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

/*
 * Copyright (c) 1990 James Ashton - Sydney University
 * Copyright (c) 2012 Stefano Sabatini
 *
 * 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
 * X-Face encoder, based on libcompface, by James Ashton.
 */

#include "xface.h"
#include "avcodec.h"
#include "internal.h"
#include "libavutil/avassert.h"

typedef struct XFaceContext {
    AVClass *class;
    uint8_t bitmap[XFACE_PIXELS]; ///< image used internally for decoding
    int max_line_len;             ///< max line length for compressed data
    int set_header;               ///< set X-Face header in the output
} XFaceContext;

static int all_same(char *bitmap, int w, int h)
{
    char val, *row;
    int x;

    val = *bitmap;
    while (h--) {
        row = bitmap;
        x = w;
        while (x--)
            if (*(row++) != val)
                return 0;
        bitmap += XFACE_WIDTH;
    }
    return 1;
}

static int all_black(char *bitmap, int w, int h)
{
    if (w > 3) {
        w /= 2;
        h /= 2;
        return (all_black(bitmap, w, h) && all_black(bitmap + w, w, h) &&
                all_black(bitmap + XFACE_WIDTH * h, w, h) &&
                all_black(bitmap + XFACE_WIDTH * h + w, w, h));
    } else {
        /* at least one pixel in the 2x2 grid is non-zero */
        return *bitmap || *(bitmap + 1) ||
               *(bitmap + XFACE_WIDTH) || *(bitmap + XFACE_WIDTH + 1);
    }
}

static int all_white(char *bitmap, int w, int h)
{
    return *bitmap == 0 && all_same(bitmap, w, h);
}

typedef struct {
    ProbRange prob_ranges[XFACE_PIXELS*2];
    int prob_ranges_idx;
} ProbRangesQueue;

static inline int pq_push(ProbRangesQueue *pq, const ProbRange *p)
{
    if (pq->prob_ranges_idx >= XFACE_PIXELS * 2 - 1)
        return -1;
    pq->prob_ranges[pq->prob_ranges_idx++] = *p;
    return 0;
}

static void push_greys(ProbRangesQueue *pq, char *bitmap, int w, int h)
{
    if (w > 3) {
        w /= 2;
        h /= 2;
        push_greys(pq, bitmap,                       w, h);
        push_greys(pq, bitmap + w,                   w, h);
        push_greys(pq, bitmap + XFACE_WIDTH * h,     w, h);
        push_greys(pq, bitmap + XFACE_WIDTH * h + w, w, h);
    } else {
        const ProbRange *p = ff_xface_probranges_2x2 +
                 *bitmap +
            2 * *(bitmap + 1) +
            4 * *(bitmap + XFACE_WIDTH) +
            8 * *(bitmap + XFACE_WIDTH + 1);
        pq_push(pq, p);
    }
}

static void encode_block(char *bitmap, int w, int h, int level, ProbRangesQueue *pq)
{
    if (all_white(bitmap, w, h)) {
        pq_push(pq, &ff_xface_probranges_per_level[level][XFACE_COLOR_WHITE]);
    } else if (all_black(bitmap, w, h)) {
        pq_push(pq, &ff_xface_probranges_per_level[level][XFACE_COLOR_BLACK]);
        push_greys(pq, bitmap, w, h);
    } else {
        pq_push(pq, &ff_xface_probranges_per_level[level][XFACE_COLOR_GREY]);
        w /= 2;
        h /= 2;
        level++;
        encode_block(bitmap,                       w, h, level, pq);
        encode_block(bitmap + w,                   w, h, level, pq);
        encode_block(bitmap + h * XFACE_WIDTH,     w, h, level, pq);
        encode_block(bitmap + w + h * XFACE_WIDTH, w, h, level, pq);
    }
}

static av_cold int xface_encode_init(AVCodecContext *avctx)
{
    avctx->coded_frame = av_frame_alloc();
    if (!avctx->coded_frame)
        return AVERROR(ENOMEM);
    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

    return 0;
}

static void push_integer(BigInt *b, const ProbRange *prange)
{
    uint8_t r;

    ff_big_div(b, prange->range, &r);
    ff_big_mul(b, 0);
    ff_big_add(b, r + prange->offset);
}

