path: root/libavcodec/lclenc.c (plain)
blob: 357313df494eeae6f9732fe0be646139ff938398

1	/*
2	* LCL (LossLess Codec Library) Codec
3	* Copyright (c) 2002-2004 Roberto Togni
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	* LCL (LossLess Codec Library) Video Codec
25	* Decoder for MSZH and ZLIB codecs
26	* Experimental encoder for ZLIB RGB24
27	*
28	* Fourcc: MSZH, ZLIB
29	*
30	* Original Win32 dll:
31	* Ver2.23 By Kenji Oshima 2000.09.20
32	* avimszh.dll, avizlib.dll
33	*
34	* A description of the decoding algorithm can be found here:
35	* http://www.pcisys.net/~melanson/codecs
36	*
37	* Supports: BGR24 (RGB 24bpp)
38	*/
39
40	#include <stdio.h>
41	#include <stdlib.h>
42
43	#include "libavutil/avassert.h"
44	#include "avcodec.h"
45	#include "internal.h"
46	#include "lcl.h"
47	#include "libavutil/internal.h"
48	#include "libavutil/mem.h"
49
50	#include <zlib.h>
51
52	typedef struct LclEncContext {
53
54	AVCodecContext *avctx;
55
56	// Image type
57	int imgtype;
58	// Compression type
59	int compression;
60	// Flags
61	int flags;
62	z_stream zstream;
63	} LclEncContext;
64
65	static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
66	const AVFrame *p, int *got_packet)
67	{
68	LclEncContext *c = avctx->priv_data;
69	int i, ret;
70	int zret; // Zlib return code
71	int max_size = deflateBound(&c->zstream, avctx->width * avctx->height * 3);
72
73	if ((ret = ff_alloc_packet2(avctx, pkt, max_size, 0)) < 0)
74	return ret;
75
76	if(avctx->pix_fmt != AV_PIX_FMT_BGR24){
77	av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
78	return -1;
79	}
80
81	zret = deflateReset(&c->zstream);
82	if (zret != Z_OK) {
83	av_log(avctx, AV_LOG_ERROR, "Deflate reset error: %d\n", zret);
84	return -1;
85	}
86	c->zstream.next_out = pkt->data;
87	c->zstream.avail_out = pkt->size;
88
89	for(i = avctx->height - 1; i >= 0; i--) {
90	c->zstream.next_in = p->data[0]+p->linesize[0]*i;
91	c->zstream.avail_in = avctx->width*3;
92	zret = deflate(&c->zstream, Z_NO_FLUSH);
93	if (zret != Z_OK) {
94	av_log(avctx, AV_LOG_ERROR, "Deflate error: %d\n", zret);
95	return -1;
96	}
97	}
98	zret = deflate(&c->zstream, Z_FINISH);
99	if (zret != Z_STREAM_END) {
100	av_log(avctx, AV_LOG_ERROR, "Deflate error: %d\n", zret);
101	return -1;
102	}
103
104	pkt->size = c->zstream.total_out;
105	pkt->flags |= AV_PKT_FLAG_KEY;
106	*got_packet = 1;
107
108	return 0;
109	}
110
111	static av_cold int encode_init(AVCodecContext *avctx)
112	{
113	LclEncContext *c = avctx->priv_data;
114	int zret; // Zlib return code
115
116	c->avctx= avctx;
117
118	av_assert0(avctx->width && avctx->height);
119
120	avctx->extradata = av_mallocz(8 + AV_INPUT_BUFFER_PADDING_SIZE);
121	if (!avctx->extradata)
122	return AVERROR(ENOMEM);
123
124	#if FF_API_CODED_FRAME
125	FF_DISABLE_DEPRECATION_WARNINGS
126	avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
127	avctx->coded_frame->key_frame = 1;
128	FF_ENABLE_DEPRECATION_WARNINGS
129	#endif
130
131	c->compression = avctx->compression_level == FF_COMPRESSION_DEFAULT ?
132	COMP_ZLIB_NORMAL :
133	av_clip(avctx->compression_level, 0, 9);
134	c->flags = 0;
135	c->imgtype = IMGTYPE_RGB24;
136	avctx->bits_per_coded_sample= 24;
137
138	avctx->extradata[0]= 4;
139	avctx->extradata[1]= 0;
140	avctx->extradata[2]= 0;
141	avctx->extradata[3]= 0;
142	avctx->extradata[4]= c->imgtype;
143	avctx->extradata[5]= c->compression;
144	avctx->extradata[6]= c->flags;
145	avctx->extradata[7]= CODEC_ZLIB;
146	c->avctx->extradata_size= 8;
147
148	c->zstream.zalloc = Z_NULL;
149	c->zstream.zfree = Z_NULL;
150	c->zstream.opaque = Z_NULL;
151	zret = deflateInit(&c->zstream, c->compression);
152	if (zret != Z_OK) {
153	av_log(avctx, AV_LOG_ERROR, "Deflate init error: %d\n", zret);
154	return AVERROR_UNKNOWN;
155	}
156
157	return 0;
158	}
159
160	static av_cold int encode_end(AVCodecContext *avctx)
161	{
162	LclEncContext *c = avctx->priv_data;
163
164	av_freep(&avctx->extradata);
165	deflateEnd(&c->zstream);
166
167	return 0;
168	}
169
170	AVCodec ff_zlib_encoder = {
171	.name = "zlib",
172	.long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),
173	.type = AVMEDIA_TYPE_VIDEO,
174	.id = AV_CODEC_ID_ZLIB,
175	.priv_data_size = sizeof(LclEncContext),
176	.init = encode_init,
177	.encode2 = encode_frame,
178	.close = encode_end,
179	.capabilities = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
180	.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
181	.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
182	FF_CODEC_CAP_INIT_CLEANUP,
183	};
184