RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

8bps: K&R formatting cosmetics 

Signed-off-by: Diego Biurrun <diego@biurrun.de>
This commit is contained in:
Paul B Mahol 2012-01-26 19:21:15 +00:00 committed by Diego Biurrun
parent 9adf25c1cf
commit 324e818093
1 changed files with 123 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

243
libavcodec/8bps.c
View File

@ -38,20 +38,20 @@
#include "avcodec.h" #include "avcodec.h"
static const enum PixelFormat pixfmt_rgb24[] = {PIX_FMT_BGR24, PIX_FMT_RGB32, PIX_FMT_NONE}; static const enum PixelFormat pixfmt_rgb24[] = {
PIX_FMT_BGR24, PIX_FMT_RGB32, PIX_FMT_NONE };
/* /*
* Decoder context * Decoder context
*/ */
typedef struct EightBpsContext { typedef struct EightBpsContext {
AVCodecContext *avctx;
AVFrame pic;
AVCodecContext *avctx; unsigned char planes;
AVFrame pic; unsigned char planemap[4];
unsigned char planes; uint32_t pal[256];
unsigned char planemap[4];
uint32_t pal[256];
} EightBpsContext; } EightBpsContext;
@ -60,94 +60,97 @@ typedef struct EightBpsContext {
* Decode a frame * Decode a frame
* *
*/ */
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) static int decode_frame(AVCodecContext *avctx, void *data,
int *data_size, AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
EightBpsContext * const c = avctx->priv_data; EightBpsContext * const c = avctx->priv_data;
const unsigned char *encoded = buf; const unsigned char *encoded = buf;
unsigned char *pixptr, *pixptr_end; unsigned char *pixptr, *pixptr_end;
unsigned int height = avctx->height; // Real image height unsigned int height = avctx->height; // Real image height
unsigned int dlen, p, row; unsigned int dlen, p, row;
const unsigned char *lp, *dp; const unsigned char *lp, *dp;
unsigned char count; unsigned char count;
unsigned int px_inc; unsigned int px_inc;
unsigned int planes = c->planes; unsigned int planes = c->planes;
unsigned char *planemap = c->planemap; unsigned char *planemap = c->planemap;
if(c->pic.data[0]) if (c->pic.data[0])
avctx->release_buffer(avctx, &c->pic); avctx->release_buffer(avctx, &c->pic);
c->pic.reference = 0; c->pic.reference = 0;
c->pic.buffer_hints = FF_BUFFER_HINTS_VALID; c->pic.buffer_hints = FF_BUFFER_HINTS_VALID;
if(avctx->get_buffer(avctx, &c->pic) < 0){ if (avctx->get_buffer(avctx, &c->pic) < 0){
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1; return -1;
} }
/* Set data pointer after line lengths */ /* Set data pointer after line lengths */
dp = encoded + planes * (height << 1); dp = encoded + planes * (height << 1);
/* Ignore alpha plane, don't know what to do with it */ /* Ignore alpha plane, don't know what to do with it */
if (planes == 4) if (planes == 4)
planes--; planes--;
px_inc = planes + (avctx->pix_fmt == PIX_FMT_RGB32); px_inc = planes + (avctx->pix_fmt == PIX_FMT_RGB32);
for (p = 0; p < planes; p++) { for (p = 0; p < planes; p++) {
/* Lines length pointer for this plane */ /* Lines length pointer for this plane */
lp = encoded + p * (height << 1); lp = encoded + p * (height << 1);
/* Decode a plane */ /* Decode a plane */
for(row = 0; row < height; row++) { for (row = 0; row < height; row++) {
pixptr = c->pic.data[0] + row * c->pic.linesize[0] + planemap[p]; pixptr = c->pic.data[0] + row * c->pic.linesize[0] + planemap[p];
pixptr_end = pixptr + c->pic.linesize[0]; pixptr_end = pixptr + c->pic.linesize[0];
dlen = av_be2ne16(*(const unsigned short *)(lp+row*2)); dlen = av_be2ne16(*(const unsigned short *)(lp + row * 2));
/* Decode a row of this plane */ /* Decode a row of this plane */
while(dlen > 0) { while (dlen > 0) {
if(dp + 1 >= buf+buf_size) return -1; if (dp + 1 >= buf + buf_size)
if ((count = *dp++) <= 127) { return -1;
count++; if ((count = *dp++) <= 127) {
dlen -= count + 1; count++;
if (pixptr + count * px_inc > pixptr_end) dlen -= count + 1;
break; if (pixptr + count * px_inc > pixptr_end)
if(dp + count > buf+buf_size) return -1; break;
while(count--) { if (dp + count > buf + buf_size)
*pixptr = *dp++; return -1;
pixptr += px_inc; while (count--) {
} *pixptr = *dp++;
} else { pixptr += px_inc;
count = 257 - count; }
if (pixptr + count * px_inc > pixptr_end) } else {
break; count = 257 - count;
while(count--) { if (pixptr + count * px_inc > pixptr_end)
*pixptr = *dp; break;
pixptr += px_inc; while (count--) {
} *pixptr = *dp;
dp++; pixptr += px_inc;
dlen -= 2; }
} dp++;
} dlen -= 2;
} }
}
}
}
if (avctx->bits_per_coded_sample <= 8) {
const uint8_t *pal = av_packet_get_side_data(avpkt,
AV_PKT_DATA_PALETTE,
NULL);
if (pal) {
c->pic.palette_has_changed = 1;
memcpy(c->pal, pal, AVPALETTE_SIZE);
} }
if (avctx->bits_per_coded_sample <= 8) { memcpy (c->pic.data[1], c->pal, AVPALETTE_SIZE);
const uint8_t *pal = av_packet_get_side_data(avpkt, }
AV_PKT_DATA_PALETTE,
NULL);
if (pal) {
c->pic.palette_has_changed = 1;
memcpy(c->pal, pal, AVPALETTE_SIZE);
}
memcpy (c->pic.data[1], c->pal, AVPALETTE_SIZE); *data_size = sizeof(AVFrame);
} *(AVFrame*)data = c->pic;
*data_size = sizeof(AVFrame); /* always report that the buffer was completely consumed */
*(AVFrame*)data = c->pic; return buf_size;
/* always report that the buffer was completely consumed */
return buf_size;
} }
@ -158,46 +161,46 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
*/ */
static av_cold int decode_init(AVCodecContext *avctx) static av_cold int decode_init(AVCodecContext *avctx)
{ {
EightBpsContext * const c = avctx->priv_data; EightBpsContext * const c = avctx->priv_data;
c->avctx = avctx; c->avctx = avctx;
c->pic.data[0] = NULL;
c->pic.data[0] = NULL; switch (avctx->bits_per_coded_sample) {
case 8:
switch (avctx->bits_per_coded_sample) { avctx->pix_fmt = PIX_FMT_PAL8;
case 8: c->planes = 1;
avctx->pix_fmt = PIX_FMT_PAL8; c->planemap[0] = 0; // 1st plane is palette indexes
c->planes = 1; break;
c->planemap[0] = 0; // 1st plane is palette indexes case 24:
break; avctx->pix_fmt = avctx->get_format(avctx, pixfmt_rgb24);
case 24: c->planes = 3;
avctx->pix_fmt = avctx->get_format(avctx, pixfmt_rgb24); c->planemap[0] = 2; // 1st plane is red
c->planes = 3; c->planemap[1] = 1; // 2nd plane is green
c->planemap[0] = 2; // 1st plane is red c->planemap[2] = 0; // 3rd plane is blue
c->planemap[1] = 1; // 2nd plane is green break;
c->planemap[2] = 0; // 3rd plane is blue case 32:
break; avctx->pix_fmt = PIX_FMT_RGB32;
case 32: c->planes = 4;
avctx->pix_fmt = PIX_FMT_RGB32;
c->planes = 4;
#if HAVE_BIGENDIAN #if HAVE_BIGENDIAN
c->planemap[0] = 1; // 1st plane is red c->planemap[0] = 1; // 1st plane is red
c->planemap[1] = 2; // 2nd plane is green c->planemap[1] = 2; // 2nd plane is green
c->planemap[2] = 3; // 3rd plane is blue c->planemap[2] = 3; // 3rd plane is blue
c->planemap[3] = 0; // 4th plane is alpha??? c->planemap[3] = 0; // 4th plane is alpha???
#else #else
c->planemap[0] = 2; // 1st plane is red c->planemap[0] = 2; // 1st plane is red
c->planemap[1] = 1; // 2nd plane is green c->planemap[1] = 1; // 2nd plane is green
c->planemap[2] = 0; // 3rd plane is blue c->planemap[2] = 0; // 3rd plane is blue
c->planemap[3] = 3; // 4th plane is alpha??? c->planemap[3] = 3; // 4th plane is alpha???
#endif #endif
break; break;
default: default:
av_log(avctx, AV_LOG_ERROR, "Error: Unsupported color depth: %u.\n", avctx->bits_per_coded_sample); av_log(avctx, AV_LOG_ERROR, "Error: Unsupported color depth: %u.\n",
return -1; avctx->bits_per_coded_sample);
} return -1;
}
return 0; return 0;
} }
@ -210,12 +213,12 @@ static av_cold int decode_init(AVCodecContext *avctx)
*/ */
static av_cold int decode_end(AVCodecContext *avctx) static av_cold int decode_end(AVCodecContext *avctx)
{ {
EightBpsContext * const c = avctx->priv_data; EightBpsContext * const c = avctx->priv_data;
if (c->pic.data[0]) if (c->pic.data[0])
avctx->release_buffer(avctx, &c->pic); avctx->release_buffer(avctx, &c->pic);
return 0; return 0;
} }