static int xface_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                              const AVFrame *frame, int *got_packet)
{
    XFaceContext *xface = avctx->priv_data;
    ProbRangesQueue pq = {{{ 0 }}, 0};
    uint8_t bitmap_copy[XFACE_PIXELS];
    BigInt b = {0};
    int i, j, k, ret = 0;
    const uint8_t *buf;
    uint8_t *p;
    char intbuf[XFACE_MAX_DIGITS];

    if (avctx->width || avctx->height) {
        if (avctx->width != XFACE_WIDTH || avctx->height != XFACE_HEIGHT) {
            av_log(avctx, AV_LOG_ERROR,
                   "Size value %dx%d not supported, only accepts a size of %dx%d\n",
                   avctx->width, avctx->height, XFACE_WIDTH, XFACE_HEIGHT);
            return AVERROR(EINVAL);
        }
    }
    avctx->width  = XFACE_WIDTH;
    avctx->height = XFACE_HEIGHT;

    /* convert image from MONOWHITE to 1=black 0=white bitmap */
    buf = frame->data[0];
    i = j = 0;
    do {
        for (k = 0; k < 8; k++)
            xface->bitmap[i++] = (buf[j]>>(7-k))&1;
        if (++j == XFACE_WIDTH/8) {
            buf += frame->linesize[0];
            j = 0;
        }
    } while (i < XFACE_PIXELS);

    /* create a copy of bitmap */
    memcpy(bitmap_copy, xface->bitmap, XFACE_PIXELS);
    ff_xface_generate_face(xface->bitmap, bitmap_copy);

    encode_block(xface->bitmap,                         16, 16, 0, &pq);
    encode_block(xface->bitmap + 16,                    16, 16, 0, &pq);
    encode_block(xface->bitmap + 32,                    16, 16, 0, &pq);
    encode_block(xface->bitmap + XFACE_WIDTH * 16,      16, 16, 0, &pq);
    encode_block(xface->bitmap + XFACE_WIDTH * 16 + 16, 16, 16, 0, &pq);
    encode_block(xface->bitmap + XFACE_WIDTH * 16 + 32, 16, 16, 0, &pq);
    encode_block(xface->bitmap + XFACE_WIDTH * 32,      16, 16, 0, &pq);
    encode_block(xface->bitmap + XFACE_WIDTH * 32 + 16, 16, 16, 0, &pq);
    encode_block(xface->bitmap + XFACE_WIDTH * 32 + 32, 16, 16, 0, &pq);

    while (pq.prob_ranges_idx > 0)
        push_integer(&b, &pq.prob_ranges[--pq.prob_ranges_idx]);

    /* write the inverted big integer in b to intbuf */
    i = 0;
    av_assert0(b.nb_words < XFACE_MAX_WORDS);
    while (b.nb_words) {
        uint8_t r;
        ff_big_div(&b, XFACE_PRINTS, &r);
        av_assert0(i < sizeof(intbuf));
        intbuf[i++] = r + XFACE_FIRST_PRINT;
    }

    if ((ret = ff_alloc_packet2(avctx, pkt, i+2)) < 0)
        return ret;

    /* revert the number, and close the buffer */
    p = pkt->data;
    while (--i >= 0)
        *(p++) = intbuf[i];
    *(p++) = '\n';
    *(p++) = 0;

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

    return 0;
}

static av_cold int xface_encode_close(AVCodecContext *avctx)
{
    av_freep(&avctx->coded_frame);

    return 0;
}

