png.c@ 9441

Last change on this file since 9441 was 5776, checked in by vboxsync, 17 years ago
ffmpeg: exported to OSE
File size: 28.4 KB

Line
1	/*
2	* PNG image format
3	* Copyright (c) 2003 Fabrice Bellard.
4	*
5	* This library is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU Lesser General Public
7	* License as published by the Free Software Foundation; either
8	* version 2 of the License, or (at your option) any later version.
9	*
10	* This library is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13	* Lesser General Public License for more details.
14	*
15	* You should have received a copy of the GNU Lesser General Public
16	* License along with this library; if not, write to the Free Software
17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18	*/
19	#include "avcodec.h"
20
21	/* TODO:
22	* - add 2, 4 and 16 bit depth support
23	* - use filters when generating a png (better compression)
24	*/
25
26	#ifdef CONFIG_ZLIB
27	#include <zlib.h>
28
29	//#define DEBUG
30
31	#define PNG_COLOR_MASK_PALETTE 1
32	#define PNG_COLOR_MASK_COLOR 2
33	#define PNG_COLOR_MASK_ALPHA 4
34
35	#define PNG_COLOR_TYPE_GRAY 0
36	#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR \| PNG_COLOR_MASK_PALETTE)
37	#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
38	#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR \| PNG_COLOR_MASK_ALPHA)
39	#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
40
41	#define PNG_FILTER_VALUE_NONE 0
42	#define PNG_FILTER_VALUE_SUB 1
43	#define PNG_FILTER_VALUE_UP 2
44	#define PNG_FILTER_VALUE_AVG 3
45	#define PNG_FILTER_VALUE_PAETH 4
46
47	#define PNG_IHDR 0x0001
48	#define PNG_IDAT 0x0002
49	#define PNG_ALLIMAGE 0x0004
50	#define PNG_PLTE 0x0008
51
52	#define NB_PASSES 7
53
54	#define IOBUF_SIZE 4096
55
56	typedef struct PNGContext {
57	uint8_t *bytestream;
58	uint8_t *bytestream_start;
59	uint8_t *bytestream_end;
60	AVFrame picture;
61
62	int state;
63	int width, height;
64	int bit_depth;
65	int color_type;
66	int compression_type;
67	int interlace_type;
68	int filter_type;
69	int channels;
70	int bits_per_pixel;
71	int bpp;
72
73	uint8_t *image_buf;
74	int image_linesize;
75	uint32_t palette[256];
76	uint8_t *crow_buf;
77	uint8_t *last_row;
78	uint8_t *tmp_row;
79	int pass;
80	int crow_size; /* compressed row size (include filter type) */
81	int row_size; /* decompressed row size */
82	int pass_row_size; /* decompress row size of the current pass */
83	int y;
84	z_stream zstream;
85	uint8_t buf[IOBUF_SIZE];
86	} PNGContext;
87
88	static unsigned int get32(uint8_t **b){
89	(*b) += 4;
90	return ((b)[-4]<<24) + ((b)[-3]<<16) + ((b)[-2]<<8) + (b)[-1];
91	}
92
93	static void put32(uint8_t **b, unsigned int v){
94	(b)++= v>>24;
95	(b)++= v>>16;
96	(b)++= v>>8;
97	(b)++= v;
98	}
99
100	static const uint8_t pngsig[8] = {137, 80, 78, 71, 13, 10, 26, 10};
101
102	/* Mask to determine which y pixels are valid in a pass */
103	static const uint8_t png_pass_ymask[NB_PASSES] = {
104	0x80, 0x80, 0x08, 0x88, 0x22, 0xaa, 0x55,
105	};
106
107	/* Mask to determine which y pixels can be written in a pass */
108	static const uint8_t png_pass_dsp_ymask[NB_PASSES] = {
109	0xff, 0xff, 0x0f, 0xcc, 0x33, 0xff, 0x55,
110	};
111
112	/* minimum x value */
113	static const uint8_t png_pass_xmin[NB_PASSES] = {
114	0, 4, 0, 2, 0, 1, 0
115	};
116
117	/* x shift to get row width */
118	static const uint8_t png_pass_xshift[NB_PASSES] = {
119	3, 3, 2, 2, 1, 1, 0
120	};
121
122	/* Mask to determine which pixels are valid in a pass */
123	static const uint8_t png_pass_mask[NB_PASSES] = {
124	0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff
125	};
126
127	/* Mask to determine which pixels to overwrite while displaying */
128	static const uint8_t png_pass_dsp_mask[NB_PASSES] = {
129	0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff
130	};
131	#if 0
132	static int png_probe(AVProbeData *pd)
133	{
134	if (pd->buf_size >= 8 &&
135	memcmp(pd->buf, pngsig, 8) == 0)
136	return AVPROBE_SCORE_MAX;
137	else
138	return 0;
139	}
140	#endif
141	static void png_zalloc(void opaque, unsigned int items, unsigned int size)
142	{
143	if(items >= UINT_MAX / size)
144	return NULL;
145	return av_malloc(items * size);
146	}
147
148	static void png_zfree(void opaque, void ptr)
149	{
150	av_free(ptr);
151	}
152
153	static int png_get_nb_channels(int color_type)
154	{
155	int channels;
156	channels = 1;
157	if ((color_type & (PNG_COLOR_MASK_COLOR \| PNG_COLOR_MASK_PALETTE)) ==
158	PNG_COLOR_MASK_COLOR)
159	channels = 3;
160	if (color_type & PNG_COLOR_MASK_ALPHA)
161	channels++;
162	return channels;
163	}
164
165	/* compute the row size of an interleaved pass */
166	static int png_pass_row_size(int pass, int bits_per_pixel, int width)
167	{
168	int shift, xmin, pass_width;
169
170	xmin = png_pass_xmin[pass];
171	if (width <= xmin)
172	return 0;
173	shift = png_pass_xshift[pass];
174	pass_width = (width - xmin + (1 << shift) - 1) >> shift;
175	return (pass_width * bits_per_pixel + 7) >> 3;
176	}
177
178	/* NOTE: we try to construct a good looking image at each pass. width
179	is the original image width. We also do pixel format convertion at
180	this stage */
181	static void png_put_interlaced_row(uint8_t *dst, int width,
182	int bits_per_pixel, int pass,
183	int color_type, const uint8_t *src)
184	{
185	int x, mask, dsp_mask, j, src_x, b, bpp;
186	uint8_t *d;
187	const uint8_t *s;
188
189	mask = png_pass_mask[pass];
190	dsp_mask = png_pass_dsp_mask[pass];
191	switch(bits_per_pixel) {
192	case 1:
193	/* we must intialize the line to zero before writing to it */
194	if (pass == 0)
195	memset(dst, 0, (width + 7) >> 3);
196	src_x = 0;
197	for(x = 0; x < width; x++) {
198	j = (x & 7);
199	if ((dsp_mask << j) & 0x80) {
200	b = (src[src_x >> 3] >> (7 - (src_x & 7))) & 1;
201	dst[x >> 3] \|= b << (7 - j);
202	}
203	if ((mask << j) & 0x80)
204	src_x++;
205	}
206	break;
207	default:
208	bpp = bits_per_pixel >> 3;
209	d = dst;
210	s = src;
211	if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
212	for(x = 0; x < width; x++) {
213	j = x & 7;
214	if ((dsp_mask << j) & 0x80) {
215	(uint32_t )d = (s[3] << 24) \| (s[0] << 16) \| (s[1] << 8) \| s[2];
216	}
217	d += bpp;
218	if ((mask << j) & 0x80)
219	s += bpp;
220	}
221	} else {
222	for(x = 0; x < width; x++) {
223	j = x & 7;
224	if ((dsp_mask << j) & 0x80) {
225	memcpy(d, s, bpp);
226	}
227	d += bpp;
228	if ((mask << j) & 0x80)
229	s += bpp;
230	}
231	}
232	break;
233	}
234	}
235
236	static void png_get_interlaced_row(uint8_t *dst, int row_size,
237	int bits_per_pixel, int pass,
238	const uint8_t *src, int width)
239	{
240	int x, mask, dst_x, j, b, bpp;
241	uint8_t *d;
242	const uint8_t *s;
243
244	mask = png_pass_mask[pass];
245	switch(bits_per_pixel) {
246	case 1:
247	memset(dst, 0, row_size);
248	dst_x = 0;
249	for(x = 0; x < width; x++) {
250	j = (x & 7);
251	if ((mask << j) & 0x80) {
252	b = (src[x >> 3] >> (7 - j)) & 1;
253	dst[dst_x >> 3] \|= b << (7 - (dst_x & 7));
254	dst_x++;
255	}
256	}
257	break;
258	default:
259	bpp = bits_per_pixel >> 3;
260	d = dst;
261	s = src;
262	for(x = 0; x < width; x++) {
263	j = x & 7;
264	if ((mask << j) & 0x80) {
265	memcpy(d, s, bpp);
266	d += bpp;
267	}
268	s += bpp;
269	}
270	break;
271	}
272	}
273
274	/* XXX: optimize */
275	/* NOTE: 'dst' can be equal to 'last' */
276	static void png_filter_row(uint8_t *dst, int filter_type,
277	uint8_t src, uint8_t last, int size, int bpp)
278	{
279	int i, p;
280
281	switch(filter_type) {
282	case PNG_FILTER_VALUE_NONE:
283	memcpy(dst, src, size);
284	break;
285	case PNG_FILTER_VALUE_SUB:
286	for(i = 0; i < bpp; i++) {
287	dst[i] = src[i];
288	}
289	for(i = bpp; i < size; i++) {
290	p = dst[i - bpp];
291	dst[i] = p + src[i];
292	}
293	break;
294	case PNG_FILTER_VALUE_UP:
295	for(i = 0; i < size; i++) {
296	p = last[i];
297	dst[i] = p + src[i];
298	}
299	break;
300	case PNG_FILTER_VALUE_AVG:
301	for(i = 0; i < bpp; i++) {
302	p = (last[i] >> 1);
303	dst[i] = p + src[i];
304	}
305	for(i = bpp; i < size; i++) {
306	p = ((dst[i - bpp] + last[i]) >> 1);
307	dst[i] = p + src[i];
308	}
309	break;
310	case PNG_FILTER_VALUE_PAETH:
311	for(i = 0; i < bpp; i++) {
312	p = last[i];
313	dst[i] = p + src[i];
314	}
315	for(i = bpp; i < size; i++) {
316	int a, b, c, pa, pb, pc;
317
318	a = dst[i - bpp];
319	b = last[i];
320	c = last[i - bpp];
321
322	p = b - c;
323	pc = a - c;
324
325	pa = abs(p);
326	pb = abs(pc);
327	pc = abs(p + pc);
328
329	if (pa <= pb && pa <= pc)
330	p = a;
331	else if (pb <= pc)
332	p = b;
333	else
334	p = c;
335	dst[i] = p + src[i];
336	}
337	break;
338	}
339	}
340
341	static void convert_from_rgba32(uint8_t dst, const uint8_t src, int width)
342	{
343	uint8_t *d;
344	int j;
345	unsigned int v;
346
347	d = dst;
348	for(j = 0; j < width; j++) {
349	v = ((const uint32_t *)src)[j];
350	d[0] = v >> 16;
351	d[1] = v >> 8;
352	d[2] = v;
353	d[3] = v >> 24;
354	d += 4;
355	}
356	}
357
358	static void convert_to_rgba32(uint8_t dst, const uint8_t src, int width)
359	{
360	int j;
361	unsigned int r, g, b, a;
362
363	for(j = 0;j < width; j++) {
364	r = src[0];
365	g = src[1];
366	b = src[2];
367	a = src[3];
368	(uint32_t )dst = (a << 24) \| (r << 16) \| (g << 8) \| b;
369	dst += 4;
370	src += 4;
371	}
372	}
373
374	/* process exactly one decompressed row */
375	static void png_handle_row(PNGContext *s)
376	{
377	uint8_t ptr, last_row;
378	int got_line;
379
380	if (!s->interlace_type) {
381	ptr = s->image_buf + s->image_linesize * s->y;
382	/* need to swap bytes correctly for RGB_ALPHA */
383	if (s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
384	png_filter_row(s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
385	s->last_row, s->row_size, s->bpp);
386	memcpy(s->last_row, s->tmp_row, s->row_size);
387	convert_to_rgba32(ptr, s->tmp_row, s->width);
388	} else {
389	/* in normal case, we avoid one copy */
390	if (s->y == 0)
391	last_row = s->last_row;
392	else
393	last_row = ptr - s->image_linesize;
394
395	png_filter_row(ptr, s->crow_buf[0], s->crow_buf + 1,
396	last_row, s->row_size, s->bpp);
397	}
398	s->y++;
399	if (s->y == s->height) {
400	s->state \|= PNG_ALLIMAGE;
401	}
402	} else {
403	got_line = 0;
404	for(;;) {
405	ptr = s->image_buf + s->image_linesize * s->y;
406	if ((png_pass_ymask[s->pass] << (s->y & 7)) & 0x80) {
407	/* if we already read one row, it is time to stop to
408	wait for the next one */
409	if (got_line)
410	break;
411	png_filter_row(s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
412	s->last_row, s->pass_row_size, s->bpp);
413	memcpy(s->last_row, s->tmp_row, s->pass_row_size);
414	got_line = 1;
415	}
416	if ((png_pass_dsp_ymask[s->pass] << (s->y & 7)) & 0x80) {
417	/* NOTE: rgba32 is handled directly in png_put_interlaced_row */
418	png_put_interlaced_row(ptr, s->width, s->bits_per_pixel, s->pass,
419	s->color_type, s->last_row);
420	}
421	s->y++;
422	if (s->y == s->height) {
423	for(;;) {
424	if (s->pass == NB_PASSES - 1) {
425	s->state \|= PNG_ALLIMAGE;
426	goto the_end;
427	} else {
428	s->pass++;
429	s->y = 0;
430	s->pass_row_size = png_pass_row_size(s->pass,
431	s->bits_per_pixel,
432	s->width);
433	s->crow_size = s->pass_row_size + 1;
434	if (s->pass_row_size != 0)
435	break;
436	/* skip pass if empty row */
437	}
438	}
439	}
440	}
441	the_end: ;
442	}
443	}
444
445	static int png_decode_idat(PNGContext *s, int length)
446	{
447	int ret;
448	s->zstream.avail_in = length;
449	s->zstream.next_in = s->bytestream;
450	s->bytestream += length;
451
452	if(s->bytestream > s->bytestream_end)
453	return -1;
454
455	/* decode one line if possible */
456	while (s->zstream.avail_in > 0) {
457	ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
458	if (ret != Z_OK && ret != Z_STREAM_END) {
459	return -1;
460	}
461	if (s->zstream.avail_out == 0) {
462	if (!(s->state & PNG_ALLIMAGE)) {
463	png_handle_row(s);
464	}
465	s->zstream.avail_out = s->crow_size;
466	s->zstream.next_out = s->crow_buf;
467	}
468	}
469	return 0;
470	}
471
472	static int decode_frame(AVCodecContext *avctx,
473	void data, int data_size,
474	uint8_t *buf, int buf_size)
475	{
476	PNGContext * const s = avctx->priv_data;
477	AVFrame *picture = data;
478	AVFrame * const p= (AVFrame*)&s->picture;
479	uint32_t tag, length;
480	int ret, crc;
481
482	s->bytestream_start=
483	s->bytestream= buf;
484	s->bytestream_end= buf + buf_size;
485
486	/* check signature */
487	if (memcmp(s->bytestream, pngsig, 8) != 0)
488	return -1;
489	s->bytestream+= 8;
490	s->y=
491	s->state=0;
492	// memset(s, 0, sizeof(PNGContext));
493	/* init the zlib */
494	s->zstream.zalloc = png_zalloc;
495	s->zstream.zfree = png_zfree;
496	s->zstream.opaque = NULL;
497	ret = inflateInit(&s->zstream);
498	if (ret != Z_OK)
499	return -1;
500	for(;;) {
501	int tag32;
502	if (s->bytestream >= s->bytestream_end)
503	goto fail;
504	length = get32(&s->bytestream);
505	if (length > 0x7fffffff)
506	goto fail;
507	tag32 = get32(&s->bytestream);
508	tag = bswap_32(tag32);
509	#ifdef DEBUG
510	av_log(avctx, AV_LOG_DEBUG, "png: tag=%c%c%c%c length=%u\n",
511	(tag & 0xff),
512	((tag >> 8) & 0xff),
513	((tag >> 16) & 0xff),
514	((tag >> 24) & 0xff), length);
515	#endif
516	switch(tag) {
517	case MKTAG('I', 'H', 'D', 'R'):
518	if (length != 13)
519	goto fail;
520	s->width = get32(&s->bytestream);
521	s->height = get32(&s->bytestream);
522	if(avcodec_check_dimensions(avctx, s->width, s->height)){
523	s->width= s->height= 0;
524	goto fail;
525	}
526	s->bit_depth = *s->bytestream++;
527	s->color_type = *s->bytestream++;
528	s->compression_type = *s->bytestream++;
529	s->filter_type = *s->bytestream++;
530	s->interlace_type = *s->bytestream++;
531	crc = get32(&s->bytestream);
532	s->state \|= PNG_IHDR;
533	#ifdef DEBUG
534	av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d compression_type=%d filter_type=%d interlace_type=%d\n",
535	s->width, s->height, s->bit_depth, s->color_type,
536	s->compression_type, s->filter_type, s->interlace_type);
537	#endif
538	break;
539	case MKTAG('I', 'D', 'A', 'T'):
540	if (!(s->state & PNG_IHDR))
541	goto fail;
542	if (!(s->state & PNG_IDAT)) {
543	/* init image info */
544	avctx->width = s->width;
545	avctx->height = s->height;
546
547	s->channels = png_get_nb_channels(s->color_type);
548	s->bits_per_pixel = s->bit_depth * s->channels;
549	s->bpp = (s->bits_per_pixel + 7) >> 3;
550	s->row_size = (avctx->width * s->bits_per_pixel + 7) >> 3;
551
552	if (s->bit_depth == 8 &&
553	s->color_type == PNG_COLOR_TYPE_RGB) {
554	avctx->pix_fmt = PIX_FMT_RGB24;
555	} else if (s->bit_depth == 8 &&
556	s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
557	avctx->pix_fmt = PIX_FMT_RGBA32;
558	} else if (s->bit_depth == 8 &&
559	s->color_type == PNG_COLOR_TYPE_GRAY) {
560	avctx->pix_fmt = PIX_FMT_GRAY8;
561	} else if (s->bit_depth == 1 &&
562	s->color_type == PNG_COLOR_TYPE_GRAY) {
563	avctx->pix_fmt = PIX_FMT_MONOBLACK;
564	} else if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
565	avctx->pix_fmt = PIX_FMT_PAL8;
566	} else {
567	goto fail;
568	}
569	if(p->data[0])
570	avctx->release_buffer(avctx, p);
571
572	p->reference= 0;
573	if(avctx->get_buffer(avctx, p) < 0){
574	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
575	goto fail;
576	}
577	p->pict_type= FF_I_TYPE;
578	p->key_frame= 1;
579	p->interlaced_frame = !!s->interlace_type;
580
581	/* compute the compressed row size */
582	if (!s->interlace_type) {
583	s->crow_size = s->row_size + 1;
584	} else {
585	s->pass = 0;
586	s->pass_row_size = png_pass_row_size(s->pass,
587	s->bits_per_pixel,
588	s->width);
589	s->crow_size = s->pass_row_size + 1;
590	}
591	#ifdef DEBUG
592	av_log(avctx, AV_LOG_DEBUG, "row_size=%d crow_size =%d\n",
593	s->row_size, s->crow_size);
594	#endif
595	s->image_buf = p->data[0];
596	s->image_linesize = p->linesize[0];
597	/* copy the palette if needed */
598	if (s->color_type == PNG_COLOR_TYPE_PALETTE)
599	memcpy(p->data[1], s->palette, 256 * sizeof(uint32_t));
600	/* empty row is used if differencing to the first row */
601	s->last_row = av_mallocz(s->row_size);
602	if (!s->last_row)
603	goto fail;
604	if (s->interlace_type \|\|
605	s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
606	s->tmp_row = av_malloc(s->row_size);
607	if (!s->tmp_row)
608	goto fail;
609	}
610	/* compressed row */
611	s->crow_buf = av_malloc(s->row_size + 1);
612	if (!s->crow_buf)
613	goto fail;
614	s->zstream.avail_out = s->crow_size;
615	s->zstream.next_out = s->crow_buf;
616	}
617	s->state \|= PNG_IDAT;
618	if (png_decode_idat(s, length) < 0)
619	goto fail;
620	/* skip crc */
621	crc = get32(&s->bytestream);
622	break;
623	case MKTAG('P', 'L', 'T', 'E'):
624	{
625	int n, i, r, g, b;
626
627	if ((length % 3) != 0 \|\| length > 256 * 3)
628	goto skip_tag;
629	/* read the palette */
630	n = length / 3;
631	for(i=0;i<n;i++) {
632	r = *s->bytestream++;
633	g = *s->bytestream++;
634	b = *s->bytestream++;
635	s->palette[i] = (0xff << 24) \| (r << 16) \| (g << 8) \| b;
636	}
637	for(;i<256;i++) {
638	s->palette[i] = (0xff << 24);
639	}
640	s->state \|= PNG_PLTE;
641	crc = get32(&s->bytestream);
642	}
643	break;
644	case MKTAG('t', 'R', 'N', 'S'):
645	{
646	int v, i;
647
648	/* read the transparency. XXX: Only palette mode supported */
649	if (s->color_type != PNG_COLOR_TYPE_PALETTE \|\|
650	length > 256 \|\|
651	!(s->state & PNG_PLTE))
652	goto skip_tag;
653	for(i=0;i<length;i++) {
654	v = *s->bytestream++;
655	s->palette[i] = (s->palette[i] & 0x00ffffff) \| (v << 24);
656	}
657	crc = get32(&s->bytestream);
658	}
659	break;
660	case MKTAG('I', 'E', 'N', 'D'):
661	if (!(s->state & PNG_ALLIMAGE))
662	goto fail;
663	crc = get32(&s->bytestream);
664	goto exit_loop;
665	default:
666	/* skip tag */
667	skip_tag:
668	s->bytestream += length + 4;
669	break;
670	}
671	}
672	exit_loop:
673	picture= (AVFrame*)&s->picture;
674	*data_size = sizeof(AVPicture);
675
676	ret = s->bytestream - s->bytestream_start;
677	the_end:
678	inflateEnd(&s->zstream);
679	av_freep(&s->crow_buf);
680	av_freep(&s->last_row);
681	av_freep(&s->tmp_row);
682	return ret;
683	fail:
684	ret = -1;
685	goto the_end;
686	}
687
688	static void png_write_chunk(uint8_t **f, uint32_t tag,
689	const uint8_t *buf, int length)
690	{
691	uint32_t crc;
692	uint8_t tagbuf[4];
693
694	put32(f, length);
695	crc = crc32(0, Z_NULL, 0);
696	tagbuf[0] = tag;
697	tagbuf[1] = tag >> 8;
698	tagbuf[2] = tag >> 16;
699	tagbuf[3] = tag >> 24;
700	crc = crc32(crc, tagbuf, 4);
701	put32(f, bswap_32(tag));
702	if (length > 0) {
703	crc = crc32(crc, buf, length);
704	memcpy(*f, buf, length);
705	*f += length;
706	}
707	put32(f, crc);
708	}
709
710	/* XXX: use avcodec generic function ? */
711	static void to_be32(uint8_t *p, uint32_t v)
712	{
713	p[0] = v >> 24;
714	p[1] = v >> 16;
715	p[2] = v >> 8;
716	p[3] = v;
717	}
718
719	/* XXX: do filtering */
720	static int png_write_row(PNGContext s, const uint8_t data, int size)
721	{
722	int ret;
723
724	s->zstream.avail_in = size;
725	s->zstream.next_in = (uint8_t *)data;
726	while (s->zstream.avail_in > 0) {
727	ret = deflate(&s->zstream, Z_NO_FLUSH);
728	if (ret != Z_OK)
729	return -1;
730	if (s->zstream.avail_out == 0) {
731	if(s->bytestream_end - s->bytestream > IOBUF_SIZE + 100)
732	png_write_chunk(&s->bytestream, MKTAG('I', 'D', 'A', 'T'), s->buf, IOBUF_SIZE);
733	s->zstream.avail_out = IOBUF_SIZE;
734	s->zstream.next_out = s->buf;
735	}
736	}
737	return 0;
738	}
739
740	static int common_init(AVCodecContext *avctx){
741	PNGContext *s = avctx->priv_data;
742
743	avcodec_get_frame_defaults((AVFrame*)&s->picture);
744	avctx->coded_frame= (AVFrame*)&s->picture;
745	// s->avctx= avctx;
746
747	return 0;
748	}
749
750	static int encode_frame(AVCodecContext avctx, unsigned char buf, int buf_size, void *data){
751	PNGContext *s = avctx->priv_data;
752	AVFrame *pict = data;
753	AVFrame * const p= (AVFrame*)&s->picture;
754	int bit_depth, color_type, y, len, row_size, ret, is_progressive;
755	int bits_per_pixel, pass_row_size;
756	uint8_t *ptr;
757	uint8_t *crow_buf = NULL;
758	uint8_t *tmp_buf = NULL;
759
760	p = pict;
761	p->pict_type= FF_I_TYPE;
762	p->key_frame= 1;
763
764	s->bytestream_start=
765	s->bytestream= buf;
766	s->bytestream_end= buf+buf_size;
767
768	is_progressive = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
769	switch(avctx->pix_fmt) {
770	case PIX_FMT_RGBA32:
771	bit_depth = 8;
772	color_type = PNG_COLOR_TYPE_RGB_ALPHA;
773	break;
774	case PIX_FMT_RGB24:
775	bit_depth = 8;
776	color_type = PNG_COLOR_TYPE_RGB;
777	break;
778	case PIX_FMT_GRAY8:
779	bit_depth = 8;
780	color_type = PNG_COLOR_TYPE_GRAY;
781	break;
782	case PIX_FMT_MONOBLACK:
783	bit_depth = 1;
784	color_type = PNG_COLOR_TYPE_GRAY;
785	break;
786	case PIX_FMT_PAL8:
787	bit_depth = 8;
788	color_type = PNG_COLOR_TYPE_PALETTE;
789	break;
790	default:
791	return -1;
792	}
793	bits_per_pixel = png_get_nb_channels(color_type) * bit_depth;
794	row_size = (avctx->width * bits_per_pixel + 7) >> 3;
795
796	s->zstream.zalloc = png_zalloc;
797	s->zstream.zfree = png_zfree;
798	s->zstream.opaque = NULL;
799	ret = deflateInit2(&s->zstream, Z_DEFAULT_COMPRESSION,
800	Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY);
801	if (ret != Z_OK)
802	return -1;
803	crow_buf = av_malloc(row_size + 1);
804	if (!crow_buf)
805	goto fail;
806	if (is_progressive) {
807	tmp_buf = av_malloc(row_size + 1);
808	if (!tmp_buf)
809	goto fail;
810	}
811
812	/* write png header */
813	memcpy(s->bytestream, pngsig, 8);
814	s->bytestream += 8;
815
816	to_be32(s->buf, avctx->width);
817	to_be32(s->buf + 4, avctx->height);
818	s->buf[8] = bit_depth;
819	s->buf[9] = color_type;
820	s->buf[10] = 0; /* compression type */
821	s->buf[11] = 0; /* filter type */
822	s->buf[12] = is_progressive; /* interlace type */
823
824	png_write_chunk(&s->bytestream, MKTAG('I', 'H', 'D', 'R'), s->buf, 13);
825
826	/* put the palette if needed */
827	if (color_type == PNG_COLOR_TYPE_PALETTE) {
828	int has_alpha, alpha, i;
829	unsigned int v;
830	uint32_t *palette;
831	uint8_t *alpha_ptr;
832
833	palette = (uint32_t *)p->data[1];
834	ptr = s->buf;
835	alpha_ptr = s->buf + 256 * 3;
836	has_alpha = 0;
837	for(i = 0; i < 256; i++) {
838	v = palette[i];
839	alpha = v >> 24;
840	if (alpha != 0xff)
841	has_alpha = 1;
842	*alpha_ptr++ = alpha;
843	ptr[0] = v >> 16;
844	ptr[1] = v >> 8;
845	ptr[2] = v;
846	ptr += 3;
847	}
848	png_write_chunk(&s->bytestream, MKTAG('P', 'L', 'T', 'E'), s->buf, 256 * 3);
849	if (has_alpha) {
850	png_write_chunk(&s->bytestream, MKTAG('t', 'R', 'N', 'S'), s->buf + 256 * 3, 256);
851	}
852	}
853
854	/* now put each row */
855	s->zstream.avail_out = IOBUF_SIZE;
856	s->zstream.next_out = s->buf;
857	if (is_progressive) {
858	uint8_t *ptr1;
859	int pass;
860
861	for(pass = 0; pass < NB_PASSES; pass++) {
862	/* NOTE: a pass is completely omited if no pixels would be
863	output */
864	pass_row_size = png_pass_row_size(pass, bits_per_pixel, avctx->width);
865	if (pass_row_size > 0) {
866	for(y = 0; y < avctx->height; y++) {
867	if ((png_pass_ymask[pass] << (y & 7)) & 0x80) {
868	ptr = p->data[0] + y * p->linesize[0];
869	if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
870	convert_from_rgba32(tmp_buf, ptr, avctx->width);
871	ptr1 = tmp_buf;
872	} else {
873	ptr1 = ptr;
874	}
875	png_get_interlaced_row(crow_buf + 1, pass_row_size,
876	bits_per_pixel, pass,
877	ptr1, avctx->width);
878	crow_buf[0] = PNG_FILTER_VALUE_NONE;
879	png_write_row(s, crow_buf, pass_row_size + 1);
880	}
881	}
882	}
883	}
884	} else {
885	for(y = 0; y < avctx->height; y++) {
886	ptr = p->data[0] + y * p->linesize[0];
887	if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
888	convert_from_rgba32(crow_buf + 1, ptr, avctx->width);
889	else
890	memcpy(crow_buf + 1, ptr, row_size);
891	crow_buf[0] = PNG_FILTER_VALUE_NONE;
892	png_write_row(s, crow_buf, row_size + 1);
893	}
894	}
895	/* compress last bytes */
896	for(;;) {
897	ret = deflate(&s->zstream, Z_FINISH);
898	if (ret == Z_OK \|\| ret == Z_STREAM_END) {
899	len = IOBUF_SIZE - s->zstream.avail_out;
900	if (len > 0 && s->bytestream_end - s->bytestream > len + 100) {
901	png_write_chunk(&s->bytestream, MKTAG('I', 'D', 'A', 'T'), s->buf, len);
902	}
903	s->zstream.avail_out = IOBUF_SIZE;
904	s->zstream.next_out = s->buf;
905	if (ret == Z_STREAM_END)
906	break;
907	} else {
908	goto fail;
909	}
910	}
911	png_write_chunk(&s->bytestream, MKTAG('I', 'E', 'N', 'D'), NULL, 0);
912
913	ret = s->bytestream - s->bytestream_start;
914	the_end:
915	av_free(crow_buf);
916	av_free(tmp_buf);
917	deflateEnd(&s->zstream);
918	return ret;
919	fail:
920	ret = -1;
921	goto the_end;
922	}
923
924	AVCodec png_decoder = {
925	"png",
926	CODEC_TYPE_VIDEO,
927	CODEC_ID_PNG,
928	sizeof(PNGContext),
929	common_init,
930	NULL,
931	NULL, //decode_end,
932	decode_frame,
933	0 /CODEC_CAP_DR1/ /\| CODEC_CAP_DRAW_HORIZ_BAND/,
934	NULL
935	};
936
937	#ifdef CONFIG_PNG_ENCODER
938	AVCodec png_encoder = {
939	"png",
940	CODEC_TYPE_VIDEO,
941	CODEC_ID_PNG,
942	sizeof(PNGContext),
943	common_init,
944	encode_frame,
945	NULL, //encode_end,
946	.pix_fmts= (enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGBA32, PIX_FMT_PAL8, PIX_FMT_GRAY8, PIX_FMT_MONOBLACK, -1},
947	};
948	#endif // CONFIG_PNG_ENCODER
949	#endif

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/ffmpeg-20060710/libavcodec/png.c@ 9441

Download in other formats: