[deb_ffmpeg.git] / ffmpeg / libavcodec / libwebpenc.c

/*
 * WebP encoding support via libwebp
 * Copyright (c) 2013 Justin Ruggles <justin.ruggles@gmail.com>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg 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 GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * WebP encoder using libwebp
 */

#include <webp/encode.h>

#include "libavutil/common.h"
#include "libavutil/frame.h"
#include "libavutil/imgutils.h"
#include "libavutil/opt.h"
#include "avcodec.h"
#include "internal.h"

typedef struct LibWebPContext {
    AVClass *class;         // class for AVOptions
    float quality;          // lossy quality 0 - 100
    int lossless;           // use lossless encoding
    int preset;             // configuration preset
    int chroma_warning;     // chroma linesize mismatch warning has been printed
    int conversion_warning; // pixel format conversion warning has been printed
    WebPConfig config;      // libwebp configuration
} LibWebPContext;

static int libwebp_error_to_averror(int err)
{
    switch (err) {
    case VP8_ENC_ERROR_OUT_OF_MEMORY:
    case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY:
        return AVERROR(ENOMEM);
    case VP8_ENC_ERROR_NULL_PARAMETER:
    case VP8_ENC_ERROR_INVALID_CONFIGURATION:
    case VP8_ENC_ERROR_BAD_DIMENSION:
        return AVERROR(EINVAL);
    }
    return AVERROR_UNKNOWN;
}

static av_cold int libwebp_encode_init(AVCodecContext *avctx)
{
    LibWebPContext *s = avctx->priv_data;
    int ret;

    if (avctx->global_quality < 0)
        avctx->global_quality = 75 * FF_QP2LAMBDA;
    s->quality = av_clipf(avctx->global_quality / (float)FF_QP2LAMBDA,
                          0.0f, 100.0f);

    if (avctx->compression_level < 0 || avctx->compression_level > 6) {
        av_log(avctx, AV_LOG_WARNING, "invalid compression level: %d\n",
               avctx->compression_level);
        avctx->compression_level = av_clip(avctx->compression_level, 0, 6);
    }

    if (s->preset >= WEBP_PRESET_DEFAULT) {
        ret = WebPConfigPreset(&s->config, s->preset, s->quality);
        if (!ret)
            return AVERROR_UNKNOWN;
        s->lossless              = s->config.lossless;
        s->quality               = s->config.quality;
        avctx->compression_level = s->config.method;
    } else {
        ret = WebPConfigInit(&s->config);
        if (!ret)
            return AVERROR_UNKNOWN;

        s->config.lossless = s->lossless;
        s->config.quality  = s->quality;
        s->config.method   = avctx->compression_level;

        ret = WebPValidateConfig(&s->config);
        if (!ret)
            return AVERROR(EINVAL);
    }

    av_log(avctx, AV_LOG_DEBUG, "%s - quality=%.1f method=%d\n",
           s->lossless ? "Lossless" : "Lossy", s->quality,
           avctx->compression_level);

    return 0;
}