AVCodec ff_xface_encoder = {
    .name           = "xface",
    .long_name      = NULL_IF_CONFIG_SMALL("X-face image"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_XFACE,
    .priv_data_size = sizeof(XFaceContext),
    .init           = xface_encode_init,
    .close          = xface_encode_close,
    .encode2        = xface_encode_frame,
    .pix_fmts       = (const enum PixelFormat[]) { AV_PIX_FMT_MONOWHITE, AV_PIX_FMT_NONE },
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (c) 1990 James Ashton - Sydney University
	3	* Copyright (c) 2012 Stefano Sabatini
	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	* X-Face encoder, based on libcompface, by James Ashton.
	25	*/
	26
	27	#include "xface.h"
	28	#include "avcodec.h"
	29	#include "internal.h"
f6fa7814	30	#include "libavutil/avassert.h"
2ba45a60 DM	31
	32	typedef struct XFaceContext {
	33	AVClass *class;
	34	uint8_t bitmap[XFACE_PIXELS]; ///< image used internally for decoding
	35	int max_line_len; ///< max line length for compressed data
	36	int set_header; ///< set X-Face header in the output
	37	} XFaceContext;
	38
	39	static int all_same(char *bitmap, int w, int h)
	40	{
	41	char val, *row;
	42	int x;
	43
	44	val = *bitmap;
	45	while (h--) {
	46	row = bitmap;
	47	x = w;
	48	while (x--)
	49	if (*(row++) != val)
	50	return 0;
	51	bitmap += XFACE_WIDTH;
	52	}
	53	return 1;
	54	}
	55
	56	static int all_black(char *bitmap, int w, int h)
	57	{
	58	if (w > 3) {
	59	w /= 2;
	60	h /= 2;
	61	return (all_black(bitmap, w, h) && all_black(bitmap + w, w, h) &&
	62	all_black(bitmap + XFACE_WIDTH * h, w, h) &&
	63	all_black(bitmap + XFACE_WIDTH * h + w, w, h));
	64	} else {
	65	/* at least one pixel in the 2x2 grid is non-zero */
	66	return bitmap \|\| (bitmap + 1) \|\|
	67	(bitmap + XFACE_WIDTH) \|\| (bitmap + XFACE_WIDTH + 1);
	68	}
	69	}
	70
	71	static int all_white(char *bitmap, int w, int h)
	72	{
	73	return *bitmap == 0 && all_same(bitmap, w, h);
	74	}
	75
	76	typedef struct {
f6fa7814	77	ProbRange prob_ranges[XFACE_PIXELS*2];
2ba45a60 DM	78	int prob_ranges_idx;
	79	} ProbRangesQueue;
	80
	81	static inline int pq_push(ProbRangesQueue pq, const ProbRange p)
	82	{
	83	if (pq->prob_ranges_idx >= XFACE_PIXELS * 2 - 1)
	84	return -1;
f6fa7814	85	pq->prob_ranges[pq->prob_ranges_idx++] = *p;
2ba45a60 DM	86	return 0;
	87	}
	88
	89	static void push_greys(ProbRangesQueue pq, char bitmap, int w, int h)
	90	{
	91	if (w > 3) {
	92	w /= 2;
	93	h /= 2;
	94	push_greys(pq, bitmap, w, h);
	95	push_greys(pq, bitmap + w, w, h);
	96	push_greys(pq, bitmap + XFACE_WIDTH * h, w, h);
	97	push_greys(pq, bitmap + XFACE_WIDTH * h + w, w, h);
	98	} else {
	99	const ProbRange *p = ff_xface_probranges_2x2 +
	100	*bitmap +
	101	2 * *(bitmap + 1) +
	102	4 * *(bitmap + XFACE_WIDTH) +
	103	8 * *(bitmap + XFACE_WIDTH + 1);
	104	pq_push(pq, p);
	105	}
	106	}
	107
	108	static void encode_block(char bitmap, int w, int h, int level, ProbRangesQueue pq)
	109	{
	110	if (all_white(bitmap, w, h)) {
	111	pq_push(pq, &ff_xface_probranges_per_level[level][XFACE_COLOR_WHITE]);
	112	} else if (all_black(bitmap, w, h)) {
	113	pq_push(pq, &ff_xface_probranges_per_level[level][XFACE_COLOR_BLACK]);
	114	push_greys(pq, bitmap, w, h);
	115	} else {
	116	pq_push(pq, &ff_xface_probranges_per_level[level][XFACE_COLOR_GREY]);
	117	w /= 2;
	118	h /= 2;
	119	level++;
	120	encode_block(bitmap, w, h, level, pq);
	121	encode_block(bitmap + w, w, h, level, pq);
	122	encode_block(bitmap + h * XFACE_WIDTH, w, h, level, pq);
	123	encode_block(bitmap + w + h * XFACE_WIDTH, w, h, level, pq);
	124	}
	125	}
	126
	127	static av_cold int xface_encode_init(AVCodecContext *avctx)
	128	{
	129	avctx->coded_frame = av_frame_alloc();
	130	if (!avctx->coded_frame)
	131	return AVERROR(ENOMEM);
	132	avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
	133
	134	return 0;
	135	}
	136
	137	static void push_integer(BigInt b, const ProbRange prange)
	138	{
	139	uint8_t r;
	140
	141	ff_big_div(b, prange->range, &r);
	142	ff_big_mul(b, 0);
	143	ff_big_add(b, r + prange->offset);
	144	}
	145
	146	static int xface_encode_frame(AVCodecContext avctx, AVPacket pkt,
	147	const AVFrame frame, int got_packet)
	148	{
	149	XFaceContext *xface = avctx->priv_data;
f6fa7814	150	ProbRangesQueue pq = {{{ 0 }}, 0};
2ba45a60 DM	151	uint8_t bitmap_copy[XFACE_PIXELS];
	152	BigInt b = {0};
	153	int i, j, k, ret = 0;
	154	const uint8_t *buf;
	155	uint8_t *p;
	156	char intbuf[XFACE_MAX_DIGITS];
	157
	158	if (avctx->width \|\| avctx->height) {
	159	if (avctx->width != XFACE_WIDTH \|\| avctx->height != XFACE_HEIGHT) {
	160	av_log(avctx, AV_LOG_ERROR,
	161	"Size value %dx%d not supported, only accepts a size of %dx%d\n",
	162	avctx->width, avctx->height, XFACE_WIDTH, XFACE_HEIGHT);
	163	return AVERROR(EINVAL);
	164	}
	165	}
	166	avctx->width = XFACE_WIDTH;
	167	avctx->height = XFACE_HEIGHT;
	168
	169	/* convert image from MONOWHITE to 1=black 0=white bitmap */
	170	buf = frame->data[0];
	171	i = j = 0;
	172	do {
	173	for (k = 0; k < 8; k++)
	174	xface->bitmap[i++] = (buf[j]>>(7-k))&1;
	175	if (++j == XFACE_WIDTH/8) {
	176	buf += frame->linesize[0];
	177	j = 0;
	178	}
	179	} while (i < XFACE_PIXELS);
	180
	181	/* create a copy of bitmap */
	182	memcpy(bitmap_copy, xface->bitmap, XFACE_PIXELS);
	183	ff_xface_generate_face(xface->bitmap, bitmap_copy);
	184
	185	encode_block(xface->bitmap, 16, 16, 0, &pq);
	186	encode_block(xface->bitmap + 16, 16, 16, 0, &pq);
	187	encode_block(xface->bitmap + 32, 16, 16, 0, &pq);
	188	encode_block(xface->bitmap + XFACE_WIDTH * 16, 16, 16, 0, &pq);
	189	encode_block(xface->bitmap + XFACE_WIDTH * 16 + 16, 16, 16, 0, &pq);
	190	encode_block(xface->bitmap + XFACE_WIDTH * 16 + 32, 16, 16, 0, &pq);
	191	encode_block(xface->bitmap + XFACE_WIDTH * 32, 16, 16, 0, &pq);
	192	encode_block(xface->bitmap + XFACE_WIDTH * 32 + 16, 16, 16, 0, &pq);
	193	encode_block(xface->bitmap + XFACE_WIDTH * 32 + 32, 16, 16, 0, &pq);
	194
	195	while (pq.prob_ranges_idx > 0)
f6fa7814	196	push_integer(&b, &pq.prob_ranges[--pq.prob_ranges_idx]);
2ba45a60 DM	197
	198	/* write the inverted big integer in b to intbuf */
	199	i = 0;
f6fa7814	200	av_assert0(b.nb_words < XFACE_MAX_WORDS);
2ba45a60 DM	201	while (b.nb_words) {
	202	uint8_t r;
	203	ff_big_div(&b, XFACE_PRINTS, &r);
f6fa7814	204	av_assert0(i < sizeof(intbuf));
2ba45a60 DM	205	intbuf[i++] = r + XFACE_FIRST_PRINT;
	206	}
	207
	208	if ((ret = ff_alloc_packet2(avctx, pkt, i+2)) < 0)
	209	return ret;
	210
	211	/* revert the number, and close the buffer */
	212	p = pkt->data;
	213	while (--i >= 0)
	214	*(p++) = intbuf[i];
	215	*(p++) = '\n';
	216	*(p++) = 0;
	217
	218	pkt->flags \|= AV_PKT_FLAG_KEY;
	219	*got_packet = 1;
	220
	221	return 0;
	222	}
	223
	224	static av_cold int xface_encode_close(AVCodecContext *avctx)
	225	{
	226	av_freep(&avctx->coded_frame);
	227
	228	return 0;
	229	}
	230
	231	AVCodec ff_xface_encoder = {
	232	.name = "xface",
	233	.long_name = NULL_IF_CONFIG_SMALL("X-face image"),
	234	.type = AVMEDIA_TYPE_VIDEO,
	235	.id = AV_CODEC_ID_XFACE,
	236	.priv_data_size = sizeof(XFaceContext),
	237	.init = xface_encode_init,
	238	.close = xface_encode_close,
	239	.encode2 = xface_encode_frame,
	240	.pix_fmts = (const enum PixelFormat[]) { AV_PIX_FMT_MONOWHITE, AV_PIX_FMT_NONE },
	241	};