libavcodec.hg: png.c comparison

comparison png.c @ 2967:ef2149182f1c libavcodec

COSMETICS: Remove all trailing whitespace.

author	diego
date	Sat, 17 Dec 2005 18:14:38 +0000
parents	b2846918585c
children	0b546eab515d

comparison

equal deleted inserted replaced

-:564788471dd4
+:ef2149182f1c
 int interlace_type;
 int filter_type;
 int channels;
 int bits_per_pixel;
 int bpp;
 uint8_t *image_buf;
 int image_linesize;
 uint32_t palette[256];
 uint8_t *crow_buf;
 uint8_t *last_row;
 static const uint8_t png_pass_mask[NB_PASSES] = {
 0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff
 };
 /* Mask to determine which pixels to overwrite while displaying */
 static const uint8_t png_pass_dsp_mask[NB_PASSES] = {
 0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff
 };
 #if 0
 static int png_probe(AVProbeData *pd)
 {
 }
 /* NOTE: we try to construct a good looking image at each pass. width
 is the original image width. We also do pixel format convertion at
 this stage */
 static void png_put_interlaced_row(uint8_t *dst, int width,
 int bits_per_pixel, int pass,
 int color_type, const uint8_t *src)
 {
 int x, mask, dsp_mask, j, src_x, b, bpp;
 uint8_t *d;
 const uint8_t *s;
 mask = png_pass_mask[pass];
 dsp_mask = png_pass_dsp_mask[pass];
 switch(bits_per_pixel) {
 case 1:
 /* we must intialize the line to zero before writing to it */
 }
 break;
 }
 }
 static void png_get_interlaced_row(uint8_t *dst, int row_size,
 int bits_per_pixel, int pass,
 const uint8_t *src, int width)
 {
 int x, mask, dst_x, j, b, bpp;
 uint8_t *d;
 const uint8_t *s;
 }
 }
 /* XXX: optimize */
 /* NOTE: 'dst' can be equal to 'last' */
 static void png_filter_row(uint8_t *dst, int filter_type,
 uint8_t *src, uint8_t *last, int size, int bpp)
 {
 int i, p;
 switch(filter_type) {
 static void convert_from_rgba32(uint8_t *dst, const uint8_t *src, int width)
 {
 uint8_t *d;
 int j;
 unsigned int v;
 d = dst;
 for(j = 0; j < width; j++) {
 v = ((uint32_t *)src)[j];
 d[0] = v >> 16;
 d[1] = v >> 8;
 /* process exactly one decompressed row */
 static void png_handle_row(PNGContext *s)
 {
 uint8_t *ptr, *last_row;
 int got_line;
 if (!s->interlace_type) {
 ptr = s->image_buf + s->image_linesize * s->y;
 /* need to swap bytes correctly for RGB_ALPHA */
 if (s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
 png_filter_row(s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
 s->last_row, s->row_size, s->bpp);
 memcpy(s->last_row, s->tmp_row, s->row_size);
 convert_to_rgba32(ptr, s->tmp_row, s->width);
 } else {
 /* in normal case, we avoid one copy */
 if (s->y == 0)
 last_row = s->last_row;
 else
 last_row = ptr - s->image_linesize;
 png_filter_row(ptr, s->crow_buf[0], s->crow_buf + 1,
 last_row, s->row_size, s->bpp);
 }
 s->y++;
 if (s->y == s->height) {
 s->state |= PNG_ALLIMAGE;
 if ((png_pass_ymask[s->pass] << (s->y & 7)) & 0x80) {
 /* if we already read one row, it is time to stop to
 wait for the next one */
 if (got_line)
 break;
 png_filter_row(s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
 s->last_row, s->pass_row_size, s->bpp);
 memcpy(s->last_row, s->tmp_row, s->pass_row_size);
 got_line = 1;
 }
 if ((png_pass_dsp_ymask[s->pass] << (s->y & 7)) & 0x80) {
 /* NOTE: rgba32 is handled directly in png_put_interlaced_row */
 png_put_interlaced_row(ptr, s->width, s->bits_per_pixel, s->pass,
 s->color_type, s->last_row);
 }
 s->y++;
 if (s->y == s->height) {
 for(;;) {
 s->state |= PNG_ALLIMAGE;
 goto the_end;
 } else {
 s->pass++;
 s->y = 0;
 s->pass_row_size = png_pass_row_size(s->pass,
 s->bits_per_pixel,
 s->width);
 s->crow_size = s->pass_row_size + 1;
 if (s->pass_row_size != 0)
 break;
 /* skip pass if empty row */
 {
 int ret;
 s->zstream.avail_in = length;
 s->zstream.next_in = s->bytestream;
 s->bytestream += length;
 if(s->bytestream > s->bytestream_end)
 return -1;
 /* decode one line if possible */
 while (s->zstream.avail_in > 0) {
 }
 }
 return 0;
 }
 static int decode_frame(AVCodecContext *avctx,
 void *data, int *data_size,
 uint8_t *buf, int buf_size)
 {
 PNGContext * const s = avctx->priv_data;
 AVFrame *picture = data;
 if (length > 0x7fffffff)
 goto fail;
 tag32 = get32(&s->bytestream);
 tag = bswap_32(tag32);
 #ifdef DEBUG
 printf("png: tag=%c%c%c%c length=%u\n",
 (tag & 0xff),
 ((tag >> 8) & 0xff),
 ((tag >> 16) & 0xff),
 ((tag >> 24) & 0xff), length);
 #endif
 s->filter_type = *s->bytestream++;
 s->interlace_type = *s->bytestream++;
 crc = get32(&s->bytestream);
 s->state |= PNG_IHDR;
 #ifdef DEBUG
 printf("width=%d height=%d depth=%d color_type=%d compression_type=%d filter_type=%d interlace_type=%d\n",
 s->width, s->height, s->bit_depth, s->color_type,
 s->compression_type, s->filter_type, s->interlace_type);
 #endif
 break;
 case MKTAG('I', 'D', 'A', 'T'):
 if (!(s->state & PNG_IHDR))
 s->channels = png_get_nb_channels(s->color_type);
 s->bits_per_pixel = s->bit_depth * s->channels;
 s->bpp = (s->bits_per_pixel + 7) >> 3;
 s->row_size = (avctx->width * s->bits_per_pixel + 7) >> 3;
 if (s->bit_depth == 8 &&
 s->color_type == PNG_COLOR_TYPE_RGB) {
 avctx->pix_fmt = PIX_FMT_RGB24;
 } else if (s->bit_depth == 8 &&
 s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
 avctx->pix_fmt = PIX_FMT_RGBA32;
 } else if (s->bit_depth == 8 &&
 s->color_type == PNG_COLOR_TYPE_GRAY) {
 avctx->pix_fmt = PIX_FMT_GRAY8;
 } else if (s->bit_depth == 1 &&
 s->color_type == PNG_COLOR_TYPE_GRAY) {
 avctx->pix_fmt = PIX_FMT_MONOBLACK;
 } else if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
 avctx->pix_fmt = PIX_FMT_PAL8;
 } else {
 goto fail;
 }
 if(p->data[0])
 avctx->release_buffer(avctx, p);
 p->reference= 0;
 if(avctx->get_buffer(avctx, p) < 0){
 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 goto fail;
 }
 /* compute the compressed row size */
 if (!s->interlace_type) {
 s->crow_size = s->row_size + 1;
 } else {
 s->pass = 0;
 s->pass_row_size = png_pass_row_size(s->pass,
 s->bits_per_pixel,
 s->width);
 s->crow_size = s->pass_row_size + 1;
 }
 #ifdef DEBUG
 printf("row_size=%d crow_size =%d\n",
 s->row_size, s->crow_size);
 #endif
 s->image_buf = p->data[0];
 s->image_linesize = p->linesize[0];
 /* copy the palette if needed */
 crc = get32(&s->bytestream);
 break;
 case MKTAG('P', 'L', 'T', 'E'):
 {
 int n, i, r, g, b;
 if ((length % 3) != 0 || length > 256 * 3)
 goto skip_tag;
 /* read the palette */
 n = length / 3;
 for(i=0;i<n;i++) {
 uint8_t *tmp_buf = NULL;
 *p = *pict;
 p->pict_type= FF_I_TYPE;
 p->key_frame= 1;
 s->bytestream_start=
 s->bytestream= buf;
 s->bytestream_end= buf+buf_size;
 is_progressive = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
 }
 /* write png header */
 memcpy(s->bytestream, pngsig, 8);
 s->bytestream += 8;
 to_be32(s->buf, avctx->width);
 to_be32(s->buf + 4, avctx->height);
 s->buf[8] = bit_depth;
 s->buf[9] = color_type;
 s->buf[10] = 0; /* compression type */
 s->buf[11] = 0; /* filter type */
 s->buf[12] = is_progressive; /* interlace type */
 png_write_chunk(&s->bytestream, MKTAG('I', 'H', 'D', 'R'), s->buf, 13);
 /* put the palette if needed */
 if (color_type == PNG_COLOR_TYPE_PALETTE) {
 int has_alpha, alpha, i;
 unsigned int v;
 uint32_t *palette;
 uint8_t *alpha_ptr;
 palette = (uint32_t *)p->data[1];
 ptr = s->buf;
 alpha_ptr = s->buf + 256 * 3;
 has_alpha = 0;
 for(i = 0; i < 256; i++) {
 convert_from_rgba32(tmp_buf, ptr, avctx->width);
 ptr1 = tmp_buf;
 } else {
 ptr1 = ptr;
 }
 png_get_interlaced_row(crow_buf + 1, pass_row_size,
 bits_per_pixel, pass,
 ptr1, avctx->width);
 crow_buf[0] = PNG_FILTER_VALUE_NONE;
 png_write_row(s, crow_buf, pass_row_size + 1);
 }
 }

Mercurial > libavcodec.hg

comparison png.c @ 2967:ef2149182f1c libavcodec