libavcodec/pnmdec.c

   1 /*
   2  * PNM image format
   3  * Copyright (c) 2002, 2003 Fabrice Bellard
   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 #include "avcodec.h"
  23 #include "bytestream.h"
  24 #include "pnm.h"
  25
  26
  27 static int pnm_decode_frame(AVCodecContext *avctx, void *data,
  28                             int *data_size, AVPacket *avpkt)
  29 {
  30     const uint8_t *buf   = avpkt->data;
  31     int buf_size         = avpkt->size;
  32     PNMContext * const s = avctx->priv_data;
  33     AVFrame *picture     = data;
  34     AVFrame * const p    = (AVFrame*)&s->picture;
  35     int i, n, linesize, h, upgrade = 0;
  36     unsigned char *ptr;
  37
  38     s->bytestream_start =
  39     s->bytestream       = buf;
  40     s->bytestream_end   = buf + buf_size;
  41
  42     if (ff_pnm_decode_header(avctx, s) < 0)
  43         return -1;
  44
  45     if (p->data[0])
  46         avctx->release_buffer(avctx, p);
  47
  48     p->reference = 0;
  49     if (avctx->get_buffer(avctx, p) < 0) {
  50         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
  51         return -1;
  52     }
  53     p->pict_type = FF_I_TYPE;
  54     p->key_frame = 1;
  55
  56     switch (avctx->pix_fmt) {
  57     default:
  58         return -1;
  59     case PIX_FMT_RGB48BE:
  60         n = avctx->width * 6;
  61         goto do_read;
  62     case PIX_FMT_RGB24:
  63         n = avctx->width * 3;
  64         goto do_read;
  65     case PIX_FMT_GRAY8:
  66         n = avctx->width;
  67         if (s->maxval < 255)
  68             upgrade = 1;
  69         goto do_read;
  70     case PIX_FMT_GRAY16BE:
  71     case PIX_FMT_GRAY16LE:
  72         n = avctx->width * 2;
  73         if (s->maxval < 65535)
  74             upgrade = 2;
  75         goto do_read;
  76     case PIX_FMT_MONOWHITE:
  77     case PIX_FMT_MONOBLACK:
  78         n = (avctx->width + 7) >> 3;
  79     do_read:
  80         ptr      = p->data[0];
  81         linesize = p->linesize[0];
  82         if (s->bytestream + n * avctx->height > s->bytestream_end)
  83             return -1;
  84         for (i = 0; i < avctx->height; i++) {
  85             if (!upgrade)
  86                 memcpy(ptr, s->bytestream, n);
  87             else if (upgrade == 1) {
  88                 unsigned int j, f = (255 * 128 + s->maxval / 2) / s->maxval;
  89                 for (j = 0; j < n; j++)
  90                     ptr[j] = (s->bytestream[j] * f + 64) >> 7;
  91             } else if (upgrade == 2) {
  92                 unsigned int j, v, f = (65535 * 32768 + s->maxval / 2) / s->maxval;
  93                 for (j = 0; j < n / 2; j++) {
  94                     v = be2me_16(((uint16_t *)s->bytestream)[j]);
  95                     ((uint16_t *)ptr)[j] = (v * f + 16384) >> 15;
  96                 }
  97             }
  98             s->bytestream += n;
  99             ptr           += linesize;
 100         }
 101         break;
 102     case PIX_FMT_YUV420P:
 103         {
 104             unsigned char *ptr1, *ptr2;
 105
 106             n        = avctx->width;
 107             ptr      = p->data[0];
 108             linesize = p->linesize[0];
 109             if (s->bytestream + n * avctx->height * 3 / 2 > s->bytestream_end)
 110                 return -1;
 111             for (i = 0; i < avctx->height; i++) {
 112                 memcpy(ptr, s->bytestream, n);
 113                 s->bytestream += n;
 114                 ptr           += linesize;
 115             }
 116             ptr1 = p->data[1];
 117             ptr2 = p->data[2];
 118             n >>= 1;
 119             h = avctx->height >> 1;
 120             for (i = 0; i < h; i++) {
 121                 memcpy(ptr1, s->bytestream, n);
 122                 s->bytestream += n;
 123                 memcpy(ptr2, s->bytestream, n);
 124                 s->bytestream += n;
 125                 ptr1 += p->linesize[1];
 126                 ptr2 += p->linesize[2];
 127             }
 128         }
 129         break;
 130     case PIX_FMT_RGB32:
 131         ptr      = p->data[0];
 132         linesize = p->linesize[0];
 133         if (s->bytestream + avctx->width * avctx->height * 4 > s->bytestream_end)
 134             return -1;
 135         for (i = 0; i < avctx->height; i++) {
 136             int j, r, g, b, a;
 137
 138             for (j = 0; j < avctx->width; j++) {
 139                 r = *s->bytestream++;
 140                 g = *s->bytestream++;
 141                 b = *s->bytestream++;
 142                 a = *s->bytestream++;
 143                 ((uint32_t *)ptr)[j] = (a << 24) | (r << 16) | (g << 8) | b;
 144             }
 145             ptr += linesize;
 146         }
 147         break;
 148     }
 149     *picture   = *(AVFrame*)&s->picture;
 150     *data_size = sizeof(AVPicture);
 151
 152     return s->bytestream - s->bytestream_start;
 153 }
 154
 155
 156 #if CONFIG_PGM_DECODER
 157 AVCodec pgm_decoder = {
 158     "pgm",
 159     CODEC_TYPE_VIDEO,
 160     CODEC_ID_PGM,
 161     sizeof(PNMContext),
 162     ff_pnm_init,
 163     NULL,
 164     ff_pnm_end,
 165     pnm_decode_frame,
 166     CODEC_CAP_DR1,
 167     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE},
 168     .long_name = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
 169 };
 170 #endif
 171
 172 #if CONFIG_PGMYUV_DECODER
 173 AVCodec pgmyuv_decoder = {
 174     "pgmyuv",
 175     CODEC_TYPE_VIDEO,
 176     CODEC_ID_PGMYUV,
 177     sizeof(PNMContext),
 178     ff_pnm_init,
 179     NULL,
 180     ff_pnm_end,
 181     pnm_decode_frame,
 182     CODEC_CAP_DR1,
 183     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
 184     .long_name = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
 185 };
 186 #endif
 187
 188 #if CONFIG_PPM_DECODER
 189 AVCodec ppm_decoder = {
 190     "ppm",
 191     CODEC_TYPE_VIDEO,
 192     CODEC_ID_PPM,
 193     sizeof(PNMContext),
 194     ff_pnm_init,
 195     NULL,
 196     ff_pnm_end,
 197     pnm_decode_frame,
 198     CODEC_CAP_DR1,
 199     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE},
 200     .long_name = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
 201 };
 202 #endif
 203
 204 #if CONFIG_PBM_DECODER
 205 AVCodec pbm_decoder = {
 206     "pbm",
 207     CODEC_TYPE_VIDEO,
 208     CODEC_ID_PBM,
 209     sizeof(PNMContext),
 210     ff_pnm_init,
 211     NULL,
 212     ff_pnm_end,
 213     pnm_decode_frame,
 214     CODEC_CAP_DR1,
 215     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_MONOWHITE, PIX_FMT_NONE},
 216     .long_name = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
 217 };
 218 #endif
 219
 220 #if CONFIG_PAM_DECODER
 221 AVCodec pam_decoder = {
 222     "pam",
 223     CODEC_TYPE_VIDEO,
 224     CODEC_ID_PAM,
 225     sizeof(PNMContext),
 226     ff_pnm_init,
 227     NULL,
 228     ff_pnm_end,
 229     pnm_decode_frame,
 230     CODEC_CAP_DR1,
 231     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOWHITE, PIX_FMT_NONE},
 232     .long_name = NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
 233 };
 234 #endif