falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3369 Commits
32 Branches
935MB
Tree: 1fa3d65d57
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1fa3d65d57'
${ noResults }
FFmpeg/libavformat/pnm.c

477 lines
12KB
Raw Blame History 

  1. /*

  2.  * PNM image format

  3.  * Copyright (c) 2002, 2003 Fabrice Bellard.

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  13.  * Lesser General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU Lesser General Public

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  18.  */

  19. #include "avformat.h"

  20. 

  21. static inline int pnm_space(int c)  

  22. {

  23.     return (c == ' ' || c == '\n' || c == '\r' || c == '\t');

  24. }

  25. 

  26. static void pnm_get(ByteIOContext *f, char *str, int buf_size) 

  27. {

  28.     char *s;

  29.     int c;

  30.     

  31.     /* skip spaces and comments */

  32.     for(;;) {

  33.         c = url_fgetc(f);

  34.         if (c == '#')  {

  35.             do  {

  36.                 c = url_fgetc(f);

  37.             } while (c != '\n' && c != URL_EOF);

  38.         } else if (!pnm_space(c)) {

  39.             break;

  40.         }

  41.     }

  42.     

  43.     s = str;

  44.     while (c != URL_EOF && !pnm_space(c)) {

  45.         if ((s - str)  < buf_size - 1)

  46.             *s++ = c;

  47.         c = url_fgetc(f);

  48.     }

  49.     *s = '\0';

  50. }

  51. 

  52. static int pnm_read1(ByteIOContext *f, 

  53.                      int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque,

  54.                      int allow_yuv)

  55. {

  56.     int i, n, linesize, h;

  57.     char buf1[32];

  58.     unsigned char *ptr;

  59.     AVImageInfo info1, *info = &info1;

  60.     int ret;

  61. 

  62.     pnm_get(f, buf1, sizeof(buf1));

  63.     if (!strcmp(buf1, "P4")) {

  64.         info->pix_fmt = PIX_FMT_MONOWHITE;

  65.     } else if (!strcmp(buf1, "P5")) {

  66.         if (allow_yuv) 

  67.             info->pix_fmt = PIX_FMT_YUV420P;

  68.         else

  69.             info->pix_fmt = PIX_FMT_GRAY8;

  70.     } else if (!strcmp(buf1, "P6")) {

  71.         info->pix_fmt = PIX_FMT_RGB24;

  72.     } else {

  73.         return AVERROR_INVALIDDATA;

  74.     }

  75.     pnm_get(f, buf1, sizeof(buf1));

  76.     info->width = atoi(buf1);

  77.     if (info->width <= 0)

  78.         return AVERROR_INVALIDDATA;

  79.     pnm_get(f, buf1, sizeof(buf1));

  80.     info->height = atoi(buf1);

  81.     if (info->height <= 0)

  82.         return AVERROR_INVALIDDATA;

  83.     if (info->pix_fmt != PIX_FMT_MONOWHITE) {

  84.         pnm_get(f, buf1, sizeof(buf1));

  85.     }

  86. 

  87.     /* more check if YUV420 */

  88.     if (info->pix_fmt == PIX_FMT_YUV420P) {

  89.         if ((info->width & 1) != 0)

  90.             return AVERROR_INVALIDDATA;

  91.         h = (info->height * 2);

  92.         if ((h % 3) != 0)

  93.             return AVERROR_INVALIDDATA;

  94.         h /= 3;

  95.         info->height = h;

  96.     }

  97.     

  98.     ret = alloc_cb(opaque, info);

  99.     if (ret)

  100.         return ret;

  101.     

  102.     switch(info->pix_fmt) {

  103.     default:

  104.         return AVERROR_INVALIDDATA;

  105.     case PIX_FMT_RGB24:

  106.         n = info->width * 3;

  107.         goto do_read;

  108.     case PIX_FMT_GRAY8:

  109.         n = info->width;

  110.         goto do_read;

  111.     case PIX_FMT_MONOWHITE:

  112.         n = (info->width + 7) >> 3;

  113.     do_read:

  114.         ptr = info->pict.data[0];

  115.         linesize = info->pict.linesize[0];

  116.         for(i = 0; i < info->height; i++) {

  117.             get_buffer(f, ptr, n);

  118.             ptr += linesize;

  119.         }

  120.         break;

  121.     case PIX_FMT_YUV420P:

  122.         {

  123.             unsigned char *ptr1, *ptr2;

  124. 

  125.             n = info->width;

  126.             ptr = info->pict.data[0];

  127.             linesize = info->pict.linesize[0];

  128.             for(i = 0; i < info->height; i++) {

  129.                 get_buffer(f, ptr, n);

  130.                 ptr += linesize;

  131.             }

  132.             ptr1 = info->pict.data[1];

  133.             ptr2 = info->pict.data[2];

  134.             n >>= 1;

  135.             h = info->height >> 1;

  136.             for(i = 0; i < h; i++) {

  137.                 get_buffer(f, ptr1, n);

  138.                 get_buffer(f, ptr2, n);

  139.                 ptr1 += info->pict.linesize[1];

  140.                 ptr2 += info->pict.linesize[2];

  141.             }

  142.         }

  143.         break;

  144.     }

  145.     return 0;

  146. }

  147. 

  148. static int pnm_read(ByteIOContext *f, 

  149.                     int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque)

  150. {

  151.     return pnm_read1(f, alloc_cb, opaque, 0);

  152. }

  153. 

  154. static int pgmyuv_read(ByteIOContext *f, 

  155.                        int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque)

  156. {

  157.     return pnm_read1(f, alloc_cb, opaque, 1);

  158. }

  159. 

  160. static int pnm_write(ByteIOContext *pb, AVImageInfo *info)

  161. {

  162.     int i, h, h1, c, n, linesize;

  163.     char buf[100];

  164.     uint8_t *ptr, *ptr1, *ptr2;

  165. 

  166.     h = info->height;

  167.     h1 = h;

  168.     switch(info->pix_fmt) {

  169.     case PIX_FMT_MONOWHITE:

  170.         c = '4';

  171.         n = (info->width + 7) >> 3;

  172.         break;

  173.     case PIX_FMT_GRAY8:

  174.         c = '5';

  175.         n = info->width;

  176.         break;

  177.     case PIX_FMT_RGB24:

  178.         c = '6';

  179.         n = info->width * 3;

  180.         break;

  181.     case PIX_FMT_YUV420P:

  182.         c = '5';

  183.         n = info->width;

  184.         h1 = (h * 3) / 2;

  185.         break;

  186.     default:

  187.         return AVERROR_INVALIDDATA;

  188.     }

  189.     snprintf(buf, sizeof(buf), 

  190.              "P%c\n%d %d\n",

  191.              c, info->width, h1);

  192.     put_buffer(pb, buf, strlen(buf));

  193.     if (info->pix_fmt != PIX_FMT_MONOWHITE) {

  194.         snprintf(buf, sizeof(buf), 

  195.                  "%d\n", 255);

  196.         put_buffer(pb, buf, strlen(buf));

  197.     }

  198.     

  199.     ptr = info->pict.data[0];

  200.     linesize = info->pict.linesize[0];

  201.     for(i=0;i<h;i++) {

  202.         put_buffer(pb, ptr, n);

  203.         ptr += linesize;

  204.     }

  205.     

  206.     if (info->pix_fmt == PIX_FMT_YUV420P) {

  207.         h >>= 1;

  208.         n >>= 1;

  209.         ptr1 = info->pict.data[1];

  210.         ptr2 = info->pict.data[2];

  211.         for(i=0;i<h;i++) {

  212.             put_buffer(pb, ptr1, n);

  213.             put_buffer(pb, ptr2, n);

  214.                 ptr1 += info->pict.linesize[1];

  215.                 ptr2 += info->pict.linesize[2];

  216.         }

  217.     }

  218.     put_flush_packet(pb);

  219.     return 0;

  220. }

  221. 

  222. static int pam_read(ByteIOContext *f, 

  223.                     int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque)

  224. {

  225.     int i, n, linesize, h, w, depth, maxval;

  226.     char buf1[32], tuple_type[32];

  227.     unsigned char *ptr;

  228.     AVImageInfo info1, *info = &info1;

  229.     int ret;

  230. 

  231.     pnm_get(f, buf1, sizeof(buf1));

  232.     if (strcmp(buf1, "P7") != 0)

  233.         return AVERROR_INVALIDDATA;

  234.     w = -1;

  235.     h = -1;

  236.     maxval = -1;

  237.     depth = -1;

  238.     tuple_type[0] = '\0';

  239.     for(;;) {

  240.         pnm_get(f, buf1, sizeof(buf1));

  241.         if (!strcmp(buf1, "WIDTH")) {

  242.             pnm_get(f, buf1, sizeof(buf1));

  243.             w = strtol(buf1, NULL, 10);

  244.         } else if (!strcmp(buf1, "HEIGHT")) {

  245.             pnm_get(f, buf1, sizeof(buf1));

  246.             h = strtol(buf1, NULL, 10);

  247.         } else if (!strcmp(buf1, "DEPTH")) {

  248.             pnm_get(f, buf1, sizeof(buf1));

  249.             depth = strtol(buf1, NULL, 10);

  250.         } else if (!strcmp(buf1, "MAXVAL")) {

  251.             pnm_get(f, buf1, sizeof(buf1));

  252.             maxval = strtol(buf1, NULL, 10);

  253.         } else if (!strcmp(buf1, "TUPLETYPE")) {

  254.             pnm_get(f, buf1, sizeof(buf1));

  255.             pstrcpy(tuple_type, sizeof(tuple_type), buf1);

  256.         } else if (!strcmp(buf1, "ENDHDR")) {

  257.             break;

  258.         } else {

  259.             return AVERROR_INVALIDDATA;

  260.         }

  261.     }

  262.     /* check that all tags are present */

  263.     if (w <= 0 || h <= 0 || maxval <= 0 || depth <= 0 || tuple_type[0] == '\0')

  264.         return AVERROR_INVALIDDATA;

  265.     info->width = w;

  266.     info->height = h;

  267.     if (depth == 1) {

  268.         if (maxval == 1)

  269.             info->pix_fmt = PIX_FMT_MONOWHITE;

  270.         else 

  271.             info->pix_fmt = PIX_FMT_GRAY8;

  272.     } else if (depth == 3) {

  273.         info->pix_fmt = PIX_FMT_RGB24;

  274.     } else if (depth == 4) {

  275.         info->pix_fmt = PIX_FMT_RGBA32;

  276.     } else {

  277.         return AVERROR_INVALIDDATA;

  278.     }

  279.     ret = alloc_cb(opaque, info);

  280.     if (ret)

  281.         return ret;

  282.     

  283.     switch(info->pix_fmt) {

  284.     default:

  285.         return AVERROR_INVALIDDATA;

  286.     case PIX_FMT_RGB24:

  287.         n = info->width * 3;

  288.         goto do_read;

  289.     case PIX_FMT_GRAY8:

  290.         n = info->width;

  291.         goto do_read;

  292.     case PIX_FMT_MONOWHITE:

  293.         n = (info->width + 7) >> 3;

  294.     do_read:

  295.         ptr = info->pict.data[0];

  296.         linesize = info->pict.linesize[0];

  297.         for(i = 0; i < info->height; i++) {

  298.             get_buffer(f, ptr, n);

  299.             ptr += linesize;

  300.         }

  301.         break;

  302.     case PIX_FMT_RGBA32:

  303.         ptr = info->pict.data[0];

  304.         linesize = info->pict.linesize[0];

  305.         for(i = 0; i < info->height; i++) {

  306.             int j, r, g, b, a;

  307. 

  308.             for(j = 0;j < w; j++) {

  309.                 r = get_byte(f);

  310.                 g = get_byte(f);

  311.                 b = get_byte(f);

  312.                 a = get_byte(f);

  313.                 ((uint32_t *)ptr)[j] = (a << 24) | (r << 16) | (g << 8) | b;

  314.             }

  315.             ptr += linesize;

  316.         }

  317.         break;

  318.     }

  319.     return 0;

  320. }

  321. 

  322. static int pam_write(ByteIOContext *pb, AVImageInfo *info)

  323. {

  324.     int i, h, w, n, linesize, depth, maxval;

  325.     const char *tuple_type;

  326.     char buf[100];

  327.     uint8_t *ptr;

  328. 

  329.     h = info->height;

  330.     w = info->width;

  331.     switch(info->pix_fmt) {

  332.     case PIX_FMT_MONOWHITE:

  333.         n = (info->width + 7) >> 3;

  334.         depth = 1;

  335.         maxval = 1;

  336.         tuple_type = "BLACKANDWHITE";

  337.         break;

  338.     case PIX_FMT_GRAY8:

  339.         n = info->width;

  340.         depth = 1;

  341.         maxval = 255;

  342.         tuple_type = "GRAYSCALE";

  343.         break;

  344.     case PIX_FMT_RGB24:

  345.         n = info->width * 3;

  346.         depth = 3;

  347.         maxval = 255;

  348.         tuple_type = "RGB";

  349.         break;

  350.     case PIX_FMT_RGBA32:

  351.         n = info->width * 4;

  352.         depth = 4;

  353.         maxval = 255;

  354.         tuple_type = "RGB_ALPHA";

  355.         break;

  356.     default:

  357.         return AVERROR_INVALIDDATA;

  358.     }

  359.     snprintf(buf, sizeof(buf), 

  360.              "P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\nTUPLETYPE %s\nENDHDR\n",

  361.              w, h, depth, maxval, tuple_type);

  362.     put_buffer(pb, buf, strlen(buf));

  363.     

  364.     ptr = info->pict.data[0];

  365.     linesize = info->pict.linesize[0];

  366.     

  367.     if (info->pix_fmt == PIX_FMT_RGBA32) {

  368.         int j;

  369.         unsigned int v;

  370. 

  371.         for(i=0;i<h;i++) {

  372.             for(j=0;j<w;j++) {

  373.                 v = ((uint32_t *)ptr)[j];

  374.                 put_byte(pb, (v >> 16) & 0xff);

  375.                 put_byte(pb, (v >> 8) & 0xff);

  376.                 put_byte(pb, (v) & 0xff);

  377.                 put_byte(pb, (v >> 24) & 0xff);

  378.             }

  379.             ptr += linesize;

  380.         }

  381.     } else {

  382.         for(i=0;i<h;i++) {

  383.             put_buffer(pb, ptr, n);

  384.             ptr += linesize;

  385.         }

  386.     }

  387.     put_flush_packet(pb);

  388.     return 0;

  389. }

  390. 

  391. static int pnm_probe(AVProbeData *pd)

  392. {

  393.     const char *p = pd->buf;

  394.     if (pd->buf_size >= 8 &&

  395.         p[0] == 'P' &&

  396.         p[1] >= '4' && p[1] <= '6' &&

  397.         pnm_space(p[2]) )

  398.         return AVPROBE_SCORE_MAX - 1; /* to permit pgmyuv probe */

  399.     else

  400.         return 0;

  401. }

  402. 

  403. static int pgmyuv_probe(AVProbeData *pd)

  404. {

  405.     if (match_ext(pd->filename, "pgmyuv"))

  406.         return AVPROBE_SCORE_MAX;

  407.     else

  408.         return 0;

  409. }

  410. 

  411. static int pam_probe(AVProbeData *pd)

  412. {

  413.     const char *p = pd->buf;

  414.     if (pd->buf_size >= 8 &&

  415.         p[0] == 'P' &&

  416.         p[1] == '7' &&

  417.         p[2] == '\n')

  418.         return AVPROBE_SCORE_MAX;

  419.     else

  420.         return 0;

  421. }

  422. 

  423. AVImageFormat pnm_image_format = {

  424.     "pnm",

  425.     NULL,

  426.     pnm_probe,

  427.     pnm_read,

  428.     0,

  429.     NULL,

  430. };

  431. 

  432. AVImageFormat pbm_image_format = {

  433.     "pbm",

  434.     "pbm",

  435.     NULL,

  436.     NULL,

  437.     (1 << PIX_FMT_MONOWHITE),

  438.     pnm_write,

  439. };

  440. 

  441. AVImageFormat pgm_image_format = {

  442.     "pgm",

  443.     "pgm",

  444.     NULL,

  445.     NULL,

  446.     (1 << PIX_FMT_GRAY8),

  447.     pnm_write,

  448. };

  449. 

  450. AVImageFormat ppm_image_format = {

  451.     "ppm",

  452.     "ppm",

  453.     NULL,

  454.     NULL,

  455.     (1 << PIX_FMT_RGB24),

  456.     pnm_write,

  457. };

  458. 

  459. AVImageFormat pam_image_format = {

  460.     "pam",

  461.     "pam",

  462.     pam_probe,

  463.     pam_read,

  464.     (1 << PIX_FMT_MONOWHITE) | (1 << PIX_FMT_GRAY8) | (1 << PIX_FMT_RGB24) | 

  465.     (1 << PIX_FMT_RGBA32),

  466.     pam_write,

  467. };

  468. 

  469. AVImageFormat pgmyuv_image_format = {

  470.     "pgmyuv",

  471.     "pgmyuv",

  472.     pgmyuv_probe,

  473.     pgmyuv_read,

  474.     (1 << PIX_FMT_YUV420P),

  475.     pnm_write,

  476. };