Merge commit '170fb593c617cd797d00cf05bfb8d8c21d612893'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 12 Jul 2013 10:36:04 +0000 (12:36 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 12 Jul 2013 10:36:04 +0000 (12:36 +0200)
* commit '170fb593c617cd797d00cf05bfb8d8c21d612893':
  pcx: K&R formatting cosmetics

Conflicts:
libavcodec/pcx.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/pcx.c

@@@ -35,59 -39,59 +35,61 @@@ static void pcx_rle_decode(GetByteConte
      unsigned char run, value;
  
      if (compressed) {
-         while (i<bytes_per_scanline) {
-             run = 1;
+         while (i < bytes_per_scanline) {
+             run   = 1;
 -            value = *src++;
 +            value = bytestream2_get_byte(gb);
              if (value >= 0xc0) {
-                 run = value & 0x3f;
+                 run   = value & 0x3f;
 -                value = *src++;
 +                value = bytestream2_get_byte(gb);
              }
-             while (i<bytes_per_scanline && run--)
+             while (i < bytes_per_scanline && run--)
                  dst[i++] = value;
          }
      } else {
 -        memcpy(dst, src, bytes_per_scanline);
 -        src += bytes_per_scanline;
 +        bytestream2_get_buffer(gb, dst, bytes_per_scanline);
      }
 -
 -    return src;
  }
  
 -static void pcx_palette(const uint8_t **src, uint32_t *dst,
 -                        unsigned int pallen)
 +static void pcx_palette(GetByteContext *gb, uint32_t *dst, int pallen)
  {
 -    unsigned int i;
 +    int i;
  
-     for (i=0; i<pallen; i++)
 +    pallen = FFMIN(pallen, bytestream2_get_bytes_left(gb) / 3);
 -        *dst++ = bytestream_get_be24(src);
+     for (i = 0; i < pallen; i++)
 +        *dst++ = 0xFF000000 | bytestream2_get_be24u(gb);
      if (pallen < 256)
          memset(dst, 0, (256 - pallen) * sizeof(*dst));
  }
  
  static int pcx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
-                             AVPacket *avpkt) {
+                             AVPacket *avpkt)
+ {
 -    const uint8_t *buf = avpkt->data;
 -    int buf_size       = avpkt->size;
 -    AVFrame *const p   = data;
 +    GetByteContext gb;
-     AVFrame * const p = data;
-     int compressed, xmin, ymin, xmax, ymax, ret;
++    AVFrame * const p  = data;
+     int compressed, xmin, ymin, xmax, ymax;
++    int ret;
      unsigned int w, h, bits_per_pixel, bytes_per_line, nplanes, stride, y, x,
                   bytes_per_scanline;
 -    uint8_t *ptr;
 -    uint8_t const *bufstart = buf;
 -    uint8_t *scanline;
 -    int ret = -1;
 +    uint8_t *ptr, *scanline;
 +
 +    if (avpkt->size < 128)
 +        return AVERROR_INVALIDDATA;
 +
 +    bytestream2_init(&gb, avpkt->data, avpkt->size);
  
 -    if (buf[0] != 0x0a || buf[1] > 5) {
 +    if (bytestream2_get_byteu(&gb) != 0x0a || bytestream2_get_byteu(&gb) > 5) {
          av_log(avctx, AV_LOG_ERROR, "this is not PCX encoded data\n");
          return AVERROR_INVALIDDATA;
      }
  
-     compressed = bytestream2_get_byteu(&gb);
-     bits_per_pixel = bytestream2_get_byteu(&gb);
-     xmin = bytestream2_get_le16u(&gb);
-     ymin = bytestream2_get_le16u(&gb);
-     xmax = bytestream2_get_le16u(&gb);
-     ymax = bytestream2_get_le16u(&gb);
 -    compressed = buf[2];
 -    xmin       = AV_RL16(buf + 4);
 -    ymin       = AV_RL16(buf + 6);
 -    xmax       = AV_RL16(buf + 8);
 -    ymax       = AV_RL16(buf + 10);
++    compressed                     = bytestream2_get_byteu(&gb);
++    bits_per_pixel                 = bytestream2_get_byteu(&gb);
++    xmin                           = bytestream2_get_le16u(&gb);
++    ymin                           = bytestream2_get_le16u(&gb);
++    xmax                           = bytestream2_get_le16u(&gb);
++    ymax                           = bytestream2_get_le16u(&gb);
 +    avctx->sample_aspect_ratio.num = bytestream2_get_le16u(&gb);
 +    avctx->sample_aspect_ratio.den = bytestream2_get_le16u(&gb);
  
      if (xmax < xmin || ymax < ymin) {
          av_log(avctx, AV_LOG_ERROR, "invalid image dimensions\n");
          return AVERROR_INVALIDDATA;
      }
  
-     switch ((nplanes<<8) + bits_per_pixel) {
-         case 0x0308:
-             avctx->pix_fmt = AV_PIX_FMT_RGB24;
-             break;
-         case 0x0108:
-         case 0x0104:
-         case 0x0102:
-         case 0x0101:
-         case 0x0401:
-         case 0x0301:
-         case 0x0201:
-             avctx->pix_fmt = AV_PIX_FMT_PAL8;
-             break;
-         default:
-             av_log(avctx, AV_LOG_ERROR, "invalid PCX file\n");
-             return AVERROR_INVALIDDATA;
+     switch ((nplanes << 8) + bits_per_pixel) {
+     case 0x0308:
+         avctx->pix_fmt = AV_PIX_FMT_RGB24;
+         break;
+     case 0x0108:
+     case 0x0104:
+     case 0x0102:
+     case 0x0101:
+     case 0x0401:
+     case 0x0301:
+     case 0x0201:
+         avctx->pix_fmt = AV_PIX_FMT_PAL8;
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR, "invalid PCX file\n");
+         return AVERROR_INVALIDDATA;
      }
  
 -    buf += 128;
 +    bytestream2_skipu(&gb, 60);
  
      if ((ret = av_image_check_size(w, h, 0, avctx)) < 0)
          return ret;
          return AVERROR(ENOMEM);
  
      if (nplanes == 3 && bits_per_pixel == 8) {
-         for (y=0; y<h; y++) {
+         for (y = 0; y < h; y++) {
 -            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);
 +            pcx_rle_decode(&gb, scanline, bytes_per_scanline, compressed);
  
-             for (x=0; x<w; x++) {
-                 ptr[3*x  ] = scanline[x                    ];
-                 ptr[3*x+1] = scanline[x+ bytes_per_line    ];
-                 ptr[3*x+2] = scanline[x+(bytes_per_line<<1)];
+             for (x = 0; x < w; x++) {
+                 ptr[3 * x]     = scanline[x];
+                 ptr[3 * x + 1] = scanline[x + bytes_per_line];
+                 ptr[3 * x + 2] = scanline[x + (bytes_per_line << 1)];
              }
  
              ptr += stride;
          }
      } else if (nplanes == 1 && bits_per_pixel == 8) {
 -        const uint8_t *palstart = bufstart + buf_size - 769;
 +        int palstart = avpkt->size - 769;
  
-         for (y=0; y<h; y++, ptr+=stride) {
+         for (y = 0; y < h; y++, ptr += stride) {
 -            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);
 +            pcx_rle_decode(&gb, scanline, bytes_per_scanline, compressed);
              memcpy(ptr, scanline, w);
          }
  
 -        if (buf != palstart) {
 +        if (bytestream2_tell(&gb) != palstart) {
              av_log(avctx, AV_LOG_WARNING, "image data possibly corrupted\n");
 -            buf = palstart;
 +            bytestream2_seek(&gb, palstart, SEEK_SET);
          }
 -        if (*buf++ != 12) {
 +        if (bytestream2_get_byte(&gb) != 12) {
              av_log(avctx, AV_LOG_ERROR, "expected palette after image data\n");
 +            ret = AVERROR_INVALIDDATA;
              goto end;
          }
      } else if (nplanes == 1) {   /* all packed formats, max. 16 colors */
          GetBitContext s;
  
-         for (y=0; y<h; y++) {
+         for (y = 0; y < h; y++) {
 -            init_get_bits(&s, scanline, bytes_per_scanline << 3);
 +            init_get_bits8(&s, scanline, bytes_per_scanline);
  
 -            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);
 +            pcx_rle_decode(&gb, scanline, bytes_per_scanline, compressed);
  
-             for (x=0; x<w; x++)
+             for (x = 0; x < w; x++)
                  ptr[x] = get_bits(&s, bits_per_pixel);
              ptr += stride;
          }
      } else {    /* planar, 4, 8 or 16 colors */
          int i;
  
-         for (y=0; y<h; y++) {
+         for (y = 0; y < h; y++) {
 -            buf = pcx_rle_decode(buf, scanline, bytes_per_scanline, compressed);
 +            pcx_rle_decode(&gb, scanline, bytes_per_scanline, compressed);
  
-             for (x=0; x<w; x++) {
-                 int m = 0x80 >> (x&7), v = 0;
-                 for (i=nplanes - 1; i>=0; i--) {
+             for (x = 0; x < w; x++) {
+                 int m = 0x80 >> (x & 7), v = 0;
+                 for (i = nplanes - 1; i >= 0; i--) {
                      v <<= 1;
-                     v  += !!(scanline[i*bytes_per_line + (x>>3)] & m);
+                     v  += !!(scanline[i * bytes_per_line + (x >> 3)] & m);
                  }
                  ptr[x] = v;
              }
          }
      }
  
 +    ret = bytestream2_tell(&gb);
      if (nplanes == 1 && bits_per_pixel == 8) {
-         pcx_palette(&gb, (uint32_t *) p->data[1], 256);
 -        pcx_palette(&buf, (uint32_t *)p->data[1], 256);
++        pcx_palette(&gb, (uint32_t *)p->data[1], 256);
 +        ret += 256 * 3;
 +    } else if (bits_per_pixel * nplanes == 1) {
 +        AV_WN32A(p->data[1]  , 0xFF000000);
 +        AV_WN32A(p->data[1]+4, 0xFFFFFFFF);
      } else if (bits_per_pixel < 8) {
 -        const uint8_t *palette = bufstart + 16;
 -        pcx_palette(&palette, (uint32_t *)p->data[1], 16);
 +        bytestream2_seek(&gb, 16, SEEK_SET);
-         pcx_palette(&gb, (uint32_t *) p->data[1], 16);
++        pcx_palette(&gb, (uint32_t *)p->data[1], 16);
      }
  
      *got_frame = 1;