mirror of
https://github.com/webmproject/libwebp.git
synced 2024-11-20 12:28:26 +01:00
9273e441da
Encoder: We were always using ExtraSamples=1, which means associated-alpha. But we don't need the (lossy) excursion to rgbA format. We can save the samples as RGBA directly, by changing ExtraSamples to '2'. The TIFF encoder now checks the colorspace properly, to handle premultiplied format as well as non-premultiplied. Decoder: The result of TIFFReadRGBAImageOriented() is always pre-multiply. So, in case an alpha channel is present, we need to unmultiply it before calling WebPPictureImportRGBA(). See: https://www.itu.int/itudoc/itu-t/com16/tiff-fx/docs/tiff6.pdf (page 31) and also http://www.asmail.be/msg0055469184.html Change-Id: I3258bfdb0eb2e1a53d6c04414f55edb2926c938c
418 lines
15 KiB
C
418 lines
15 KiB
C
// Copyright 2010 Google Inc. All Rights Reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style license
|
|
// that can be found in the COPYING file in the root of the source
|
|
// tree. An additional intellectual property rights grant can be found
|
|
// in the file PATENTS. All contributing project authors may
|
|
// be found in the AUTHORS file in the root of the source tree.
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// Command-line tool for decoding a WebP image.
|
|
//
|
|
// Author: Skal (pascal.massimino@gmail.com)
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "webp/config.h"
|
|
#endif
|
|
|
|
#include "../examples/example_util.h"
|
|
#include "../imageio/image_enc.h"
|
|
#include "../imageio/webpdec.h"
|
|
#include "./stopwatch.h"
|
|
|
|
static int verbose = 0;
|
|
static int quiet = 0;
|
|
#ifndef WEBP_DLL
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern void* VP8GetCPUInfo; // opaque forward declaration.
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
#endif // WEBP_DLL
|
|
|
|
|
|
static int SaveOutput(const WebPDecBuffer* const buffer,
|
|
WebPOutputFileFormat format, const char* const out_file) {
|
|
const int use_stdout = (out_file != NULL) && !strcmp(out_file, "-");
|
|
int ok = 1;
|
|
Stopwatch stop_watch;
|
|
|
|
if (verbose) {
|
|
StopwatchReset(&stop_watch);
|
|
}
|
|
ok = WebPSaveImage(buffer, format, out_file);
|
|
|
|
if (ok) {
|
|
if (!quiet) {
|
|
if (use_stdout) {
|
|
fprintf(stderr, "Saved to stdout\n");
|
|
} else {
|
|
fprintf(stderr, "Saved file %s\n", out_file);
|
|
}
|
|
}
|
|
if (verbose) {
|
|
const double write_time = StopwatchReadAndReset(&stop_watch);
|
|
fprintf(stderr, "Time to write output: %.3fs\n", write_time);
|
|
}
|
|
} else {
|
|
if (use_stdout) {
|
|
fprintf(stderr, "Error writing to stdout !!\n");
|
|
} else {
|
|
fprintf(stderr, "Error writing file %s !!\n", out_file);
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
static void Help(void) {
|
|
printf("Usage: dwebp in_file [options] [-o out_file]\n\n"
|
|
"Decodes the WebP image file to PNG format [Default]\n"
|
|
"Use following options to convert into alternate image formats:\n"
|
|
" -pam ......... save the raw RGBA samples as a color PAM\n"
|
|
" -ppm ......... save the raw RGB samples as a color PPM\n"
|
|
" -bmp ......... save as uncompressed BMP format\n"
|
|
" -tiff ........ save as uncompressed TIFF format\n"
|
|
" -pgm ......... save the raw YUV samples as a grayscale PGM\n"
|
|
" file with IMC4 layout\n"
|
|
" -yuv ......... save the raw YUV samples in flat layout\n"
|
|
"\n"
|
|
" Other options are:\n"
|
|
" -version ..... print version number and exit\n"
|
|
" -nofancy ..... don't use the fancy YUV420 upscaler\n"
|
|
" -nofilter .... disable in-loop filtering\n"
|
|
" -nodither .... disable dithering\n"
|
|
" -dither <d> .. dithering strength (in 0..100)\n"
|
|
" -alpha_dither use alpha-plane dithering if needed\n"
|
|
" -mt .......... use multi-threading\n"
|
|
" -crop <x> <y> <w> <h> ... crop output with the given rectangle\n"
|
|
" -resize <w> <h> ......... scale the output (*after* any cropping)\n"
|
|
" -flip ........ flip the output vertically\n"
|
|
" -alpha ....... only save the alpha plane\n"
|
|
" -incremental . use incremental decoding (useful for tests)\n"
|
|
" -h ........... this help message\n"
|
|
" -v ........... verbose (e.g. print encoding/decoding times)\n"
|
|
" -quiet ....... quiet mode, don't print anything\n"
|
|
#ifndef WEBP_DLL
|
|
" -noasm ....... disable all assembly optimizations\n"
|
|
#endif
|
|
);
|
|
}
|
|
|
|
static const char* const kFormatType[] = {
|
|
"unspecified", "lossy", "lossless"
|
|
};
|
|
|
|
static uint8_t* AllocateExternalBuffer(WebPDecoderConfig* config,
|
|
WebPOutputFileFormat format,
|
|
int use_external_memory) {
|
|
uint8_t* external_buffer = NULL;
|
|
WebPDecBuffer* const output_buffer = &config->output;
|
|
int w = config->input.width;
|
|
int h = config->input.height;
|
|
if (config->options.use_scaling) {
|
|
w = config->options.scaled_width;
|
|
h = config->options.scaled_height;
|
|
} else if (config->options.use_cropping) {
|
|
w = config->options.crop_width;
|
|
h = config->options.crop_height;
|
|
}
|
|
if (format >= RGB && format <= rgbA_4444) {
|
|
const int bpp = (format == RGB || format == BGR) ? 3
|
|
: (format == RGBA_4444 || format == rgbA_4444 ||
|
|
format == RGB_565) ? 2
|
|
: 4;
|
|
uint32_t stride = bpp * w + 7; // <- just for exercising
|
|
external_buffer = (uint8_t*)malloc(stride * h);
|
|
if (external_buffer == NULL) return NULL;
|
|
output_buffer->u.RGBA.stride = stride;
|
|
output_buffer->u.RGBA.size = stride * h;
|
|
output_buffer->u.RGBA.rgba = external_buffer;
|
|
} else { // YUV and YUVA
|
|
const int has_alpha = WebPIsAlphaMode(output_buffer->colorspace);
|
|
uint8_t* tmp;
|
|
uint32_t stride = w + 3;
|
|
uint32_t uv_stride = (w + 1) / 2 + 13;
|
|
uint32_t total_size = stride * h * (has_alpha ? 2 : 1)
|
|
+ 2 * uv_stride * (h + 1) / 2;
|
|
assert(format >= YUV && format <= YUVA);
|
|
external_buffer = (uint8_t*)malloc(total_size);
|
|
if (external_buffer == NULL) return NULL;
|
|
tmp = external_buffer;
|
|
output_buffer->u.YUVA.y = tmp;
|
|
output_buffer->u.YUVA.y_stride = stride;
|
|
output_buffer->u.YUVA.y_size = stride * h;
|
|
tmp += output_buffer->u.YUVA.y_size;
|
|
if (has_alpha) {
|
|
output_buffer->u.YUVA.a = tmp;
|
|
output_buffer->u.YUVA.a_stride = stride;
|
|
output_buffer->u.YUVA.a_size = stride * h;
|
|
tmp += output_buffer->u.YUVA.a_size;
|
|
} else {
|
|
output_buffer->u.YUVA.a = NULL;
|
|
output_buffer->u.YUVA.a_stride = 0;
|
|
}
|
|
output_buffer->u.YUVA.u = tmp;
|
|
output_buffer->u.YUVA.u_stride = uv_stride;
|
|
output_buffer->u.YUVA.u_size = uv_stride * (h + 1) / 2;
|
|
tmp += output_buffer->u.YUVA.u_size;
|
|
|
|
output_buffer->u.YUVA.v = tmp;
|
|
output_buffer->u.YUVA.v_stride = uv_stride;
|
|
output_buffer->u.YUVA.v_size = uv_stride * (h + 1) / 2;
|
|
tmp += output_buffer->u.YUVA.v_size;
|
|
assert(tmp <= external_buffer + total_size);
|
|
}
|
|
output_buffer->is_external_memory = use_external_memory;
|
|
return external_buffer;
|
|
}
|
|
|
|
int main(int argc, const char *argv[]) {
|
|
int ok = 0;
|
|
const char *in_file = NULL;
|
|
const char *out_file = NULL;
|
|
|
|
WebPDecoderConfig config;
|
|
WebPDecBuffer* const output_buffer = &config.output;
|
|
WebPBitstreamFeatures* const bitstream = &config.input;
|
|
WebPOutputFileFormat format = PNG;
|
|
uint8_t* external_buffer = NULL;
|
|
int use_external_memory = 0;
|
|
const uint8_t* data = NULL;
|
|
|
|
int incremental = 0;
|
|
int c;
|
|
|
|
if (!WebPInitDecoderConfig(&config)) {
|
|
fprintf(stderr, "Library version mismatch!\n");
|
|
return -1;
|
|
}
|
|
|
|
for (c = 1; c < argc; ++c) {
|
|
int parse_error = 0;
|
|
if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
|
|
Help();
|
|
return 0;
|
|
} else if (!strcmp(argv[c], "-o") && c < argc - 1) {
|
|
out_file = argv[++c];
|
|
} else if (!strcmp(argv[c], "-alpha")) {
|
|
format = ALPHA_PLANE_ONLY;
|
|
} else if (!strcmp(argv[c], "-nofancy")) {
|
|
config.options.no_fancy_upsampling = 1;
|
|
} else if (!strcmp(argv[c], "-nofilter")) {
|
|
config.options.bypass_filtering = 1;
|
|
} else if (!strcmp(argv[c], "-pam")) {
|
|
format = PAM;
|
|
} else if (!strcmp(argv[c], "-ppm")) {
|
|
format = PPM;
|
|
} else if (!strcmp(argv[c], "-bmp")) {
|
|
format = BMP;
|
|
} else if (!strcmp(argv[c], "-tiff")) {
|
|
format = TIFF;
|
|
} else if (!strcmp(argv[c], "-quiet")) {
|
|
quiet = 1;
|
|
} else if (!strcmp(argv[c], "-version")) {
|
|
const int version = WebPGetDecoderVersion();
|
|
printf("%d.%d.%d\n",
|
|
(version >> 16) & 0xff, (version >> 8) & 0xff, version & 0xff);
|
|
return 0;
|
|
} else if (!strcmp(argv[c], "-pgm")) {
|
|
format = PGM;
|
|
} else if (!strcmp(argv[c], "-yuv")) {
|
|
format = RAW_YUV;
|
|
} else if (!strcmp(argv[c], "-pixel_format") && c < argc - 1) {
|
|
const char* const fmt = argv[++c];
|
|
if (!strcmp(fmt, "RGB")) format = RGB;
|
|
else if (!strcmp(fmt, "RGBA")) format = RGBA;
|
|
else if (!strcmp(fmt, "BGR")) format = BGR;
|
|
else if (!strcmp(fmt, "BGRA")) format = BGRA;
|
|
else if (!strcmp(fmt, "ARGB")) format = ARGB;
|
|
else if (!strcmp(fmt, "RGBA_4444")) format = RGBA_4444;
|
|
else if (!strcmp(fmt, "RGB_565")) format = RGB_565;
|
|
else if (!strcmp(fmt, "rgbA")) format = rgbA;
|
|
else if (!strcmp(fmt, "bgrA")) format = bgrA;
|
|
else if (!strcmp(fmt, "Argb")) format = Argb;
|
|
else if (!strcmp(fmt, "rgbA_4444")) format = rgbA_4444;
|
|
else if (!strcmp(fmt, "YUV")) format = YUV;
|
|
else if (!strcmp(fmt, "YUVA")) format = YUVA;
|
|
else {
|
|
fprintf(stderr, "Can't parse pixel_format %s\n", fmt);
|
|
parse_error = 1;
|
|
}
|
|
} else if (!strcmp(argv[c], "-external_memory") && c < argc - 1) {
|
|
use_external_memory = ExUtilGetInt(argv[++c], 0, &parse_error);
|
|
parse_error |= (use_external_memory > 2 || use_external_memory < 0);
|
|
if (parse_error) {
|
|
fprintf(stderr, "Can't parse 'external_memory' value %s\n", argv[c]);
|
|
}
|
|
} else if (!strcmp(argv[c], "-mt")) {
|
|
config.options.use_threads = 1;
|
|
} else if (!strcmp(argv[c], "-alpha_dither")) {
|
|
config.options.alpha_dithering_strength = 100;
|
|
} else if (!strcmp(argv[c], "-nodither")) {
|
|
config.options.dithering_strength = 0;
|
|
} else if (!strcmp(argv[c], "-dither") && c < argc - 1) {
|
|
config.options.dithering_strength =
|
|
ExUtilGetInt(argv[++c], 0, &parse_error);
|
|
} else if (!strcmp(argv[c], "-crop") && c < argc - 4) {
|
|
config.options.use_cropping = 1;
|
|
config.options.crop_left = ExUtilGetInt(argv[++c], 0, &parse_error);
|
|
config.options.crop_top = ExUtilGetInt(argv[++c], 0, &parse_error);
|
|
config.options.crop_width = ExUtilGetInt(argv[++c], 0, &parse_error);
|
|
config.options.crop_height = ExUtilGetInt(argv[++c], 0, &parse_error);
|
|
} else if ((!strcmp(argv[c], "-scale") || !strcmp(argv[c], "-resize")) &&
|
|
c < argc - 2) { // '-scale' is left for compatibility
|
|
config.options.use_scaling = 1;
|
|
config.options.scaled_width = ExUtilGetInt(argv[++c], 0, &parse_error);
|
|
config.options.scaled_height = ExUtilGetInt(argv[++c], 0, &parse_error);
|
|
} else if (!strcmp(argv[c], "-flip")) {
|
|
config.options.flip = 1;
|
|
} else if (!strcmp(argv[c], "-v")) {
|
|
verbose = 1;
|
|
#ifndef WEBP_DLL
|
|
} else if (!strcmp(argv[c], "-noasm")) {
|
|
VP8GetCPUInfo = NULL;
|
|
#endif
|
|
} else if (!strcmp(argv[c], "-incremental")) {
|
|
incremental = 1;
|
|
} else if (!strcmp(argv[c], "--")) {
|
|
if (c < argc - 1) in_file = argv[++c];
|
|
break;
|
|
} else if (argv[c][0] == '-') {
|
|
fprintf(stderr, "Unknown option '%s'\n", argv[c]);
|
|
Help();
|
|
return -1;
|
|
} else {
|
|
in_file = argv[c];
|
|
}
|
|
|
|
if (parse_error) {
|
|
Help();
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (in_file == NULL) {
|
|
fprintf(stderr, "missing input file!!\n");
|
|
Help();
|
|
return -1;
|
|
}
|
|
|
|
if (quiet) verbose = 0;
|
|
|
|
{
|
|
VP8StatusCode status = VP8_STATUS_OK;
|
|
size_t data_size = 0;
|
|
if (!LoadWebP(in_file, &data, &data_size, bitstream)) {
|
|
return -1;
|
|
}
|
|
|
|
switch (format) {
|
|
case PNG:
|
|
#ifdef HAVE_WINCODEC_H
|
|
output_buffer->colorspace = bitstream->has_alpha ? MODE_BGRA : MODE_BGR;
|
|
#else
|
|
output_buffer->colorspace = bitstream->has_alpha ? MODE_RGBA : MODE_RGB;
|
|
#endif
|
|
break;
|
|
case PAM:
|
|
output_buffer->colorspace = MODE_RGBA;
|
|
break;
|
|
case PPM:
|
|
output_buffer->colorspace = MODE_RGB; // drops alpha for PPM
|
|
break;
|
|
case BMP:
|
|
output_buffer->colorspace = bitstream->has_alpha ? MODE_BGRA : MODE_BGR;
|
|
break;
|
|
case TIFF:
|
|
output_buffer->colorspace = bitstream->has_alpha ? MODE_RGBA : MODE_RGB;
|
|
break;
|
|
case PGM:
|
|
case RAW_YUV:
|
|
output_buffer->colorspace = bitstream->has_alpha ? MODE_YUVA : MODE_YUV;
|
|
break;
|
|
case ALPHA_PLANE_ONLY:
|
|
output_buffer->colorspace = MODE_YUVA;
|
|
break;
|
|
// forced modes:
|
|
case RGB: output_buffer->colorspace = MODE_RGB; break;
|
|
case RGBA: output_buffer->colorspace = MODE_RGBA; break;
|
|
case BGR: output_buffer->colorspace = MODE_BGR; break;
|
|
case BGRA: output_buffer->colorspace = MODE_BGRA; break;
|
|
case ARGB: output_buffer->colorspace = MODE_ARGB; break;
|
|
case RGBA_4444: output_buffer->colorspace = MODE_RGBA_4444; break;
|
|
case RGB_565: output_buffer->colorspace = MODE_RGB_565; break;
|
|
case rgbA: output_buffer->colorspace = MODE_rgbA; break;
|
|
case bgrA: output_buffer->colorspace = MODE_bgrA; break;
|
|
case Argb: output_buffer->colorspace = MODE_Argb; break;
|
|
case rgbA_4444: output_buffer->colorspace = MODE_rgbA_4444; break;
|
|
case YUV: output_buffer->colorspace = MODE_YUV; break;
|
|
case YUVA: output_buffer->colorspace = MODE_YUVA; break;
|
|
default: goto Exit;
|
|
}
|
|
|
|
if (use_external_memory > 0 && format >= RGB) {
|
|
external_buffer = AllocateExternalBuffer(&config, format,
|
|
use_external_memory);
|
|
if (external_buffer == NULL) goto Exit;
|
|
}
|
|
|
|
{
|
|
Stopwatch stop_watch;
|
|
if (verbose) StopwatchReset(&stop_watch);
|
|
|
|
if (incremental) {
|
|
status = DecodeWebPIncremental(data, data_size, &config);
|
|
} else {
|
|
status = DecodeWebP(data, data_size, &config);
|
|
}
|
|
if (verbose) {
|
|
const double decode_time = StopwatchReadAndReset(&stop_watch);
|
|
fprintf(stderr, "Time to decode picture: %.3fs\n", decode_time);
|
|
}
|
|
}
|
|
|
|
ok = (status == VP8_STATUS_OK);
|
|
if (!ok) {
|
|
PrintWebPError(in_file, status);
|
|
goto Exit;
|
|
}
|
|
}
|
|
|
|
if (out_file != NULL) {
|
|
if (!quiet) {
|
|
fprintf(stderr, "Decoded %s. Dimensions: %d x %d %s. Format: %s. "
|
|
"Now saving...\n",
|
|
in_file, output_buffer->width, output_buffer->height,
|
|
bitstream->has_alpha ? " (with alpha)" : "",
|
|
kFormatType[bitstream->format]);
|
|
}
|
|
ok = SaveOutput(output_buffer, format, out_file);
|
|
} else {
|
|
if (!quiet) {
|
|
fprintf(stderr, "File %s can be decoded "
|
|
"(dimensions: %d x %d %s. Format: %s).\n",
|
|
in_file, output_buffer->width, output_buffer->height,
|
|
bitstream->has_alpha ? " (with alpha)" : "",
|
|
kFormatType[bitstream->format]);
|
|
fprintf(stderr, "Nothing written; "
|
|
"use -o flag to save the result as e.g. PNG.\n");
|
|
}
|
|
}
|
|
Exit:
|
|
WebPFreeDecBuffer(output_buffer);
|
|
free((void*)external_buffer);
|
|
free((void*)data);
|
|
return ok ? 0 : -1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|