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

/*
 * PAM image format
 * Copyright (c) 2002, 2003 Fabrice Bellard
 *
 * 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
 */

#include "avcodec.h"
#include "internal.h"

static int pam_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                            const AVFrame *p, int *got_packet)
{
    uint8_t *bytestream_start, *bytestream, *bytestream_end;
    int i, h, w, n, linesize, depth, maxval, ret;
    const char *tuple_type;
    uint8_t *ptr;

    h = avctx->height;
    w = avctx->width;
    switch (avctx->pix_fmt) {
    case AV_PIX_FMT_MONOBLACK:
        n          = w;
        depth      = 1;
        maxval     = 1;
        tuple_type = "BLACKANDWHITE";
        break;
    case AV_PIX_FMT_GRAY8:
        n          = w;
        depth      = 1;
        maxval     = 255;
        tuple_type = "GRAYSCALE";
        break;
    case AV_PIX_FMT_GRAY16BE:
        n          = w * 2;
        depth      = 1;
        maxval     = 0xFFFF;
        tuple_type = "GRAYSCALE";
        break;
    case AV_PIX_FMT_GRAY8A:
        n          = w * 2;
        depth      = 2;
        maxval     = 255;
        tuple_type = "GRAYSCALE_ALPHA";
        break;
    case AV_PIX_FMT_RGB24:
        n          = w * 3;
        depth      = 3;
        maxval     = 255;
        tuple_type = "RGB";
        break;
    case AV_PIX_FMT_RGBA:
        n          = w * 4;
        depth      = 4;
        maxval     = 255;
        tuple_type = "RGB_ALPHA";
        break;
    case AV_PIX_FMT_RGB48BE:
        n          = w * 6;
        depth      = 3;
        maxval     = 0xFFFF;
        tuple_type = "RGB";
        break;
    case AV_PIX_FMT_RGBA64BE:
        n          = w * 8;
        depth      = 4;
        maxval     = 0xFFFF;
        tuple_type = "RGB_ALPHA";
        break;
    default:
        return -1;
    }

    if ((ret = ff_alloc_packet2(avctx, pkt, n*h + 200)) < 0)
        return ret;

    bytestream_start =
    bytestream       = pkt->data;
    bytestream_end   = pkt->data + pkt->size;

    snprintf(bytestream, bytestream_end - bytestream,
             "P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\nTUPLTYPE %s\nENDHDR\n",
             w, h, depth, maxval, tuple_type);
    bytestream += strlen(bytestream);

    ptr      = p->data[0];
    linesize = p->linesize[0];

    if (avctx->pix_fmt == AV_PIX_FMT_MONOBLACK){
        int j;
        for (i = 0; i < h; i++) {
            for (j = 0; j < w; j++)
                *bytestream++ = ptr[j >> 3] >> (7 - j & 7) & 1;
            ptr += linesize;
        }
    } else {
        for (i = 0; i < h; i++) {
            memcpy(bytestream, ptr, n);
            bytestream += n;
            ptr        += linesize;
        }
    }

    pkt->size   = bytestream - bytestream_start;
    pkt->flags |= AV_PKT_FLAG_KEY;
    *got_packet = 1;
    return 0;
}

static av_cold int pam_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;
    avctx->coded_frame->key_frame = 1;

    return 0;
}

static av_cold int pam_encode_close(AVCodecContext *avctx)
{
    av_frame_free(&avctx->coded_frame);
    return 0;
}

