blob: efdeccfe5ce5b8de436fe9224c187efa32e4f569 [file] [log] [blame]
James Zernad1e1632012-01-06 14:49:06 -08001// Copyright 2011 Google Inc. All Rights Reserved.
Pascal Massiminof61d14a2011-02-18 23:33:46 -08002//
James Zernd6406142013-06-06 23:05:58 -07003// Use of this source code is governed by a BSD-style license
4// that can be found in the COPYING file in the root of the source
5// tree. An additional intellectual property rights grant can be found
6// in the file PATENTS. All contributing project authors may
7// be found in the AUTHORS file in the root of the source tree.
Pascal Massiminof61d14a2011-02-18 23:33:46 -08008// -----------------------------------------------------------------------------
9//
10// simple command line calling the WebPEncode function.
11// Encodes a raw .YUV into WebP bitstream
12//
13// Author: Skal (pascal.massimino@gmail.com)
14
15#include <stdio.h>
Pascal Massimino4b0b0d62011-03-26 09:27:45 -070016#include <stdlib.h>
Pascal Massiminof61d14a2011-02-18 23:33:46 -080017#include <string.h>
18
James Zern31f9dc62011-06-06 17:56:50 -070019#ifdef HAVE_CONFIG_H
20#include "config.h"
21#endif
22
Pascal Massiminof61d14a2011-02-18 23:33:46 -080023#include "webp/encode.h"
skal1bd287a2012-12-11 11:02:39 +010024
James Zern63aba3a2012-12-03 18:20:00 -080025#include "./metadata.h"
James Zern00b29e22012-05-15 13:48:11 -070026#include "./stopwatch.h"
skal1bd287a2012-12-11 11:02:39 +010027
28#include "./jpegdec.h"
29#include "./pngdec.h"
James Zern1c1c5642012-12-06 14:04:36 -080030#include "./tiffdec.h"
James Zerna452a552013-01-22 18:28:52 -080031#include "./wicdec.h"
skal1bd287a2012-12-11 11:02:39 +010032
James Zernb4d0ef82011-07-15 14:53:03 -070033#ifndef WEBP_DLL
James Zern04e84cf2011-11-04 15:20:08 -070034#if defined(__cplusplus) || defined(c_plusplus)
35extern "C" {
James Zernb4d0ef82011-07-15 14:53:03 -070036#endif
Pascal Massiminocfbf88a2011-04-22 12:14:45 -070037
James Zern04e84cf2011-11-04 15:20:08 -070038extern void* VP8GetCPUInfo; // opaque forward declaration.
39
40#if defined(__cplusplus) || defined(c_plusplus)
41} // extern "C"
42#endif
43#endif // WEBP_DLL
44
James Zernc7e86ab2011-08-25 14:22:32 -070045//------------------------------------------------------------------------------
Pascal Massiminof61d14a2011-02-18 23:33:46 -080046
47static int verbose = 0;
48
49static int ReadYUV(FILE* in_file, WebPPicture* const pic) {
Pascal Massiminodd108172012-07-18 21:58:53 +000050 const int use_argb = pic->use_argb;
Pascal Massiminof61d14a2011-02-18 23:33:46 -080051 const int uv_width = (pic->width + 1) / 2;
52 const int uv_height = (pic->height + 1) / 2;
53 int y;
54 int ok = 0;
55
Pascal Massiminodd108172012-07-18 21:58:53 +000056 pic->use_argb = 0;
Pascal Massiminof61d14a2011-02-18 23:33:46 -080057 if (!WebPPictureAlloc(pic)) return ok;
58
59 for (y = 0; y < pic->height; ++y) {
60 if (fread(pic->y + y * pic->y_stride, pic->width, 1, in_file) != 1) {
61 goto End;
62 }
63 }
64 for (y = 0; y < uv_height; ++y) {
65 if (fread(pic->u + y * pic->uv_stride, uv_width, 1, in_file) != 1)
66 goto End;
67 }
68 for (y = 0; y < uv_height; ++y) {
69 if (fread(pic->v + y * pic->uv_stride, uv_width, 1, in_file) != 1)
70 goto End;
71 }
72 ok = 1;
Pascal Massiminodd108172012-07-18 21:58:53 +000073 if (use_argb) ok = WebPPictureYUVAToARGB(pic);
Pascal Massiminof61d14a2011-02-18 23:33:46 -080074
75 End:
76 return ok;
77}
78
James Zern31f9dc62011-06-06 17:56:50 -070079#ifdef HAVE_WINCODEC_H
Pascal Massiminof61d14a2011-02-18 23:33:46 -080080
Pascal Massimino2ab4b722011-04-25 16:58:04 -070081static int ReadPicture(const char* const filename, WebPPicture* const pic,
James Zern63aba3a2012-12-03 18:20:00 -080082 int keep_alpha, Metadata* const metadata) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -080083 int ok;
84 if (pic->width != 0 && pic->height != 0) {
85 // If image size is specified, infer it as YUV format.
86 FILE* in_file = fopen(filename, "rb");
87 if (in_file == NULL) {
88 fprintf(stderr, "Error! Cannot open input file '%s'\n", filename);
89 return 0;
90 }
91 ok = ReadYUV(in_file, pic);
92 fclose(in_file);
93 } else {
94 // If no size specified, try to decode it using WIC.
James Zerne83ff7d2013-01-24 15:37:49 -080095 ok = ReadPictureWithWIC(filename, pic, keep_alpha, metadata);
Pascal Massiminof61d14a2011-02-18 23:33:46 -080096 }
97 if (!ok) {
98 fprintf(stderr, "Error! Could not process file %s\n", filename);
99 }
100 return ok;
101}
102
James Zern31f9dc62011-06-06 17:56:50 -0700103#else // !HAVE_WINCODEC_H
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800104
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800105typedef enum {
James Zernd8921dd2012-07-02 11:24:23 -0700106 PNG_ = 0,
107 JPEG_,
James Zern6f76d242012-07-01 17:55:21 -0700108 TIFF_, // 'TIFF' clashes with libtiff
James Zerna0b27362012-01-27 17:39:47 -0800109 UNSUPPORTED
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800110} InputFileFormat;
111
112static InputFileFormat GetImageType(FILE* in_file) {
113 InputFileFormat format = UNSUPPORTED;
James Zernf4f90882013-04-13 10:33:41 -0700114 uint32_t magic;
115 uint8_t buf[4];
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800116
117 if ((fread(&buf[0], 4, 1, in_file) != 1) ||
118 (fseek(in_file, 0, SEEK_SET) != 0)) {
119 return format;
120 }
121
James Zernf4f90882013-04-13 10:33:41 -0700122 magic = ((uint32_t)buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800123 if (magic == 0x89504E47U) {
James Zernd8921dd2012-07-02 11:24:23 -0700124 format = PNG_;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800125 } else if (magic >= 0xFFD8FF00U && magic <= 0xFFD8FFFFU) {
James Zernd8921dd2012-07-02 11:24:23 -0700126 format = JPEG_;
James Zern6f76d242012-07-01 17:55:21 -0700127 } else if (magic == 0x49492A00 || magic == 0x4D4D002A) {
128 format = TIFF_;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800129 }
130 return format;
131}
132
Pascal Massimino2ab4b722011-04-25 16:58:04 -0700133static int ReadPicture(const char* const filename, WebPPicture* const pic,
James Zern63aba3a2012-12-03 18:20:00 -0800134 int keep_alpha, Metadata* const metadata) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800135 int ok = 0;
136 FILE* in_file = fopen(filename, "rb");
137 if (in_file == NULL) {
138 fprintf(stderr, "Error! Cannot open input file '%s'\n", filename);
139 return ok;
140 }
141
142 if (pic->width == 0 || pic->height == 0) {
143 // If no size specified, try to decode it as PNG/JPEG (as appropriate).
144 const InputFileFormat format = GetImageType(in_file);
James Zernd8921dd2012-07-02 11:24:23 -0700145 if (format == PNG_) {
James Zerndba64d92012-12-04 19:00:30 -0800146 ok = ReadPNG(in_file, pic, keep_alpha, metadata);
James Zernd8921dd2012-07-02 11:24:23 -0700147 } else if (format == JPEG_) {
James Zern2c724962012-12-16 19:13:56 -0800148 ok = ReadJPEG(in_file, pic, metadata);
James Zern6f76d242012-07-01 17:55:21 -0700149 } else if (format == TIFF_) {
James Zern2914ecf2012-12-15 19:41:03 -0800150 ok = ReadTIFF(filename, pic, keep_alpha, metadata);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800151 }
152 } else {
153 // If image size is specified, infer it as YUV format.
154 ok = ReadYUV(in_file, pic);
155 }
156 if (!ok) {
157 fprintf(stderr, "Error! Could not process file %s\n", filename);
158 }
159
160 fclose(in_file);
161 return ok;
162}
163
James Zern31f9dc62011-06-06 17:56:50 -0700164#endif // !HAVE_WINCODEC_H
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800165
166static void AllocExtraInfo(WebPPicture* const pic) {
167 const int mb_w = (pic->width + 15) / 16;
168 const int mb_h = (pic->height + 15) / 16;
169 pic->extra_info = (uint8_t*)malloc(mb_w * mb_h * sizeof(*pic->extra_info));
170}
171
172static void PrintByteCount(const int bytes[4], int total_size,
173 int* const totals) {
174 int s;
175 int total = 0;
176 for (s = 0; s < 4; ++s) {
177 fprintf(stderr, "| %7d ", bytes[s]);
178 total += bytes[s];
179 if (totals) totals[s] += bytes[s];
180 }
James Zern04e84cf2011-11-04 15:20:08 -0700181 fprintf(stderr, "| %7d (%.1f%%)\n", total, 100.f * total / total_size);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800182}
183
184static void PrintPercents(const int counts[4], int total) {
185 int s;
186 for (s = 0; s < 4; ++s) {
187 fprintf(stderr, "| %2d%%", 100 * counts[s] / total);
188 }
James Zern04e84cf2011-11-04 15:20:08 -0700189 fprintf(stderr, "| %7d\n", total);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800190}
191
192static void PrintValues(const int values[4]) {
193 int s;
194 for (s = 0; s < 4; ++s) {
195 fprintf(stderr, "| %7d ", values[s]);
196 }
James Zern04e84cf2011-11-04 15:20:08 -0700197 fprintf(stderr, "|\n");
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800198}
199
Pascal Massimino7d853d72012-07-24 16:15:36 -0700200static void PrintFullLosslessInfo(const WebPAuxStats* const stats,
201 const char* const description) {
202 fprintf(stderr, "Lossless-%s compressed size: %d bytes\n",
203 description, stats->lossless_size);
204 if (stats->lossless_features) {
205 fprintf(stderr, " * Lossless features used:");
206 if (stats->lossless_features & 1) fprintf(stderr, " PREDICTION");
207 if (stats->lossless_features & 2) fprintf(stderr, " CROSS-COLOR-TRANSFORM");
208 if (stats->lossless_features & 4) fprintf(stderr, " SUBTRACT-GREEN");
209 if (stats->lossless_features & 8) fprintf(stderr, " PALETTE");
210 fprintf(stderr, "\n");
211 }
212 fprintf(stderr, " * Precision Bits: histogram=%d transform=%d cache=%d\n",
213 stats->histogram_bits, stats->transform_bits, stats->cache_bits);
214 if (stats->palette_size > 0) {
215 fprintf(stderr, " * Palette size: %d\n", stats->palette_size);
216 }
217}
218
Vikas Arorac4ccab62012-05-09 11:27:46 +0530219static void PrintExtraInfoLossless(const WebPPicture* const pic,
220 int short_output,
221 const char* const file_name) {
222 const WebPAuxStats* const stats = pic->stats;
223 if (short_output) {
224 fprintf(stderr, "%7d %2.2f\n", stats->coded_size, stats->PSNR[3]);
225 } else {
226 fprintf(stderr, "File: %s\n", file_name);
227 fprintf(stderr, "Dimension: %d x %d\n", pic->width, pic->height);
228 fprintf(stderr, "Output: %d bytes\n", stats->coded_size);
Pascal Massimino7d853d72012-07-24 16:15:36 -0700229 PrintFullLosslessInfo(stats, "ARGB");
Vikas Arorac4ccab62012-05-09 11:27:46 +0530230 }
231}
232
233static void PrintExtraInfoLossy(const WebPPicture* const pic, int short_output,
skal9bfbdd12013-03-12 00:37:42 +0100234 int full_details,
Vikas Arorac4ccab62012-05-09 11:27:46 +0530235 const char* const file_name) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800236 const WebPAuxStats* const stats = pic->stats;
237 if (short_output) {
238 fprintf(stderr, "%7d %2.2f\n", stats->coded_size, stats->PSNR[3]);
James Zern04e84cf2011-11-04 15:20:08 -0700239 } else {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800240 const int num_i4 = stats->block_count[0];
241 const int num_i16 = stats->block_count[1];
242 const int num_skip = stats->block_count[2];
243 const int total = num_i4 + num_i16;
Pascal Massiminod61479f2012-01-20 07:20:56 -0800244 fprintf(stderr, "File: %s\n", file_name);
245 fprintf(stderr, "Dimension: %d x %d%s\n",
James Zernc71ff9e2012-06-07 17:32:29 -0700246 pic->width, pic->height,
247 stats->alpha_data_size ? " (with alpha)" : "");
Pascal Massiminod61479f2012-01-20 07:20:56 -0800248 fprintf(stderr, "Output: "
249 "%d bytes Y-U-V-All-PSNR %2.2f %2.2f %2.2f %2.2f dB\n",
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800250 stats->coded_size,
251 stats->PSNR[0], stats->PSNR[1], stats->PSNR[2], stats->PSNR[3]);
252 if (total > 0) {
253 int totals[4] = { 0, 0, 0, 0 };
254 fprintf(stderr, "block count: intra4: %d\n"
255 " intra16: %d (-> %.2f%%)\n",
256 num_i4, num_i16, 100.f * num_i16 / total);
257 fprintf(stderr, " skipped block: %d (%.2f%%)\n",
258 num_skip, 100.f * num_skip / total);
259 fprintf(stderr, "bytes used: header: %6d (%.1f%%)\n"
260 " mode-partition: %6d (%.1f%%)\n",
261 stats->header_bytes[0],
262 100.f * stats->header_bytes[0] / stats->coded_size,
263 stats->header_bytes[1],
264 100.f * stats->header_bytes[1] / stats->coded_size);
Pascal Massimino7d853d72012-07-24 16:15:36 -0700265 if (stats->alpha_data_size > 0) {
266 fprintf(stderr, " transparency: %6d (%.1f dB)\n",
267 stats->alpha_data_size, stats->PSNR[4]);
Pascal Massimino2ab4b722011-04-25 16:58:04 -0700268 }
Pascal Massimino6d0e66c2011-05-02 17:19:00 -0700269 if (stats->layer_data_size) {
270 fprintf(stderr, " enhancement: %6d\n",
271 stats->layer_data_size);
272 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800273 fprintf(stderr, " Residuals bytes "
274 "|segment 1|segment 2|segment 3"
275 "|segment 4| total\n");
skal9bfbdd12013-03-12 00:37:42 +0100276 if (full_details) {
277 fprintf(stderr, " intra4-coeffs: ");
278 PrintByteCount(stats->residual_bytes[0], stats->coded_size, totals);
279 fprintf(stderr, " intra16-coeffs: ");
280 PrintByteCount(stats->residual_bytes[1], stats->coded_size, totals);
281 fprintf(stderr, " chroma coeffs: ");
282 PrintByteCount(stats->residual_bytes[2], stats->coded_size, totals);
283 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800284 fprintf(stderr, " macroblocks: ");
285 PrintPercents(stats->segment_size, total);
286 fprintf(stderr, " quantizer: ");
287 PrintValues(stats->segment_quant);
288 fprintf(stderr, " filter level: ");
289 PrintValues(stats->segment_level);
skal9bfbdd12013-03-12 00:37:42 +0100290 if (full_details) {
291 fprintf(stderr, "------------------+---------");
292 fprintf(stderr, "+---------+---------+---------+-----------------\n");
293 fprintf(stderr, " segments total: ");
294 PrintByteCount(totals, stats->coded_size, NULL);
295 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800296 }
Pascal Massimino7d853d72012-07-24 16:15:36 -0700297 if (stats->lossless_size > 0) {
298 PrintFullLosslessInfo(stats, "alpha");
299 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800300 }
Pascal Massimino7d853d72012-07-24 16:15:36 -0700301 if (pic->extra_info != NULL) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800302 const int mb_w = (pic->width + 15) / 16;
303 const int mb_h = (pic->height + 15) / 16;
304 const int type = pic->extra_info_type;
305 int x, y;
306 for (y = 0; y < mb_h; ++y) {
307 for (x = 0; x < mb_w; ++x) {
308 const int c = pic->extra_info[x + y * mb_w];
309 if (type == 1) { // intra4/intra16
310 printf("%c", "+."[c]);
311 } else if (type == 2) { // segments
312 printf("%c", ".-*X"[c]);
313 } else if (type == 3) { // quantizers
314 printf("%.2d ", c);
315 } else if (type == 6 || type == 7) {
316 printf("%3d ", c);
317 } else {
318 printf("0x%.2x ", c);
319 }
320 }
321 printf("\n");
322 }
323 }
324}
325
James Zernc7e86ab2011-08-25 14:22:32 -0700326//------------------------------------------------------------------------------
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800327
328static int MyWriter(const uint8_t* data, size_t data_size,
329 const WebPPicture* const pic) {
330 FILE* const out = (FILE*)pic->custom_ptr;
331 return data_size ? (fwrite(data, data_size, 1, out) == 1) : 1;
332}
333
334// Dumps a picture as a PGM file using the IMC4 layout.
335static int DumpPicture(const WebPPicture* const picture, const char* PGM_name) {
336 int y;
337 const int uv_width = (picture->width + 1) / 2;
338 const int uv_height = (picture->height + 1) / 2;
339 const int stride = (picture->width + 1) & ~1;
Pascal Massimino437999f2012-06-04 15:50:05 -0700340 const int alpha_height =
341 WebPPictureHasTransparency(picture) ? picture->height : 0;
Pascal Massimino5142a0b2011-07-07 16:08:15 -0700342 const int height = picture->height + uv_height + alpha_height;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800343 FILE* const f = fopen(PGM_name, "wb");
Pascal Massiminod61479f2012-01-20 07:20:56 -0800344 if (f == NULL) return 0;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800345 fprintf(f, "P5\n%d %d\n255\n", stride, height);
346 for (y = 0; y < picture->height; ++y) {
347 if (fwrite(picture->y + y * picture->y_stride, picture->width, 1, f) != 1)
348 return 0;
349 if (picture->width & 1) fputc(0, f); // pad
350 }
351 for (y = 0; y < uv_height; ++y) {
352 if (fwrite(picture->u + y * picture->uv_stride, uv_width, 1, f) != 1)
353 return 0;
354 if (fwrite(picture->v + y * picture->uv_stride, uv_width, 1, f) != 1)
355 return 0;
356 }
Pascal Massimino5142a0b2011-07-07 16:08:15 -0700357 for (y = 0; y < alpha_height; ++y) {
358 if (fwrite(picture->a + y * picture->a_stride, picture->width, 1, f) != 1)
359 return 0;
360 if (picture->width & 1) fputc(0, f); // pad
361 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800362 fclose(f);
363 return 1;
364}
365
James Zern7eaee9f2013-01-11 12:25:36 -0800366// -----------------------------------------------------------------------------
367// Metadata writing.
368
369enum {
370 METADATA_EXIF = (1 << 0),
James Zernd8dc72a2013-03-13 14:04:20 -0700371 METADATA_ICC = (1 << 1),
James Zern7eaee9f2013-01-11 12:25:36 -0800372 METADATA_XMP = (1 << 2),
James Zernd8dc72a2013-03-13 14:04:20 -0700373 METADATA_ALL = METADATA_EXIF | METADATA_ICC | METADATA_XMP
James Zern7eaee9f2013-01-11 12:25:36 -0800374};
375
James Zern76ec5fa2013-01-14 18:32:44 -0800376static const int kChunkHeaderSize = 8;
377static const int kTagSize = 4;
378
James Zern0bc42682013-03-13 14:41:38 -0700379static void PrintMetadataInfo(const Metadata* const metadata,
380 int metadata_written) {
381 if (metadata == NULL || metadata_written == 0) return;
382
383 fprintf(stderr, "Metadata:\n");
James Zern7dd288f2013-03-15 16:42:58 -0700384 if (metadata_written & METADATA_ICC) {
James Zern14d42af2013-03-20 16:59:35 -0700385 fprintf(stderr, " * ICC profile: %6d bytes\n", (int)metadata->iccp.size);
James Zern0bc42682013-03-13 14:41:38 -0700386 }
387 if (metadata_written & METADATA_EXIF) {
James Zern14d42af2013-03-20 16:59:35 -0700388 fprintf(stderr, " * EXIF data: %6d bytes\n", (int)metadata->exif.size);
James Zern0bc42682013-03-13 14:41:38 -0700389 }
390 if (metadata_written & METADATA_XMP) {
James Zern14d42af2013-03-20 16:59:35 -0700391 fprintf(stderr, " * XMP data: %6d bytes\n", (int)metadata->xmp.size);
James Zern0bc42682013-03-13 14:41:38 -0700392 }
393}
394
James Zern76ec5fa2013-01-14 18:32:44 -0800395// Outputs, in little endian, 'num' bytes from 'val' to 'out'.
396static int WriteLE(FILE* const out, uint32_t val, int num) {
397 uint8_t buf[4];
398 int i;
399 for (i = 0; i < num; ++i) {
400 buf[i] = (uint8_t)(val & 0xff);
401 val >>= 8;
402 }
403 return (fwrite(buf, num, 1, out) == 1);
404}
405
406static int WriteLE24(FILE* const out, uint32_t val) {
407 return WriteLE(out, val, 3);
408}
409
410static int WriteLE32(FILE* const out, uint32_t val) {
411 return WriteLE(out, val, 4);
412}
413
414static int WriteMetadataChunk(FILE* const out, const char fourcc[4],
415 const MetadataPayload* const payload) {
416 const uint8_t zero = 0;
417 const size_t need_padding = payload->size & 1;
418 int ok = (fwrite(fourcc, kTagSize, 1, out) == 1);
419 ok = ok && WriteLE32(out, (uint32_t)payload->size);
420 ok = ok && (fwrite(payload->bytes, payload->size, 1, out) == 1);
421 return ok && (fwrite(&zero, need_padding, need_padding, out) == need_padding);
422}
423
424// Sets 'flag' in 'vp8x_flags' and updates 'metadata_size' with the size of the
425// chunk if there is metadata and 'keep' is true.
426static int UpdateFlagsAndSize(const MetadataPayload* const payload,
427 int keep, int flag,
428 uint32_t* vp8x_flags, uint64_t* metadata_size) {
429 if (keep && payload->bytes != NULL && payload->size > 0) {
430 *vp8x_flags |= flag;
431 *metadata_size += kChunkHeaderSize + payload->size + (payload->size & 1);
432 return 1;
433 }
434 return 0;
435}
436
437// Writes a WebP file using the image contained in 'memory_writer' and the
438// metadata from 'metadata'. Metadata is controlled by 'keep_metadata' and the
439// availability in 'metadata'. Returns true on success.
440// For details see doc/webp-container-spec.txt#extended-file-format.
441static int WriteWebPWithMetadata(FILE* const out,
442 const WebPPicture* const picture,
443 const WebPMemoryWriter* const memory_writer,
444 const Metadata* const metadata,
James Zern0bc42682013-03-13 14:41:38 -0700445 int keep_metadata,
446 int* const metadata_written) {
James Zern76ec5fa2013-01-14 18:32:44 -0800447 const char kVP8XHeader[] = "VP8X\x0a\x00\x00\x00";
448 const int kAlphaFlag = 0x10;
449 const int kEXIFFlag = 0x08;
450 const int kICCPFlag = 0x20;
451 const int kXMPFlag = 0x04;
452 const size_t kRiffHeaderSize = 12;
453 const size_t kMaxChunkPayload = ~0 - kChunkHeaderSize - 1;
454 const size_t kMinSize = kRiffHeaderSize + kChunkHeaderSize;
455 uint32_t flags = 0;
456 uint64_t metadata_size = 0;
457 const int write_exif = UpdateFlagsAndSize(&metadata->exif,
458 !!(keep_metadata & METADATA_EXIF),
459 kEXIFFlag, &flags, &metadata_size);
460 const int write_iccp = UpdateFlagsAndSize(&metadata->iccp,
James Zernd8dc72a2013-03-13 14:04:20 -0700461 !!(keep_metadata & METADATA_ICC),
James Zern76ec5fa2013-01-14 18:32:44 -0800462 kICCPFlag, &flags, &metadata_size);
463 const int write_xmp = UpdateFlagsAndSize(&metadata->xmp,
464 !!(keep_metadata & METADATA_XMP),
465 kXMPFlag, &flags, &metadata_size);
466 uint8_t* webp = memory_writer->mem;
467 size_t webp_size = memory_writer->size;
James Zern0bc42682013-03-13 14:41:38 -0700468
469 *metadata_written = 0;
470
James Zern76ec5fa2013-01-14 18:32:44 -0800471 if (webp_size < kMinSize) return 0;
472 if (webp_size - kChunkHeaderSize + metadata_size > kMaxChunkPayload) {
473 fprintf(stderr, "Error! Addition of metadata would exceed "
474 "container size limit.\n");
475 return 0;
476 }
477
478 if (metadata_size > 0) {
479 const int kVP8XChunkSize = 18;
480 const int has_vp8x = !memcmp(webp + kRiffHeaderSize, "VP8X", kTagSize);
481 const uint32_t riff_size = (uint32_t)(webp_size - kChunkHeaderSize +
482 (has_vp8x ? 0 : kVP8XChunkSize) +
483 metadata_size);
484 // RIFF
485 int ok = (fwrite(webp, kTagSize, 1, out) == 1);
486 // RIFF size (file header size is not recorded)
487 ok = ok && WriteLE32(out, riff_size);
488 webp += kChunkHeaderSize;
489 webp_size -= kChunkHeaderSize;
490 // WEBP
491 ok = ok && (fwrite(webp, kTagSize, 1, out) == 1);
492 webp += kTagSize;
493 webp_size -= kTagSize;
494 if (has_vp8x) { // update the existing VP8X flags
495 webp[kChunkHeaderSize] |= (uint8_t)(flags & 0xff);
496 ok = ok && (fwrite(webp, kVP8XChunkSize, 1, out) == 1);
497 webp_size -= kVP8XChunkSize;
498 } else {
499 const int is_lossless = !memcmp(webp, "VP8L", kTagSize);
500 // The alpha flag is forced with lossless images.
501 if (is_lossless) flags |= kAlphaFlag;
502 ok = ok && (fwrite(kVP8XHeader, kChunkHeaderSize, 1, out) == 1);
503 ok = ok && WriteLE32(out, flags);
504 ok = ok && WriteLE24(out, picture->width - 1);
505 ok = ok && WriteLE24(out, picture->height - 1);
506 }
James Zern0bc42682013-03-13 14:41:38 -0700507 if (write_iccp) {
508 ok = ok && WriteMetadataChunk(out, "ICCP", &metadata->iccp);
James Zern7dd288f2013-03-15 16:42:58 -0700509 *metadata_written |= METADATA_ICC;
James Zern0bc42682013-03-13 14:41:38 -0700510 }
James Zern76ec5fa2013-01-14 18:32:44 -0800511 // Image
512 ok = ok && (fwrite(webp, webp_size, 1, out) == 1);
James Zern0bc42682013-03-13 14:41:38 -0700513 if (write_exif) {
514 ok = ok && WriteMetadataChunk(out, "EXIF", &metadata->exif);
515 *metadata_written |= METADATA_EXIF;
516 }
517 if (write_xmp) {
518 ok = ok && WriteMetadataChunk(out, "XMP ", &metadata->xmp);
519 *metadata_written |= METADATA_XMP;
520 }
James Zern76ec5fa2013-01-14 18:32:44 -0800521 return ok;
522 } else {
523 // No metadata, just write the original image file.
524 return (fwrite(webp, webp_size, 1, out) == 1);
525 }
526}
527
James Zernc7e86ab2011-08-25 14:22:32 -0700528//------------------------------------------------------------------------------
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800529
Pascal Massimino30971c92011-12-01 02:24:50 -0800530static int ProgressReport(int percent, const WebPPicture* const picture) {
531 printf("[%s]: %3d %% \r",
James Zern475d87d2012-07-27 19:53:16 -0700532 (char*)picture->user_data, percent);
Pascal Massimino30971c92011-12-01 02:24:50 -0800533 fflush(stdout);
534 return 1; // all ok
535}
536
537//------------------------------------------------------------------------------
538
Pascal Massiminof8db5d52011-03-25 15:04:11 -0700539static void HelpShort(void) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800540 printf("Usage:\n\n");
541 printf(" cwebp [options] -q quality input.png -o output.webp\n\n");
542 printf("where quality is between 0 (poor) to 100 (very good).\n");
543 printf("Typical value is around 80.\n\n");
544 printf("Try -longhelp for an exhaustive list of advanced options.\n");
545}
546
Pascal Massiminof8db5d52011-03-25 15:04:11 -0700547static void HelpLong(void) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800548 printf("Usage:\n");
549 printf(" cwebp [-preset <...>] [options] in_file [-o out_file]\n\n");
550 printf("If input size (-s) for an image is not specified, "
James Zern12f9aed2012-07-13 14:55:39 -0700551 "it is assumed to be a PNG, JPEG or TIFF file.\n");
James Zern31f9dc62011-06-06 17:56:50 -0700552#ifdef HAVE_WINCODEC_H
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800553 printf("Windows builds can take as input any of the files handled by WIC\n");
554#endif
555 printf("options:\n");
556 printf(" -h / -help ............ short help\n");
557 printf(" -H / -longhelp ........ long help\n");
558 printf(" -q <float> ............. quality factor (0:small..100:big)\n");
Vikas Aroraa0ec9aa2011-12-01 15:11:34 +0530559 printf(" -alpha_q <int> ......... Transparency-compression quality "
560 "(0..100).\n");
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800561 printf(" -preset <string> ....... Preset setting, one of:\n");
562 printf(" default, photo, picture,\n");
563 printf(" drawing, icon, text\n");
564 printf(" -preset must come first, as it overwrites other parameters.");
565 printf("\n");
566 printf(" -m <int> ............... compression method (0=fast, 6=slowest)\n");
567 printf(" -segments <int> ........ number of segments to use (1..4)\n");
Pascal Massimino38369c02011-05-04 22:59:51 -0700568 printf(" -size <int> ............ Target size (in bytes)\n");
569 printf(" -psnr <float> .......... Target PSNR (in dB. typically: 42)\n");
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800570 printf("\n");
571 printf(" -s <int> <int> ......... Input size (width x height) for YUV\n");
572 printf(" -sns <int> ............. Spatial Noise Shaping (0:off, 100:max)\n");
573 printf(" -f <int> ............... filter strength (0=off..100)\n");
574 printf(" -sharpness <int> ....... "
575 "filter sharpness (0:most .. 7:least sharp)\n");
Pascal Massimino92668da2013-02-15 01:08:52 -0800576 printf(" -strong ................ use strong filter instead "
577 "of simple (default).\n");
578 printf(" -nostrong .............. use simple filter instead of strong.\n");
Pascal Massimino900286e2011-08-23 15:58:22 -0700579 printf(" -partition_limit <int> . limit quality to fit the 512k limit on\n");
580 printf(" "
581 "the first partition (0=no degradation ... 100=full)\n");
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800582 printf(" -pass <int> ............ analysis pass number (1..10)\n");
583 printf(" -crop <x> <y> <w> <h> .. crop picture with the given rectangle\n");
Pascal Massimino6d0e66c2011-05-02 17:19:00 -0700584 printf(" -resize <w> <h> ........ resize picture (after any cropping)\n");
skalf8179302013-03-01 01:21:34 +0100585 printf(" -mt .................... use multi-threading if available\n");
skal9bfbdd12013-03-12 00:37:42 +0100586 printf(" -low_memory ............ reduce memory usage (slower encoding)\n");
Pascal Massimino6d0e66c2011-05-02 17:19:00 -0700587#ifdef WEBP_EXPERIMENTAL_FEATURES
588 printf(" -444 / -422 / -gray ..... Change colorspace\n");
589#endif
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800590 printf(" -map <int> ............. print map of extra info.\n");
Pascal Massiminod61479f2012-01-20 07:20:56 -0800591 printf(" -print_psnr ............ prints averaged PSNR distortion.\n");
Pascal Massiminof86e6ab2012-10-18 08:26:40 -0700592 printf(" -print_ssim ............ prints averaged SSIM distortion.\n");
593 printf(" -print_lsim ............ prints local-similarity distortion.\n");
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800594 printf(" -d <file.pgm> .......... dump the compressed output (PGM file).\n");
Vikas Aroraa0ec9aa2011-12-01 15:11:34 +0530595 printf(" -alpha_method <int> .... Transparency-compression method (0..1)\n");
Pascal Massimino8ca20762012-01-08 19:27:21 -0800596 printf(" -alpha_filter <string> . predictive filtering for alpha plane.\n");
597 printf(" One of: none, fast (default) or best.\n");
Pascal Massimino2e3e8b22012-01-17 08:18:22 +0000598 printf(" -alpha_cleanup ......... Clean RGB values in transparent area.\n");
Pascal Massiminoe7d95482013-04-02 19:14:14 -0700599 printf(" -blend_alpha <hex> ..... Blend colors against background color\n"
600 " expressed as RGB values written in\n"
601 " hexadecimal, e.g. 0xc0e0d0 for red=0xc0\n"
602 " green=0xe0 and blue=0xd0.\n");
Vikas Aroraa0ec9aa2011-12-01 15:11:34 +0530603 printf(" -noalpha ............... discard any transparency information.\n");
Vikas Arorad3730762012-06-22 12:14:48 +0530604 printf(" -lossless .............. Encode image losslessly.\n");
605 printf(" -hint <string> ......... Specify image characteristics hint.\n");
Vikas Aroradd1c3872012-07-31 23:07:52 -0700606 printf(" One of: photo, picture or graph\n");
Pascal Massimino6d0e66c2011-05-02 17:19:00 -0700607
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800608 printf("\n");
James Zern7eaee9f2013-01-11 12:25:36 -0800609 printf(" -metadata <string> ..... comma separated list of metadata to\n");
610 printf(" ");
611 printf("copy from the input to the output if present.\n");
612 printf(" "
James Zernd8dc72a2013-03-13 14:04:20 -0700613 "Valid values: all, none (default), exif, icc, xmp\n");
James Zern7eaee9f2013-01-11 12:25:36 -0800614
615 printf("\n");
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800616 printf(" -short ................. condense printed message\n");
617 printf(" -quiet ................. don't print anything.\n");
Pascal Massimino650ffa32011-03-24 16:17:10 -0700618 printf(" -version ............... print version number and exit.\n");
James Zernb4d0ef82011-07-15 14:53:03 -0700619#ifndef WEBP_DLL
Pascal Massiminocfbf88a2011-04-22 12:14:45 -0700620 printf(" -noasm ................. disable all assembly optimizations.\n");
James Zernb4d0ef82011-07-15 14:53:03 -0700621#endif
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800622 printf(" -v ..................... verbose, e.g. print encoding/decoding "
623 "times\n");
Pascal Massimino30971c92011-12-01 02:24:50 -0800624 printf(" -progress .............. report encoding progress\n");
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800625 printf("\n");
626 printf("Experimental Options:\n");
skale8950592013-02-05 19:40:18 +0100627 printf(" -jpeg_like ............. Roughly match expected JPEG size.\n");
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800628 printf(" -af .................... auto-adjust filter strength.\n");
629 printf(" -pre <int> ............. pre-processing filter\n");
630 printf("\n");
631}
632
James Zernc7e86ab2011-08-25 14:22:32 -0700633//------------------------------------------------------------------------------
Pascal Massiminoca7a2fd2011-06-02 06:55:03 -0700634// Error messages
635
636static const char* const kErrorMessages[] = {
637 "OK",
638 "OUT_OF_MEMORY: Out of memory allocating objects",
639 "BITSTREAM_OUT_OF_MEMORY: Out of memory re-allocating byte buffer",
640 "NULL_PARAMETER: NULL parameter passed to function",
641 "INVALID_CONFIGURATION: configuration is invalid",
Pascal Massimino900286e2011-08-23 15:58:22 -0700642 "BAD_DIMENSION: Bad picture dimension. Maximum width and height "
643 "allowed is 16383 pixels.",
644 "PARTITION0_OVERFLOW: Partition #0 is too big to fit 512k.\n"
645 "To reduce the size of this partition, try using less segments "
646 "with the -segments option, and eventually reduce the number of "
647 "header bits using -partition_limit. More details are available "
648 "in the manual (`man cwebp`)",
649 "PARTITION_OVERFLOW: Partition is too big to fit 16M",
Pascal Massiminod71fbdc2011-12-01 03:34:22 -0800650 "BAD_WRITE: Picture writer returned an I/O error",
Pascal Massimino30971c92011-12-01 02:24:50 -0800651 "FILE_TOO_BIG: File would be too big to fit in 4G",
652 "USER_ABORT: encoding abort requested by user"
Pascal Massiminoca7a2fd2011-06-02 06:55:03 -0700653};
654
James Zernc7e86ab2011-08-25 14:22:32 -0700655//------------------------------------------------------------------------------
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800656
657int main(int argc, const char *argv[]) {
Pascal Massimino4abe04a2012-05-09 00:32:20 -0700658 int return_value = -1;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800659 const char *in_file = NULL, *out_file = NULL, *dump_file = NULL;
660 FILE *out = NULL;
661 int c;
662 int short_output = 0;
663 int quiet = 0;
Vikas Aroraa0ec9aa2011-12-01 15:11:34 +0530664 int keep_alpha = 1;
Pascal Massiminoe7d95482013-04-02 19:14:14 -0700665 int blend_alpha = 0;
666 uint32_t background_color = 0xffffffu;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800667 int crop = 0, crop_x = 0, crop_y = 0, crop_w = 0, crop_h = 0;
Pascal Massimino6d0e66c2011-05-02 17:19:00 -0700668 int resize_w = 0, resize_h = 0;
Pascal Massimino30971c92011-12-01 02:24:50 -0800669 int show_progress = 0;
James Zern7eaee9f2013-01-11 12:25:36 -0800670 int keep_metadata = 0;
James Zern0bc42682013-03-13 14:41:38 -0700671 int metadata_written = 0;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800672 WebPPicture picture;
Pascal Massiminof86e6ab2012-10-18 08:26:40 -0700673 int print_distortion = -1; // -1=off, 0=PSNR, 1=SSIM, 2=LSIM
Pascal Massiminod61479f2012-01-20 07:20:56 -0800674 WebPPicture original_picture; // when PSNR or SSIM is requested
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800675 WebPConfig config;
676 WebPAuxStats stats;
James Zern76ec5fa2013-01-14 18:32:44 -0800677 WebPMemoryWriter memory_writer;
James Zern63aba3a2012-12-03 18:20:00 -0800678 Metadata metadata;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800679 Stopwatch stop_watch;
Pascal Massimino6d0e66c2011-05-02 17:19:00 -0700680
James Zern63aba3a2012-12-03 18:20:00 -0800681 MetadataInit(&metadata);
James Zern88d382a2013-02-01 19:17:26 -0800682 WebPMemoryWriterInit(&memory_writer);
Pascal Massiminod61479f2012-01-20 07:20:56 -0800683 if (!WebPPictureInit(&picture) ||
684 !WebPPictureInit(&original_picture) ||
685 !WebPConfigInit(&config)) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800686 fprintf(stderr, "Error! Version mismatch!\n");
James Zern256afef2012-07-27 18:56:55 -0700687 return -1;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800688 }
689
690 if (argc == 1) {
691 HelpShort();
692 return 0;
693 }
694
695 for (c = 1; c < argc; ++c) {
696 if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
697 HelpShort();
698 return 0;
699 } else if (!strcmp(argv[c], "-H") || !strcmp(argv[c], "-longhelp")) {
700 HelpLong();
701 return 0;
702 } else if (!strcmp(argv[c], "-o") && c < argc - 1) {
703 out_file = argv[++c];
704 } else if (!strcmp(argv[c], "-d") && c < argc - 1) {
705 dump_file = argv[++c];
706 config.show_compressed = 1;
Pascal Massiminod61479f2012-01-20 07:20:56 -0800707 } else if (!strcmp(argv[c], "-print_psnr")) {
708 config.show_compressed = 1;
Pascal Massiminof86e6ab2012-10-18 08:26:40 -0700709 print_distortion = 0;
710 } else if (!strcmp(argv[c], "-print_ssim")) {
711 config.show_compressed = 1;
Pascal Massiminod61479f2012-01-20 07:20:56 -0800712 print_distortion = 1;
Pascal Massiminof86e6ab2012-10-18 08:26:40 -0700713 } else if (!strcmp(argv[c], "-print_lsim")) {
714 config.show_compressed = 1;
715 print_distortion = 2;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800716 } else if (!strcmp(argv[c], "-short")) {
717 short_output++;
718 } else if (!strcmp(argv[c], "-s") && c < argc - 2) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700719 picture.width = strtol(argv[++c], NULL, 0);
720 picture.height = strtol(argv[++c], NULL, 0);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800721 } else if (!strcmp(argv[c], "-m") && c < argc - 1) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700722 config.method = strtol(argv[++c], NULL, 0);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800723 } else if (!strcmp(argv[c], "-q") && c < argc - 1) {
Mikolaj Zalewski2aa6b802011-06-28 16:02:56 +0200724 config.quality = (float)strtod(argv[++c], NULL);
Vikas Aroraa0ec9aa2011-12-01 15:11:34 +0530725 } else if (!strcmp(argv[c], "-alpha_q") && c < argc - 1) {
726 config.alpha_quality = strtol(argv[++c], NULL, 0);
727 } else if (!strcmp(argv[c], "-alpha_method") && c < argc - 1) {
728 config.alpha_compression = strtol(argv[++c], NULL, 0);
Pascal Massimino2e3e8b22012-01-17 08:18:22 +0000729 } else if (!strcmp(argv[c], "-alpha_cleanup")) {
730 keep_alpha = keep_alpha ? 2 : 0;
Pascal Massiminoe7d95482013-04-02 19:14:14 -0700731 } else if (!strcmp(argv[c], "-blend_alpha") && c < argc - 1) {
732 blend_alpha = 1;
733 background_color = strtol(argv[++c], NULL, 16); // <- parses '0x' prefix
734 background_color = background_color & 0x00ffffffu;
Vikas Arora252028a2012-01-05 13:04:30 +0530735 } else if (!strcmp(argv[c], "-alpha_filter") && c < argc - 1) {
Pascal Massimino8ca20762012-01-08 19:27:21 -0800736 ++c;
737 if (!strcmp(argv[c], "none")) {
738 config.alpha_filtering = 0;
739 } else if (!strcmp(argv[c], "fast")) {
740 config.alpha_filtering = 1;
741 } else if (!strcmp(argv[c], "best")) {
742 config.alpha_filtering = 2;
743 } else {
744 fprintf(stderr, "Error! Unrecognized alpha filter: %s\n", argv[c]);
745 goto Error;
746 }
Vikas Aroraa0ec9aa2011-12-01 15:11:34 +0530747 } else if (!strcmp(argv[c], "-noalpha")) {
748 keep_alpha = 0;
Pascal Massimino72920ca2012-04-24 10:59:08 +0000749 } else if (!strcmp(argv[c], "-lossless")) {
750 config.lossless = 1;
Vikas Arorad3730762012-06-22 12:14:48 +0530751 } else if (!strcmp(argv[c], "-hint") && c < argc - 1) {
752 ++c;
753 if (!strcmp(argv[c], "photo")) {
754 config.image_hint = WEBP_HINT_PHOTO;
755 } else if (!strcmp(argv[c], "picture")) {
756 config.image_hint = WEBP_HINT_PICTURE;
Vikas Aroradd1c3872012-07-31 23:07:52 -0700757 } else if (!strcmp(argv[c], "graph")) {
758 config.image_hint = WEBP_HINT_GRAPH;
Vikas Arorad3730762012-06-22 12:14:48 +0530759 } else {
760 fprintf(stderr, "Error! Unrecognized image hint: %s\n", argv[c]);
761 goto Error;
762 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800763 } else if (!strcmp(argv[c], "-size") && c < argc - 1) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700764 config.target_size = strtol(argv[++c], NULL, 0);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800765 } else if (!strcmp(argv[c], "-psnr") && c < argc - 1) {
Mikolaj Zalewski2aa6b802011-06-28 16:02:56 +0200766 config.target_PSNR = (float)strtod(argv[++c], NULL);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800767 } else if (!strcmp(argv[c], "-sns") && c < argc - 1) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700768 config.sns_strength = strtol(argv[++c], NULL, 0);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800769 } else if (!strcmp(argv[c], "-f") && c < argc - 1) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700770 config.filter_strength = strtol(argv[++c], NULL, 0);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800771 } else if (!strcmp(argv[c], "-af")) {
772 config.autofilter = 1;
skale8950592013-02-05 19:40:18 +0100773 } else if (!strcmp(argv[c], "-jpeg_like")) {
774 config.emulate_jpeg_size = 1;
skalf8179302013-03-01 01:21:34 +0100775 } else if (!strcmp(argv[c], "-mt")) {
776 ++config.thread_level; // increase thread level
skal9bfbdd12013-03-12 00:37:42 +0100777 } else if (!strcmp(argv[c], "-low_memory")) {
778 config.low_memory = 1;
Pascal Massimino842c0092011-05-05 18:10:08 -0700779 } else if (!strcmp(argv[c], "-strong")) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800780 config.filter_type = 1;
Pascal Massimino92668da2013-02-15 01:08:52 -0800781 } else if (!strcmp(argv[c], "-nostrong")) {
782 config.filter_type = 0;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800783 } else if (!strcmp(argv[c], "-sharpness") && c < argc - 1) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700784 config.filter_sharpness = strtol(argv[++c], NULL, 0);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800785 } else if (!strcmp(argv[c], "-pass") && c < argc - 1) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700786 config.pass = strtol(argv[++c], NULL, 0);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800787 } else if (!strcmp(argv[c], "-pre") && c < argc - 1) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700788 config.preprocessing = strtol(argv[++c], NULL, 0);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800789 } else if (!strcmp(argv[c], "-segments") && c < argc - 1) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700790 config.segments = strtol(argv[++c], NULL, 0);
Pascal Massimino900286e2011-08-23 15:58:22 -0700791 } else if (!strcmp(argv[c], "-partition_limit") && c < argc - 1) {
792 config.partition_limit = strtol(argv[++c], NULL, 0);
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800793 } else if (!strcmp(argv[c], "-map") && c < argc - 1) {
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700794 picture.extra_info_type = strtol(argv[++c], NULL, 0);
Pascal Massimino6d0e66c2011-05-02 17:19:00 -0700795#ifdef WEBP_EXPERIMENTAL_FEATURES
796 } else if (!strcmp(argv[c], "-444")) {
797 picture.colorspace = WEBP_YUV444;
798 } else if (!strcmp(argv[c], "-422")) {
799 picture.colorspace = WEBP_YUV422;
800 } else if (!strcmp(argv[c], "-gray")) {
801 picture.colorspace = WEBP_YUV400;
802#endif
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800803 } else if (!strcmp(argv[c], "-crop") && c < argc - 4) {
804 crop = 1;
Pascal Massimino4b0b0d62011-03-26 09:27:45 -0700805 crop_x = strtol(argv[++c], NULL, 0);
806 crop_y = strtol(argv[++c], NULL, 0);
807 crop_w = strtol(argv[++c], NULL, 0);
808 crop_h = strtol(argv[++c], NULL, 0);
Pascal Massimino6d0e66c2011-05-02 17:19:00 -0700809 } else if (!strcmp(argv[c], "-resize") && c < argc - 2) {
810 resize_w = strtol(argv[++c], NULL, 0);
811 resize_h = strtol(argv[++c], NULL, 0);
James Zernb4d0ef82011-07-15 14:53:03 -0700812#ifndef WEBP_DLL
Pascal Massiminocfbf88a2011-04-22 12:14:45 -0700813 } else if (!strcmp(argv[c], "-noasm")) {
Pascal Massiminoe06ac082011-09-02 21:30:08 +0000814 VP8GetCPUInfo = NULL;
James Zernb4d0ef82011-07-15 14:53:03 -0700815#endif
Pascal Massimino650ffa32011-03-24 16:17:10 -0700816 } else if (!strcmp(argv[c], "-version")) {
817 const int version = WebPGetEncoderVersion();
818 printf("%d.%d.%d\n",
819 (version >> 16) & 0xff, (version >> 8) & 0xff, version & 0xff);
820 return 0;
Pascal Massimino30971c92011-12-01 02:24:50 -0800821 } else if (!strcmp(argv[c], "-progress")) {
822 show_progress = 1;
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800823 } else if (!strcmp(argv[c], "-quiet")) {
824 quiet = 1;
825 } else if (!strcmp(argv[c], "-preset") && c < argc - 1) {
826 WebPPreset preset;
827 ++c;
828 if (!strcmp(argv[c], "default")) {
829 preset = WEBP_PRESET_DEFAULT;
830 } else if (!strcmp(argv[c], "photo")) {
831 preset = WEBP_PRESET_PHOTO;
832 } else if (!strcmp(argv[c], "picture")) {
833 preset = WEBP_PRESET_PICTURE;
834 } else if (!strcmp(argv[c], "drawing")) {
835 preset = WEBP_PRESET_DRAWING;
836 } else if (!strcmp(argv[c], "icon")) {
837 preset = WEBP_PRESET_ICON;
838 } else if (!strcmp(argv[c], "text")) {
839 preset = WEBP_PRESET_TEXT;
840 } else {
841 fprintf(stderr, "Error! Unrecognized preset: %s\n", argv[c]);
842 goto Error;
843 }
844 if (!WebPConfigPreset(&config, preset, config.quality)) {
Pascal Massimino6d978a62011-03-17 14:49:19 -0700845 fprintf(stderr, "Error! Could initialize configuration with preset.\n");
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800846 goto Error;
847 }
James Zern7eaee9f2013-01-11 12:25:36 -0800848 } else if (!strcmp(argv[c], "-metadata") && c < argc - 1) {
849 static const struct {
850 const char* option;
851 int flag;
852 } kTokens[] = {
853 { "all", METADATA_ALL },
854 { "none", 0 },
855 { "exif", METADATA_EXIF },
James Zernd8dc72a2013-03-13 14:04:20 -0700856 { "icc", METADATA_ICC },
James Zern7eaee9f2013-01-11 12:25:36 -0800857 { "xmp", METADATA_XMP },
858 };
859 const size_t kNumTokens = sizeof(kTokens) / sizeof(kTokens[0]);
860 const char* start = argv[++c];
861 const char* const end = start + strlen(start);
862
863 while (start < end) {
864 size_t i;
865 const char* token = strchr(start, ',');
866 if (token == NULL) token = end;
867
868 for (i = 0; i < kNumTokens; ++i) {
869 if ((size_t)(token - start) == strlen(kTokens[i].option) &&
870 !strncmp(start, kTokens[i].option, strlen(kTokens[i].option))) {
871 if (kTokens[i].flag != 0) {
872 keep_metadata |= kTokens[i].flag;
873 } else {
874 keep_metadata = 0;
875 }
876 break;
877 }
878 }
879 if (i == kNumTokens) {
880 fprintf(stderr, "Error! Unknown metadata type '%.*s'\n",
881 (int)(token - start), start);
882 HelpLong();
883 return -1;
884 }
885 start = token + 1;
886 }
James Zern76ec5fa2013-01-14 18:32:44 -0800887#ifdef HAVE_WINCODEC_H
James Zernd8dc72a2013-03-13 14:04:20 -0700888 if (keep_metadata != 0 && keep_metadata != METADATA_ICC) {
James Zern7eaee9f2013-01-11 12:25:36 -0800889 // TODO(jzern): remove when -metadata is supported on all platforms.
James Zerne83ff7d2013-01-24 15:37:49 -0800890 fprintf(stderr, "Warning: only ICC profile extraction is currently"
891 " supported on this platform!\n");
James Zern7eaee9f2013-01-11 12:25:36 -0800892 }
James Zern76ec5fa2013-01-14 18:32:44 -0800893#endif
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800894 } else if (!strcmp(argv[c], "-v")) {
895 verbose = 1;
896 } else if (argv[c][0] == '-') {
897 fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
898 HelpLong();
899 return -1;
900 } else {
901 in_file = argv[c];
902 }
903 }
Pascal Massimino4abe04a2012-05-09 00:32:20 -0700904 if (in_file == NULL) {
905 fprintf(stderr, "No input file specified!\n");
906 HelpShort();
907 goto Error;
908 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800909
Vikas Arorab7fb0ed2012-06-20 09:02:25 +0530910 // Check for unsupported command line options for lossless mode and log
911 // warning for such options.
Pascal Massimino02751592012-06-20 09:20:34 +0000912 if (!quiet && config.lossless == 1) {
Vikas Arorab7fb0ed2012-06-20 09:02:25 +0530913 if (config.target_size > 0 || config.target_PSNR > 0) {
914 fprintf(stderr, "Encoding for specified size or PSNR is not supported"
915 " for lossless encoding. Ignoring such option(s)!\n");
916 }
917 if (config.partition_limit > 0) {
918 fprintf(stderr, "Partition limit option is not required for lossless"
919 " encoding. Ignoring this option!\n");
920 }
Vikas Arorab7fb0ed2012-06-20 09:02:25 +0530921 }
922
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800923 if (!WebPValidateConfig(&config)) {
924 fprintf(stderr, "Error! Invalid configuration.\n");
925 goto Error;
926 }
927
Pascal Massimino0744e842011-02-25 12:03:27 -0800928 // Read the input
Pascal Massimino38369c02011-05-04 22:59:51 -0700929 if (verbose) {
Pascal Massimino0744e842011-02-25 12:03:27 -0800930 StopwatchReadAndReset(&stop_watch);
Pascal Massimino38369c02011-05-04 22:59:51 -0700931 }
James Zern7eaee9f2013-01-11 12:25:36 -0800932 if (!ReadPicture(in_file, &picture, keep_alpha,
933 (keep_metadata == 0) ? NULL : &metadata)) {
Pascal Massiminod61479f2012-01-20 07:20:56 -0800934 fprintf(stderr, "Error! Cannot read input picture file '%s'\n", in_file);
Pascal Massimino6d978a62011-03-17 14:49:19 -0700935 goto Error;
936 }
Pascal Massimino30971c92011-12-01 02:24:50 -0800937 picture.progress_hook = (show_progress && !quiet) ? ProgressReport : NULL;
Pascal Massiminoe7d95482013-04-02 19:14:14 -0700938
939 if (blend_alpha) {
940 WebPBlendAlpha(&picture, background_color);
941 }
942
James Zern7c732e52013-02-01 20:04:20 -0800943 if (keep_alpha == 2) {
944 WebPCleanupTransparentArea(&picture);
945 }
Pascal Massimino30971c92011-12-01 02:24:50 -0800946
Pascal Massimino0744e842011-02-25 12:03:27 -0800947 if (verbose) {
Pascal Massimino126c0352013-01-25 00:44:16 -0800948 const double read_time = StopwatchReadAndReset(&stop_watch);
949 fprintf(stderr, "Time to read input: %.3fs\n", read_time);
Pascal Massimino0744e842011-02-25 12:03:27 -0800950 }
951
952 // Open the output
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800953 if (out_file) {
954 out = fopen(out_file, "wb");
Pascal Massiminod61479f2012-01-20 07:20:56 -0800955 if (out == NULL) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800956 fprintf(stderr, "Error! Cannot open output file '%s'\n", out_file);
957 goto Error;
958 } else {
959 if (!short_output && !quiet) {
960 fprintf(stderr, "Saving file '%s'\n", out_file);
961 }
962 }
James Zern76ec5fa2013-01-14 18:32:44 -0800963 if (keep_metadata == 0) {
964 picture.writer = MyWriter;
965 picture.custom_ptr = (void*)out;
966 } else {
James Zern76ec5fa2013-01-14 18:32:44 -0800967 picture.writer = WebPMemoryWrite;
968 picture.custom_ptr = (void*)&memory_writer;
969 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800970 } else {
971 out = NULL;
972 if (!quiet && !short_output) {
973 fprintf(stderr, "No output file specified (no -o flag). Encoding will\n");
974 fprintf(stderr, "be performed, but its results discarded.\n\n");
975 }
976 }
Pascal Massimino7d853d72012-07-24 16:15:36 -0700977 if (!quiet) {
978 picture.stats = &stats;
James Zern475d87d2012-07-27 19:53:16 -0700979 picture.user_data = (void*)in_file;
Pascal Massimino7d853d72012-07-24 16:15:36 -0700980 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800981
Pascal Massimino0744e842011-02-25 12:03:27 -0800982 // Compress
Pascal Massimino38369c02011-05-04 22:59:51 -0700983 if (verbose) {
Pascal Massiminof61d14a2011-02-18 23:33:46 -0800984 StopwatchReadAndReset(&stop_watch);
Pascal Massimino38369c02011-05-04 22:59:51 -0700985 }
Pascal Massimino31b68fe2012-06-21 00:30:43 -0700986 if (crop != 0) {
987 // We use self-cropping using a view.
988 if (!WebPPictureView(&picture, crop_x, crop_y, crop_w, crop_h, &picture)) {
989 fprintf(stderr, "Error! Cannot crop picture\n");
990 goto Error;
991 }
Pascal Massimino6d978a62011-03-17 14:49:19 -0700992 }
Pascal Massimino6d0e66c2011-05-02 17:19:00 -0700993 if ((resize_w | resize_h) > 0) {
994 if (!WebPPictureRescale(&picture, resize_w, resize_h)) {
995 fprintf(stderr, "Error! Cannot resize picture\n");
996 goto Error;
997 }
998 }
999 if (picture.extra_info_type > 0) {
1000 AllocExtraInfo(&picture);
1001 }
Pascal Massiminof86e6ab2012-10-18 08:26:40 -07001002 if (print_distortion >= 0) { // Save original picture for later comparison
Pascal Massiminod61479f2012-01-20 07:20:56 -08001003 WebPPictureCopy(&picture, &original_picture);
1004 }
Pascal Massimino6d978a62011-03-17 14:49:19 -07001005 if (!WebPEncode(&config, &picture)) {
1006 fprintf(stderr, "Error! Cannot encode picture as WebP\n");
Pascal Massiminoca7a2fd2011-06-02 06:55:03 -07001007 fprintf(stderr, "Error code: %d (%s)\n",
1008 picture.error_code, kErrorMessages[picture.error_code]);
Pascal Massimino6d978a62011-03-17 14:49:19 -07001009 goto Error;
1010 }
Pascal Massiminof61d14a2011-02-18 23:33:46 -08001011 if (verbose) {
Pascal Massimino126c0352013-01-25 00:44:16 -08001012 const double encode_time = StopwatchReadAndReset(&stop_watch);
1013 fprintf(stderr, "Time to encode picture: %.3fs\n", encode_time);
Pascal Massiminof61d14a2011-02-18 23:33:46 -08001014 }
Pascal Massimino0744e842011-02-25 12:03:27 -08001015
1016 // Write info
Pascal Massimino38369c02011-05-04 22:59:51 -07001017 if (dump_file) {
Pascal Massiminodd108172012-07-18 21:58:53 +00001018 if (picture.use_argb) {
Pascal Massimino437999f2012-06-04 15:50:05 -07001019 fprintf(stderr, "Warning: can't dump file (-d option) in lossless mode.");
1020 } else if (!DumpPicture(&picture, dump_file)) {
1021 fprintf(stderr, "Warning, couldn't dump picture %s\n", dump_file);
1022 }
Pascal Massimino38369c02011-05-04 22:59:51 -07001023 }
Pascal Massiminod61479f2012-01-20 07:20:56 -08001024
James Zern76ec5fa2013-01-14 18:32:44 -08001025 if (keep_metadata != 0 && out != NULL) {
1026 if (!WriteWebPWithMetadata(out, &picture, &memory_writer,
James Zern0bc42682013-03-13 14:41:38 -07001027 &metadata, keep_metadata, &metadata_written)) {
James Zern76ec5fa2013-01-14 18:32:44 -08001028 fprintf(stderr, "Error writing WebP file with metadata!\n");
1029 goto Error;
1030 }
1031 }
1032
Pascal Massimino38369c02011-05-04 22:59:51 -07001033 if (!quiet) {
Vikas Arorac4ccab62012-05-09 11:27:46 +05301034 if (config.lossless) {
1035 PrintExtraInfoLossless(&picture, short_output, in_file);
1036 } else {
skal9bfbdd12013-03-12 00:37:42 +01001037 PrintExtraInfoLossy(&picture, short_output, config.low_memory, in_file);
Vikas Arorac4ccab62012-05-09 11:27:46 +05301038 }
James Zern0bc42682013-03-13 14:41:38 -07001039 if (!short_output) {
1040 PrintMetadataInfo(&metadata, metadata_written);
1041 }
Pascal Massiminod61479f2012-01-20 07:20:56 -08001042 }
Pascal Massiminof86e6ab2012-10-18 08:26:40 -07001043 if (!quiet && !short_output && print_distortion >= 0) { // print distortion
1044 static const char* distortion_names[] = { "PSNR", "SSIM", "LSIM" };
Pascal Massiminod61479f2012-01-20 07:20:56 -08001045 float values[5];
1046 WebPPictureDistortion(&picture, &original_picture,
Pascal Massiminof86e6ab2012-10-18 08:26:40 -07001047 print_distortion, values);
Pascal Massiminod61479f2012-01-20 07:20:56 -08001048 fprintf(stderr, "%s: Y:%.2f U:%.2f V:%.2f A:%.2f Total:%.2f\n",
Pascal Massiminof86e6ab2012-10-18 08:26:40 -07001049 distortion_names[print_distortion],
Pascal Massiminod61479f2012-01-20 07:20:56 -08001050 values[0], values[1], values[2], values[3], values[4]);
Pascal Massimino38369c02011-05-04 22:59:51 -07001051 }
Pascal Massimino4abe04a2012-05-09 00:32:20 -07001052 return_value = 0;
Pascal Massiminof61d14a2011-02-18 23:33:46 -08001053
1054 Error:
James Zern88d382a2013-02-01 19:17:26 -08001055 free(memory_writer.mem);
Pascal Massiminof61d14a2011-02-18 23:33:46 -08001056 free(picture.extra_info);
James Zern63aba3a2012-12-03 18:20:00 -08001057 MetadataFree(&metadata);
Pascal Massiminof61d14a2011-02-18 23:33:46 -08001058 WebPPictureFree(&picture);
Pascal Massiminod61479f2012-01-20 07:20:56 -08001059 WebPPictureFree(&original_picture);
Pascal Massiminof61d14a2011-02-18 23:33:46 -08001060 if (out != NULL) {
1061 fclose(out);
1062 }
1063
Pascal Massimino4abe04a2012-05-09 00:32:20 -07001064 return return_value;
Pascal Massiminof61d14a2011-02-18 23:33:46 -08001065}
1066
James Zernc7e86ab2011-08-25 14:22:32 -07001067//------------------------------------------------------------------------------