static int libwebp_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                                const AVFrame *frame, int *got_packet)
{
    LibWebPContext *s  = avctx->priv_data;
    AVFrame *alt_frame = NULL;
    WebPPicture *pic = NULL;
    WebPMemoryWriter mw = { 0 };
    int ret;

    if (avctx->width > WEBP_MAX_DIMENSION || avctx->height > WEBP_MAX_DIMENSION) {
        av_log(avctx, AV_LOG_ERROR, "Picture size is too large. Max is %dx%d.\n",
               WEBP_MAX_DIMENSION, WEBP_MAX_DIMENSION);
        return AVERROR(EINVAL);
    }

    pic = av_malloc(sizeof(*pic));
    if (!pic)
        return AVERROR(ENOMEM);

    ret = WebPPictureInit(pic);
    if (!ret) {
        ret = AVERROR_UNKNOWN;
        goto end;
    }
    pic->width  = avctx->width;
    pic->height = avctx->height;

    if (avctx->pix_fmt == AV_PIX_FMT_RGB32) {
        if (!s->lossless) {
            /* libwebp will automatically convert RGB input to YUV when
               encoding lossy. */
            if (!s->conversion_warning) {
                av_log(avctx, AV_LOG_WARNING,
                       "Using libwebp for RGB-to-YUV conversion. You may want "
                       "to consider passing in YUV instead for lossy "
                       "encoding.\n");
                s->conversion_warning = 1;
            }
        }
        pic->use_argb    = 1;
        pic->argb        = (uint32_t *)frame->data[0];
        pic->argb_stride = frame->linesize[0] / 4;
    } else {
        if (frame->linesize[1] != frame->linesize[2]) {
            if (!s->chroma_warning) {
                av_log(avctx, AV_LOG_WARNING,
                       "Copying frame due to differing chroma linesizes.\n");
                s->chroma_warning = 1;
            }
            alt_frame = av_frame_alloc();
            if (!alt_frame) {
                ret = AVERROR(ENOMEM);
                goto end;
            }
            alt_frame->width  = frame->width;
            alt_frame->height = frame->height;
            alt_frame->format = frame->format;
            ret = av_frame_get_buffer(alt_frame, 32);
            if (ret < 0)
                goto end;
            av_frame_copy(alt_frame, frame);
            frame = alt_frame;
        }
        pic->use_argb  = 0;
        pic->y         = frame->data[0];
        pic->u         = frame->data[1];
        pic->v         = frame->data[2];
        pic->y_stride  = frame->linesize[0];
        pic->uv_stride = frame->linesize[1];
        if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
            pic->colorspace = WEBP_YUV420A;
            pic->a          = frame->data[3];
            pic->a_stride   = frame->linesize[3];
        } else {
            pic->colorspace = WEBP_YUV420;
        }

        if (s->lossless) {
            /* We do not have a way to automatically prioritize RGB over YUV
               in automatic pixel format conversion based on whether we're
               encoding lossless or lossy, so we do conversion with libwebp as
               a convenience. */
            if (!s->conversion_warning) {
                av_log(avctx, AV_LOG_WARNING,
                       "Using libwebp for YUV-to-RGB conversion. You may want "
                       "to consider passing in RGB instead for lossless "
                       "encoding.\n");
                s->conversion_warning = 1;
            }

#if (WEBP_ENCODER_ABI_VERSION <= 0x201)
            /* libwebp should do the conversion automatically, but there is a
               bug that causes it to return an error instead, so a work-around
               is required.
               See https://code.google.com/p/webp/issues/detail?id=178 */
            pic->memory_ = (void*)1;  /* something non-null */
            ret = WebPPictureYUVAToARGB(pic);
            if (!ret) {
                av_log(avctx, AV_LOG_ERROR,
                       "WebPPictureYUVAToARGB() failed with error: %d\n",
                       pic->error_code);
                ret = libwebp_error_to_averror(pic->error_code);
                goto end;
            }
            pic->memory_ = NULL;  /* restore pointer */
#endif
        }
    }

    WebPMemoryWriterInit(&mw);
    pic->custom_ptr = &mw;
    pic->writer     = WebPMemoryWrite;

    ret = WebPEncode(&s->config, pic);
    if (!ret) {
        av_log(avctx, AV_LOG_ERROR, "WebPEncode() failed with error: %d\n",
               pic->error_code);
        ret = libwebp_error_to_averror(pic->error_code);
        goto end;
    }

    ret = ff_alloc_packet(pkt, mw.size);
    if (ret < 0)
        goto end;
    memcpy(pkt->data, mw.mem, mw.size);

    pkt->flags |= AV_PKT_FLAG_KEY;
    *got_packet = 1;

end:
#if (WEBP_ENCODER_ABI_VERSION > 0x0203)
    WebPMemoryWriterClear(&mw);
#else
    free(mw.mem); /* must use free() according to libwebp documentation */
#endif
    WebPPictureFree(pic);
    av_freep(&pic);
    av_frame_free(&alt_frame);

    return ret;
}

