libavcodec/pnmenc.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 #include "avcodec.h"
  22 #include "bytestream.h"
  23 #include "pnm.h"
  24
  25
  26 static av_cold int common_init(AVCodecContext *avctx){
  27     PNMContext *s = avctx->priv_data;
  28
  29     avcodec_get_frame_defaults((AVFrame*)&s->picture);
  30     avctx->coded_frame= (AVFrame*)&s->picture;
  31
  32     return 0;
  33 }
  34
  35 static int pnm_decode_frame(AVCodecContext *avctx,
  36                         void *data, int *data_size,
  37                         AVPacket *avpkt)
  38 {
  39     const uint8_t *buf = avpkt->data;
  40     int buf_size = avpkt->size;
  41     PNMContext * const s = avctx->priv_data;
  42     AVFrame *picture = data;
  43     AVFrame * const p= (AVFrame*)&s->picture;
  44     int i, n, linesize, h, upgrade = 0;
  45     unsigned char *ptr;
  46
  47     s->bytestream_start=
  48     s->bytestream= buf;
  49     s->bytestream_end= buf + buf_size;
  50
  51     if(ff_pnm_decode_header(avctx, s) < 0)
  52         return -1;
  53
  54     if(p->data[0])
  55         avctx->release_buffer(avctx, p);
  56
  57     p->reference= 0;
  58     if(avctx->get_buffer(avctx, p) < 0){
  59         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
  60         return -1;
  61     }
  62     p->pict_type= FF_I_TYPE;
  63     p->key_frame= 1;
  64
  65     switch(avctx->pix_fmt) {
  66     default:
  67         return -1;
  68     case PIX_FMT_RGB48BE:
  69         n = avctx->width * 6;
  70         goto do_read;
  71     case PIX_FMT_RGB24:
  72         n = avctx->width * 3;
  73         goto do_read;
  74     case PIX_FMT_GRAY8:
  75         n = avctx->width;
  76         if (s->maxval < 255)
  77             upgrade = 1;
  78         goto do_read;
  79     case PIX_FMT_GRAY16BE:
  80     case PIX_FMT_GRAY16LE:
  81         n = avctx->width * 2;
  82         if (s->maxval < 65535)
  83             upgrade = 2;
  84         goto do_read;
  85     case PIX_FMT_MONOWHITE:
  86     case PIX_FMT_MONOBLACK:
  87         n = (avctx->width + 7) >> 3;
  88     do_read:
  89         ptr = p->data[0];
  90         linesize = p->linesize[0];
  91         if(s->bytestream + n*avctx->height > s->bytestream_end)
  92             return -1;
  93         for(i = 0; i < avctx->height; i++) {
  94             if (!upgrade)
  95                 memcpy(ptr, s->bytestream, n);
  96             else if (upgrade == 1) {
  97                 unsigned int j, f = (255*128 + s->maxval/2) / s->maxval;
  98                 for (j=0; j<n; j++)
  99                     ptr[j] = (s->bytestream[j] * f + 64) >> 7;
 100             } else if (upgrade == 2) {
 101                 unsigned int j, v, f = (65535*32768 + s->maxval/2) / s->maxval;
 102                 for (j=0; j<n/2; j++) {
 103                     v = be2me_16(((uint16_t *)s->bytestream)[j]);
 104                     ((uint16_t *)ptr)[j] = (v * f + 16384) >> 15;
 105                 }
 106             }
 107             s->bytestream += n;
 108             ptr += linesize;
 109         }
 110         break;
 111     case PIX_FMT_YUV420P:
 112         {
 113             unsigned char *ptr1, *ptr2;
 114
 115             n = avctx->width;
 116             ptr = p->data[0];
 117             linesize = p->linesize[0];
 118             if(s->bytestream + n*avctx->height*3/2 > s->bytestream_end)
 119                 return -1;
 120             for(i = 0; i < avctx->height; i++) {
 121                 memcpy(ptr, s->bytestream, n);
 122                 s->bytestream += n;
 123                 ptr += linesize;
 124             }
 125             ptr1 = p->data[1];
 126             ptr2 = p->data[2];
 127             n >>= 1;
 128             h = avctx->height >> 1;
 129             for(i = 0; i < h; i++) {
 130                 memcpy(ptr1, s->bytestream, n);
 131                 s->bytestream += n;
 132                 memcpy(ptr2, s->bytestream, n);
 133                 s->bytestream += n;
 134                 ptr1 += p->linesize[1];
 135                 ptr2 += p->linesize[2];
 136             }
 137         }
 138         break;
 139     case PIX_FMT_RGB32:
 140         ptr = p->data[0];
 141         linesize = p->linesize[0];
 142         if(s->bytestream + avctx->width*avctx->height*4 > s->bytestream_end)
 143             return -1;
 144         for(i = 0; i < avctx->height; i++) {
 145             int j, r, g, b, a;
 146
 147             for(j = 0;j < avctx->width; j++) {
 148                 r = *s->bytestream++;
 149                 g = *s->bytestream++;
 150                 b = *s->bytestream++;
 151                 a = *s->bytestream++;
 152                 ((uint32_t *)ptr)[j] = (a << 24) | (r << 16) | (g << 8) | b;
 153             }
 154             ptr += linesize;
 155         }
 156         break;
 157     }
 158     *picture= *(AVFrame*)&s->picture;
 159     *data_size = sizeof(AVPicture);
 160
 161     return s->bytestream - s->bytestream_start;
 162 }
 163
 164 static int pnm_encode_frame(AVCodecContext *avctx, unsigned char *outbuf, int buf_size, void *data){
 165     PNMContext *s = avctx->priv_data;
 166     AVFrame *pict = data;
 167     AVFrame * const p= (AVFrame*)&s->picture;
 168     int i, h, h1, c, n, linesize;
 169     uint8_t *ptr, *ptr1, *ptr2;
 170
 171     if(buf_size < avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height) + 200){
 172         av_log(avctx, AV_LOG_ERROR, "encoded frame too large\n");
 173         return -1;
 174     }
 175
 176     *p = *pict;
 177     p->pict_type= FF_I_TYPE;
 178     p->key_frame= 1;
 179
 180     s->bytestream_start=
 181     s->bytestream= outbuf;
 182     s->bytestream_end= outbuf+buf_size;
 183
 184     h = avctx->height;
 185     h1 = h;
 186     switch(avctx->pix_fmt) {
 187     case PIX_FMT_MONOWHITE:
 188         c = '4';
 189         n = (avctx->width + 7) >> 3;
 190         break;
 191     case PIX_FMT_GRAY8:
 192         c = '5';
 193         n = avctx->width;
 194         break;
 195     case PIX_FMT_GRAY16BE:
 196         c = '5';
 197         n = avctx->width * 2;
 198         break;
 199     case PIX_FMT_RGB24:
 200         c = '6';
 201         n = avctx->width * 3;
 202         break;
 203     case PIX_FMT_RGB48BE:
 204         c = '6';
 205         n = avctx->width * 6;
 206         break;
 207     case PIX_FMT_YUV420P:
 208         c = '5';
 209         n = avctx->width;
 210         h1 = (h * 3) / 2;
 211         break;
 212     default:
 213         return -1;
 214     }
 215     snprintf(s->bytestream, s->bytestream_end - s->bytestream,
 216              "P%c\n%d %d\n",
 217              c, avctx->width, h1);
 218     s->bytestream += strlen(s->bytestream);
 219     if (avctx->pix_fmt != PIX_FMT_MONOWHITE) {
 220         snprintf(s->bytestream, s->bytestream_end - s->bytestream,
 221                  "%d\n", (avctx->pix_fmt != PIX_FMT_GRAY16BE && avctx->pix_fmt != PIX_FMT_RGB48BE) ? 255 : 65535);
 222         s->bytestream += strlen(s->bytestream);
 223     }
 224
 225     ptr = p->data[0];
 226     linesize = p->linesize[0];
 227     for(i=0;i<h;i++) {
 228         memcpy(s->bytestream, ptr, n);
 229         s->bytestream += n;
 230         ptr += linesize;
 231     }
 232
 233     if (avctx->pix_fmt == PIX_FMT_YUV420P) {
 234         h >>= 1;
 235         n >>= 1;
 236         ptr1 = p->data[1];
 237         ptr2 = p->data[2];
 238         for(i=0;i<h;i++) {
 239             memcpy(s->bytestream, ptr1, n);
 240             s->bytestream += n;
 241             memcpy(s->bytestream, ptr2, n);
 242             s->bytestream += n;
 243                 ptr1 += p->linesize[1];
 244                 ptr2 += p->linesize[2];
 245         }
 246     }
 247     return s->bytestream - s->bytestream_start;
 248 }
 249
 250 static int pam_encode_frame(AVCodecContext *avctx, unsigned char *outbuf, int buf_size, void *data){
 251     PNMContext *s = avctx->priv_data;
 252     AVFrame *pict = data;
 253     AVFrame * const p= (AVFrame*)&s->picture;
 254     int i, h, w, n, linesize, depth, maxval;
 255     const char *tuple_type;
 256     uint8_t *ptr;
 257
 258     if(buf_size < avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height) + 200){
 259         av_log(avctx, AV_LOG_ERROR, "encoded frame too large\n");
 260         return -1;
 261     }
 262
 263     *p = *pict;
 264     p->pict_type= FF_I_TYPE;
 265     p->key_frame= 1;
 266
 267     s->bytestream_start=
 268     s->bytestream= outbuf;
 269     s->bytestream_end= outbuf+buf_size;
 270
 271     h = avctx->height;
 272     w = avctx->width;
 273     switch(avctx->pix_fmt) {
 274     case PIX_FMT_MONOWHITE:
 275         n = (w + 7) >> 3;
 276         depth = 1;
 277         maxval = 1;
 278         tuple_type = "BLACKANDWHITE";
 279         break;
 280     case PIX_FMT_GRAY8:
 281         n = w;
 282         depth = 1;
 283         maxval = 255;
 284         tuple_type = "GRAYSCALE";
 285         break;
 286     case PIX_FMT_RGB24:
 287         n = w * 3;
 288         depth = 3;
 289         maxval = 255;
 290         tuple_type = "RGB";
 291         break;
 292     case PIX_FMT_RGB32:
 293         n = w * 4;
 294         depth = 4;
 295         maxval = 255;
 296         tuple_type = "RGB_ALPHA";
 297         break;
 298     default:
 299         return -1;
 300     }
 301     snprintf(s->bytestream, s->bytestream_end - s->bytestream,
 302              "P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\nTUPLETYPE %s\nENDHDR\n",
 303              w, h, depth, maxval, tuple_type);
 304     s->bytestream += strlen(s->bytestream);
 305
 306     ptr = p->data[0];
 307     linesize = p->linesize[0];
 308
 309     if (avctx->pix_fmt == PIX_FMT_RGB32) {
 310         int j;
 311         unsigned int v;
 312
 313         for(i=0;i<h;i++) {
 314             for(j=0;j<w;j++) {
 315                 v = ((uint32_t *)ptr)[j];
 316                 bytestream_put_be24(&s->bytestream, v);
 317                 *s->bytestream++ = v >> 24;
 318             }
 319             ptr += linesize;
 320         }
 321     } else {
 322         for(i=0;i<h;i++) {
 323             memcpy(s->bytestream, ptr, n);
 324             s->bytestream += n;
 325             ptr += linesize;
 326         }
 327     }
 328     return s->bytestream - s->bytestream_start;
 329 }
 330
 331 #if 0
 332 static int pnm_probe(AVProbeData *pd)
 333 {
 334     const char *p = pd->buf;
 335     if (pd->buf_size >= 8 &&
 336         p[0] == 'P' &&
 337         p[1] >= '4' && p[1] <= '6' &&
 338         pnm_space(p[2]) )
 339         return AVPROBE_SCORE_MAX - 1; /* to permit pgmyuv probe */
 340     else
 341         return 0;
 342 }
 343
 344 static int pgmyuv_probe(AVProbeData *pd)
 345 {
 346     if (match_ext(pd->filename, "pgmyuv"))
 347         return AVPROBE_SCORE_MAX;
 348     else
 349         return 0;
 350 }
 351
 352 static int pam_probe(AVProbeData *pd)
 353 {
 354     const char *p = pd->buf;
 355     if (pd->buf_size >= 8 &&
 356         p[0] == 'P' &&
 357         p[1] == '7' &&
 358         p[2] == '\n')
 359         return AVPROBE_SCORE_MAX;
 360     else
 361         return 0;
 362 }
 363 #endif
 364
 365
 366 #if CONFIG_PGM_DECODER
 367 AVCodec pgm_decoder = {
 368     "pgm",
 369     CODEC_TYPE_VIDEO,
 370     CODEC_ID_PGM,
 371     sizeof(PNMContext),
 372     common_init,
 373     NULL,
 374     NULL,
 375     pnm_decode_frame,
 376     CODEC_CAP_DR1,
 377     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE},
 378     .long_name= NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
 379 };
 380 #endif
 381
 382 #if CONFIG_PGM_ENCODER
 383 AVCodec pgm_encoder = {
 384     "pgm",
 385     CODEC_TYPE_VIDEO,
 386     CODEC_ID_PGM,
 387     sizeof(PNMContext),
 388     common_init,
 389     pnm_encode_frame,
 390     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE},
 391     .long_name= NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
 392 };
 393 #endif // CONFIG_PGM_ENCODER
 394
 395 #if CONFIG_PGMYUV_DECODER
 396 AVCodec pgmyuv_decoder = {
 397     "pgmyuv",
 398     CODEC_TYPE_VIDEO,
 399     CODEC_ID_PGMYUV,
 400     sizeof(PNMContext),
 401     common_init,
 402     NULL,
 403     NULL,
 404     pnm_decode_frame,
 405     CODEC_CAP_DR1,
 406     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
 407     .long_name= NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
 408 };
 409 #endif
 410
 411 #if CONFIG_PGMYUV_ENCODER
 412 AVCodec pgmyuv_encoder = {
 413     "pgmyuv",
 414     CODEC_TYPE_VIDEO,
 415     CODEC_ID_PGMYUV,
 416     sizeof(PNMContext),
 417     common_init,
 418     pnm_encode_frame,
 419     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
 420     .long_name= NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
 421 };
 422 #endif // CONFIG_PGMYUV_ENCODER
 423
 424 #if CONFIG_PPM_DECODER
 425 AVCodec ppm_decoder = {
 426     "ppm",
 427     CODEC_TYPE_VIDEO,
 428     CODEC_ID_PPM,
 429     sizeof(PNMContext),
 430     common_init,
 431     NULL,
 432     NULL,
 433     pnm_decode_frame,
 434     CODEC_CAP_DR1,
 435     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE},
 436     .long_name= NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
 437 };
 438 #endif
 439
 440 #if CONFIG_PPM_ENCODER
 441 AVCodec ppm_encoder = {
 442     "ppm",
 443     CODEC_TYPE_VIDEO,
 444     CODEC_ID_PPM,
 445     sizeof(PNMContext),
 446     common_init,
 447     pnm_encode_frame,
 448     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE},
 449     .long_name= NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
 450 };
 451 #endif // CONFIG_PPM_ENCODER
 452
 453 #if CONFIG_PBM_DECODER
 454 AVCodec pbm_decoder = {
 455     "pbm",
 456     CODEC_TYPE_VIDEO,
 457     CODEC_ID_PBM,
 458     sizeof(PNMContext),
 459     common_init,
 460     NULL,
 461     NULL,
 462     pnm_decode_frame,
 463     CODEC_CAP_DR1,
 464     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_MONOWHITE, PIX_FMT_NONE},
 465     .long_name= NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
 466 };
 467 #endif
 468
 469 #if CONFIG_PBM_ENCODER
 470 AVCodec pbm_encoder = {
 471     "pbm",
 472     CODEC_TYPE_VIDEO,
 473     CODEC_ID_PBM,
 474     sizeof(PNMContext),
 475     common_init,
 476     pnm_encode_frame,
 477     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_MONOWHITE, PIX_FMT_NONE},
 478     .long_name= NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
 479 };
 480 #endif // CONFIG_PBM_ENCODER
 481
 482 #if CONFIG_PAM_DECODER
 483 AVCodec pam_decoder = {
 484     "pam",
 485     CODEC_TYPE_VIDEO,
 486     CODEC_ID_PAM,
 487     sizeof(PNMContext),
 488     common_init,
 489     NULL,
 490     NULL,
 491     pnm_decode_frame,
 492     CODEC_CAP_DR1,
 493     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOWHITE, PIX_FMT_NONE},
 494     .long_name= NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
 495 };
 496 #endif
 497
 498 #if CONFIG_PAM_ENCODER
 499 AVCodec pam_encoder = {
 500     "pam",
 501     CODEC_TYPE_VIDEO,
 502     CODEC_ID_PAM,
 503     sizeof(PNMContext),
 504     common_init,
 505     pam_encode_frame,
 506     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOWHITE, PIX_FMT_NONE},
 507     .long_name= NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
 508 };
 509 #endif // CONFIG_PAM_ENCODER