AVCodec ff_pam_encoder = {
    .name           = "pam",
    .long_name      = NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_PAM,
    .init           = pam_encode_init,
    .close          = pam_encode_close,
    .encode2        = pam_encode_frame,
    .pix_fmts       = (const enum AVPixelFormat[]){
        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE
    },
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* PAM image format
	3	* Copyright (c) 2002, 2003 Fabrice Bellard
	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	#include "avcodec.h"
	23	#include "internal.h"
	24
	25	static int pam_encode_frame(AVCodecContext avctx, AVPacket pkt,
	26	const AVFrame p, int got_packet)
	27	{
	28	uint8_t bytestream_start, bytestream, *bytestream_end;
	29	int i, h, w, n, linesize, depth, maxval, ret;
	30	const char *tuple_type;
	31	uint8_t *ptr;
	32
	33	h = avctx->height;
	34	w = avctx->width;
	35	switch (avctx->pix_fmt) {
	36	case AV_PIX_FMT_MONOBLACK:
	37	n = w;
	38	depth = 1;
	39	maxval = 1;
	40	tuple_type = "BLACKANDWHITE";
	41	break;
	42	case AV_PIX_FMT_GRAY8:
	43	n = w;
	44	depth = 1;
	45	maxval = 255;
	46	tuple_type = "GRAYSCALE";
	47	break;
	48	case AV_PIX_FMT_GRAY16BE:
	49	n = w * 2;
	50	depth = 1;
	51	maxval = 0xFFFF;
	52	tuple_type = "GRAYSCALE";
	53	break;
	54	case AV_PIX_FMT_GRAY8A:
	55	n = w * 2;
	56	depth = 2;
	57	maxval = 255;
	58	tuple_type = "GRAYSCALE_ALPHA";
	59	break;
	60	case AV_PIX_FMT_RGB24:
	61	n = w * 3;
	62	depth = 3;
	63	maxval = 255;
	64	tuple_type = "RGB";
65	break;
66	case AV_PIX_FMT_RGBA:
67	n = w * 4;
68	depth = 4;
69	maxval = 255;
70	tuple_type = "RGB_ALPHA";
71	break;
72	case AV_PIX_FMT_RGB48BE:
73	n = w * 6;
74	depth = 3;
75	maxval = 0xFFFF;
76	tuple_type = "RGB";
77	break;
78	case AV_PIX_FMT_RGBA64BE:
79	n = w * 8;
80	depth = 4;
81	maxval = 0xFFFF;
82	tuple_type = "RGB_ALPHA";
83	break;
84	default:
85	return -1;
86	}
87
88	if ((ret = ff_alloc_packet2(avctx, pkt, n*h + 200)) < 0)
89	return ret;
90
91	bytestream_start =
92	bytestream = pkt->data;
93	bytestream_end = pkt->data + pkt->size;
94
95	snprintf(bytestream, bytestream_end - bytestream,
96	"P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\nTUPLTYPE %s\nENDHDR\n",
97	w, h, depth, maxval, tuple_type);
98	bytestream += strlen(bytestream);
99
100	ptr = p->data[0];
101	linesize = p->linesize[0];
102
103	if (avctx->pix_fmt == AV_PIX_FMT_MONOBLACK){
104	int j;
105	for (i = 0; i < h; i++) {
106	for (j = 0; j < w; j++)
107	*bytestream++ = ptr[j >> 3] >> (7 - j & 7) & 1;
108	ptr += linesize;
109	}
110	} else {
111	for (i = 0; i < h; i++) {
112	memcpy(bytestream, ptr, n);
113	bytestream += n;
114	ptr += linesize;
115	}
116	}
117
118	pkt->size = bytestream - bytestream_start;
119	pkt->flags \|= AV_PKT_FLAG_KEY;
120	*got_packet = 1;
121	return 0;
122	}
123
124	static av_cold int pam_encode_init(AVCodecContext *avctx)
125	{
126	avctx->coded_frame = av_frame_alloc();
127	if (!avctx->coded_frame)
128	return AVERROR(ENOMEM);
129
130	avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
131	avctx->coded_frame->key_frame = 1;
132
133	return 0;
134	}
135
136	static av_cold int pam_encode_close(AVCodecContext *avctx)
137	{
138	av_frame_free(&avctx->coded_frame);
139	return 0;
140	}
141
142	AVCodec ff_pam_encoder = {
143	.name = "pam",
144	.long_name = NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
145	.type = AVMEDIA_TYPE_VIDEO,
146	.id = AV_CODEC_ID_PAM,
147	.init = pam_encode_init,
148	.close = pam_encode_close,
149	.encode2 = pam_encode_frame,
150	.pix_fmts = (const enum AVPixelFormat[]){
151	AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE
152	},
153	};