#define OFFSET(x) offsetof(LibWebPContext, x)
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
    { "lossless",   "Use lossless mode",       OFFSET(lossless), AV_OPT_TYPE_INT,   { .i64 =  0 },  0, 1,                           VE           },
    { "preset",     "Configuration preset",    OFFSET(preset),   AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, WEBP_PRESET_TEXT,            VE, "preset" },
    { "none",       "do not use a preset",                              0, AV_OPT_TYPE_CONST, { .i64 = -1                  }, 0, 0, VE, "preset" },
    { "default",    "default preset",                                   0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_DEFAULT }, 0, 0, VE, "preset" },
    { "picture",    "digital picture, like portrait, inner shot",       0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_PICTURE }, 0, 0, VE, "preset" },
    { "photo",      "outdoor photograph, with natural lighting",        0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_PHOTO   }, 0, 0, VE, "preset" },
    { "drawing",    "hand or line drawing, with high-contrast details", 0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_DRAWING }, 0, 0, VE, "preset" },
    { "icon",       "small-sized colorful images",                      0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_ICON    }, 0, 0, VE, "preset" },
    { "text",       "text-like",                                        0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_TEXT    }, 0, 0, VE, "preset" },
    { NULL },
};

static const AVClass class = {
    .class_name = "libwebp",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

static const AVCodecDefault libwebp_defaults[] = {
    { "compression_level",  "4"  },
    { "global_quality",     "-1" },
    { NULL },
};

AVCodec ff_libwebp_encoder = {
    .name           = "libwebp",
    .long_name      = NULL_IF_CONFIG_SMALL("libwebp WebP image"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_WEBP,
    .priv_data_size = sizeof(LibWebPContext),
    .init           = libwebp_encode_init,
    .encode2        = libwebp_encode_frame,
    .pix_fmts       = (const enum AVPixelFormat[]) {
        AV_PIX_FMT_RGB32,
        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P,
        AV_PIX_FMT_NONE
    },
    .priv_class     = &class,
    .defaults       = libwebp_defaults,
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* WebP encoding support via libwebp
	3	* Copyright (c) 2013 Justin Ruggles <justin.ruggles@gmail.com>
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	/**
	23	* @file
	24	* WebP encoder using libwebp
	25	*/
	26
	27	#include <webp/encode.h>
	28
	29	#include "libavutil/common.h"
	30	#include "libavutil/frame.h"
	31	#include "libavutil/imgutils.h"
	32	#include "libavutil/opt.h"
	33	#include "avcodec.h"
	34	#include "internal.h"
	35
	36	typedef struct LibWebPContext {
	37	AVClass *class; // class for AVOptions
	38	float quality; // lossy quality 0 - 100
	39	int lossless; // use lossless encoding
	40	int preset; // configuration preset
	41	int chroma_warning; // chroma linesize mismatch warning has been printed
	42	int conversion_warning; // pixel format conversion warning has been printed
	43	WebPConfig config; // libwebp configuration
	44	} LibWebPContext;
	45
	46	static int libwebp_error_to_averror(int err)
	47	{
	48	switch (err) {
	49	case VP8_ENC_ERROR_OUT_OF_MEMORY:
	50	case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY:
	51	return AVERROR(ENOMEM);
	52	case VP8_ENC_ERROR_NULL_PARAMETER:
	53	case VP8_ENC_ERROR_INVALID_CONFIGURATION:
	54	case VP8_ENC_ERROR_BAD_DIMENSION:
	55	return AVERROR(EINVAL);
	56	}
	57	return AVERROR_UNKNOWN;
	58	}
	59
	60	static av_cold int libwebp_encode_init(AVCodecContext *avctx)
	61	{
	62	LibWebPContext *s = avctx->priv_data;
	63	int ret;
	64
65	if (avctx->global_quality < 0)
66	avctx->global_quality = 75 * FF_QP2LAMBDA;
67	s->quality = av_clipf(avctx->global_quality / (float)FF_QP2LAMBDA,
68	0.0f, 100.0f);
69
70	if (avctx->compression_level < 0 \|\| avctx->compression_level > 6) {
71	av_log(avctx, AV_LOG_WARNING, "invalid compression level: %d\n",
72	avctx->compression_level);
73	avctx->compression_level = av_clip(avctx->compression_level, 0, 6);
74	}
75
76	if (s->preset >= WEBP_PRESET_DEFAULT) {
77	ret = WebPConfigPreset(&s->config, s->preset, s->quality);
78	if (!ret)
79	return AVERROR_UNKNOWN;
80	s->lossless = s->config.lossless;
81	s->quality = s->config.quality;
82	avctx->compression_level = s->config.method;
83	} else {
84	ret = WebPConfigInit(&s->config);
85	if (!ret)
86	return AVERROR_UNKNOWN;
87
88	s->config.lossless = s->lossless;
89	s->config.quality = s->quality;
90	s->config.method = avctx->compression_level;
91
92	ret = WebPValidateConfig(&s->config);
93	if (!ret)
94	return AVERROR(EINVAL);
95	}
96
97	av_log(avctx, AV_LOG_DEBUG, "%s - quality=%.1f method=%d\n",
98	s->lossless ? "Lossless" : "Lossy", s->quality,
99	avctx->compression_level);
100
101	return 0;
102	}
103
104	static int libwebp_encode_frame(AVCodecContext avctx, AVPacket pkt,
105	const AVFrame frame, int got_packet)
106	{
107	LibWebPContext *s = avctx->priv_data;
108	AVFrame *alt_frame = NULL;
109	WebPPicture *pic = NULL;
110	WebPMemoryWriter mw = { 0 };
111	int ret;
112
113	if (avctx->width > WEBP_MAX_DIMENSION \|\| avctx->height > WEBP_MAX_DIMENSION) {
114	av_log(avctx, AV_LOG_ERROR, "Picture size is too large. Max is %dx%d.\n",
115	WEBP_MAX_DIMENSION, WEBP_MAX_DIMENSION);
116	return AVERROR(EINVAL);
117	}
118
119	pic = av_malloc(sizeof(*pic));
120	if (!pic)
121	return AVERROR(ENOMEM);
122
123	ret = WebPPictureInit(pic);
124	if (!ret) {
125	ret = AVERROR_UNKNOWN;
126	goto end;
127	}
128	pic->width = avctx->width;
129	pic->height = avctx->height;
130
131	if (avctx->pix_fmt == AV_PIX_FMT_RGB32) {
132	if (!s->lossless) {
133	/* libwebp will automatically convert RGB input to YUV when
134	encoding lossy. */
135	if (!s->conversion_warning) {
136	av_log(avctx, AV_LOG_WARNING,
137	"Using libwebp for RGB-to-YUV conversion. You may want "
138	"to consider passing in YUV instead for lossy "
139	"encoding.\n");
140	s->conversion_warning = 1;
141	}
142	}
143	pic->use_argb = 1;
144	pic->argb = (uint32_t *)frame->data[0];
145	pic->argb_stride = frame->linesize[0] / 4;
146	} else {
147	if (frame->linesize[1] != frame->linesize[2]) {
148	if (!s->chroma_warning) {
149	av_log(avctx, AV_LOG_WARNING,
150	"Copying frame due to differing chroma linesizes.\n");
151	s->chroma_warning = 1;
152	}
153	alt_frame = av_frame_alloc();
154	if (!alt_frame) {
155	ret = AVERROR(ENOMEM);
156	goto end;
157	}
158	alt_frame->width = frame->width;
159	alt_frame->height = frame->height;
160	alt_frame->format = frame->format;
161	ret = av_frame_get_buffer(alt_frame, 32);
162	if (ret < 0)
163	goto end;
164	av_frame_copy(alt_frame, frame);
165	frame = alt_frame;
166	}
167	pic->use_argb = 0;
168	pic->y = frame->data[0];
169	pic->u = frame->data[1];
170	pic->v = frame->data[2];
171	pic->y_stride = frame->linesize[0];
172	pic->uv_stride = frame->linesize[1];
173	if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
174	pic->colorspace = WEBP_YUV420A;
175	pic->a = frame->data[3];
176	pic->a_stride = frame->linesize[3];
177	} else {
178	pic->colorspace = WEBP_YUV420;
179	}
180
181	if (s->lossless) {
182	/* We do not have a way to automatically prioritize RGB over YUV
183	in automatic pixel format conversion based on whether we're
184	encoding lossless or lossy, so we do conversion with libwebp as
185	a convenience. */
186	if (!s->conversion_warning) {
187	av_log(avctx, AV_LOG_WARNING,
188	"Using libwebp for YUV-to-RGB conversion. You may want "
189	"to consider passing in RGB instead for lossless "
190	"encoding.\n");
191	s->conversion_warning = 1;
192	}
193
194	#if (WEBP_ENCODER_ABI_VERSION <= 0x201)
195	/* libwebp should do the conversion automatically, but there is a
196	bug that causes it to return an error instead, so a work-around
197	is required.
198	See https://code.google.com/p/webp/issues/detail?id=178 */
199	pic->memory_ = (void)1; / something non-null */
200	ret = WebPPictureYUVAToARGB(pic);
201	if (!ret) {
202	av_log(avctx, AV_LOG_ERROR,
203	"WebPPictureYUVAToARGB() failed with error: %d\n",
204	pic->error_code);
205	ret = libwebp_error_to_averror(pic->error_code);
206	goto end;
207	}
208	pic->memory_ = NULL; /* restore pointer */
209	#endif
210	}
211	}
212
213	WebPMemoryWriterInit(&mw);
214	pic->custom_ptr = &mw;
215	pic->writer = WebPMemoryWrite;
216
217	ret = WebPEncode(&s->config, pic);
218	if (!ret) {
219	av_log(avctx, AV_LOG_ERROR, "WebPEncode() failed with error: %d\n",
220	pic->error_code);
221	ret = libwebp_error_to_averror(pic->error_code);
222	goto end;
223	}
224
225	ret = ff_alloc_packet(pkt, mw.size);
226	if (ret < 0)
227	goto end;
228	memcpy(pkt->data, mw.mem, mw.size);
229
230	pkt->flags \|= AV_PKT_FLAG_KEY;
231	*got_packet = 1;
232
233	end:
234	#if (WEBP_ENCODER_ABI_VERSION > 0x0203)
235	WebPMemoryWriterClear(&mw);
236	#else
237	free(mw.mem); /* must use free() according to libwebp documentation */
238	#endif
239	WebPPictureFree(pic);
240	av_freep(&pic);
241	av_frame_free(&alt_frame);
242
243	return ret;
244	}
245
246	#define OFFSET(x) offsetof(LibWebPContext, x)
247	#define VE AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM
248	static const AVOption options[] = {
249	{ "lossless", "Use lossless mode", OFFSET(lossless), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
250	{ "preset", "Configuration preset", OFFSET(preset), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, WEBP_PRESET_TEXT, VE, "preset" },
251	{ "none", "do not use a preset", 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, 0, 0, VE, "preset" },
252	{ "default", "default preset", 0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_DEFAULT }, 0, 0, VE, "preset" },
253	{ "picture", "digital picture, like portrait, inner shot", 0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_PICTURE }, 0, 0, VE, "preset" },
254	{ "photo", "outdoor photograph, with natural lighting", 0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_PHOTO }, 0, 0, VE, "preset" },
255	{ "drawing", "hand or line drawing, with high-contrast details", 0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_DRAWING }, 0, 0, VE, "preset" },
256	{ "icon", "small-sized colorful images", 0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_ICON }, 0, 0, VE, "preset" },
257	{ "text", "text-like", 0, AV_OPT_TYPE_CONST, { .i64 = WEBP_PRESET_TEXT }, 0, 0, VE, "preset" },
258	{ NULL },
259	};
260
261	static const AVClass class = {
262	.class_name = "libwebp",
263	.item_name = av_default_item_name,
264	.option = options,
265	.version = LIBAVUTIL_VERSION_INT,
266	};
267
268	static const AVCodecDefault libwebp_defaults[] = {
269	{ "compression_level", "4" },
270	{ "global_quality", "-1" },
271	{ NULL },
272	};
273
274	AVCodec ff_libwebp_encoder = {
275	.name = "libwebp",
276	.long_name = NULL_IF_CONFIG_SMALL("libwebp WebP image"),
277	.type = AVMEDIA_TYPE_VIDEO,
278	.id = AV_CODEC_ID_WEBP,
279	.priv_data_size = sizeof(LibWebPContext),
280	.init = libwebp_encode_init,
281	.encode2 = libwebp_encode_frame,
282	.pix_fmts = (const enum AVPixelFormat[]) {
283	AV_PIX_FMT_RGB32,
284	AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P,
285	AV_PIX_FMT_NONE
286	},
287	.priv_class = &class,
288	.defaults = libwebp_defaults,
289	};