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.
735 Commits
32 Branches
935MB
Tree: 789bee1264
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '789bee1264'
${ noResults }
FFmpeg/libav/img.c

803 lines
18KB
Raw Blame History 

  1. /*

  2.  * Image format

  3.  * Copyright (c) 2000, 2001, 2002 Gerard Lantau.

  4.  *

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

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * (at your option) any later version.

  9.  *

  10.  * This program 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

  13.  * GNU General Public License for more details.

  14.  *

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

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

  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18.  */

  19. #include "avformat.h"

  20. 

  21. extern AVInputFormat pgm_iformat;

  22. extern AVOutputFormat pgm_oformat;

  23. extern AVInputFormat pgmyuv_iformat;

  24. extern AVOutputFormat pgmyuv_oformat;

  25. extern AVInputFormat ppm_iformat;

  26. extern AVOutputFormat ppm_oformat;

  27. extern AVInputFormat imgyuv_iformat;

  28. extern AVOutputFormat imgyuv_oformat;

  29. extern AVInputFormat pgmpipe_iformat;

  30. extern AVOutputFormat pgmpipe_oformat;

  31. extern AVInputFormat pgmyuvpipe_iformat;

  32. extern AVOutputFormat pgmyuvpipe_oformat;

  33. extern AVInputFormat ppmpipe_iformat;

  34. extern AVOutputFormat ppmpipe_oformat;

  35. 

  36. #define IMGFMT_YUV     1

  37. #define IMGFMT_PGMYUV  2

  38. #define IMGFMT_PGM     3

  39. #define IMGFMT_PPM     4

  40. 

  41. typedef struct {

  42.     int width;

  43.     int height;

  44.     int img_number;

  45.     int img_size;

  46.     int img_fmt;

  47.     int is_pipe;

  48.     char path[1024];

  49. } VideoData;

  50. 

  51. static inline int pnm_space(int c)  

  52. {

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

  54. }

  55. 

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

  57. {

  58.     char *s;

  59.     int c;

  60.     

  61.     do  {

  62.         c=get_byte(f);

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

  64.             do  {

  65.                 c=get_byte(f);

  66.             } while (c!='\n');

  67.             c=get_byte(f);

  68.         }

  69.     } while (pnm_space(c));

  70.     

  71.     s=str;

  72.     do  {

  73.         if (url_feof(f))

  74.             break;

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

  76.             *s++=c;

  77.         c=get_byte(f);

  78.     } while (!pnm_space(c));

  79.     *s = '\0';

  80. }

  81. 

  82. static int pgm_read(VideoData *s, ByteIOContext *f, UINT8 *buf, int size, int is_yuv)

  83. {

  84.     int width, height, i;

  85.     char buf1[32];

  86.     UINT8 *picture[3];

  87. 

  88.     width = s->width;

  89.     height = s->height;

  90. 

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

  92.     if (strcmp(buf1, "P5")) {

  93.         return -EIO;

  94.     }

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

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

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

  98.     

  99.     picture[0] = buf;

  100.     picture[1] = buf + width * height;

  101.     picture[2] = buf + width * height + (width * height / 4);

  102.     get_buffer(f, picture[0], width * height);

  103.     

  104.     height>>=1;

  105.     width>>=1;

  106.     if (is_yuv) {

  107.         for(i=0;i<height;i++) {

  108.             get_buffer(f, picture[1] + i * width, width);

  109.             get_buffer(f, picture[2] + i * width, width);

  110.         }

  111.     } else {

  112.         for(i=0;i<height;i++) {

  113.             memset(picture[1] + i * width, 128, width);

  114.             memset(picture[2] + i * width, 128, width);

  115.         }

  116.     }

  117.     return 0;

  118. }

  119. 

  120. static int ppm_read(VideoData *s, ByteIOContext *f, UINT8 *buf, int size)

  121. {

  122.     int width, height;

  123.     char buf1[32];

  124.     UINT8 *picture[3];

  125. 

  126.     width = s->width;

  127.     height = s->height;

  128. 

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

  130.     if (strcmp(buf1, "P6")) {

  131.         return -EIO;

  132.     }

  133.     

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

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

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

  137.     

  138.     picture[0] = buf;

  139.     get_buffer(f, picture[0], width * height*3);

  140.     

  141.     return 0;

  142. 

  143. }

  144. 

  145. static int yuv_read(VideoData *s, const char *filename, UINT8 *buf, int size1)

  146. {

  147.     ByteIOContext pb1, *pb = &pb1;

  148.     char fname[1024], *p;

  149.     int size;

  150. 

  151.     size = s->width * s->height;

  152.     

  153.     strcpy(fname, filename);

  154.     p = strrchr(fname, '.');

  155.     if (!p || p[1] != 'Y')

  156.         return -EIO;

  157. 

  158.     if (url_fopen(pb, fname, URL_RDONLY) < 0)

  159.         return -EIO;

  160.     

  161.     get_buffer(pb, buf, size);

  162.     url_fclose(pb);

  163.     

  164.     p[1] = 'U';

  165.     if (url_fopen(pb, fname, URL_RDONLY) < 0)

  166.         return -EIO;

  167. 

  168.     get_buffer(pb, buf + size, size / 4);

  169.     url_fclose(pb);

  170.     

  171.     p[1] = 'V';

  172.     if (url_fopen(pb, fname, URL_RDONLY) < 0)

  173.         return -EIO;

  174. 

  175.     get_buffer(pb, buf + size + (size / 4), size / 4);

  176.     url_fclose(pb);

  177.     return 0;

  178. }

  179. 

  180. static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)

  181. {

  182.     VideoData *s = s1->priv_data;

  183.     char filename[1024];

  184.     int ret;

  185.     ByteIOContext f1, *f;

  186. 

  187. /*

  188.     This if-statement destroys pipes - I do not see why it is necessary

  189.     if (get_frame_filename(filename, sizeof(filename),

  190.                            s->path, s->img_number) < 0)

  191.         return -EIO;

  192. */

  193.     get_frame_filename(filename, sizeof(filename),

  194.                        s->path, s->img_number);

  195.     if (!s->is_pipe) {

  196.         f = &f1;

  197.         if (url_fopen(f, filename, URL_RDONLY) < 0)

  198.             return -EIO;

  199.     } else {

  200.         f = &s1->pb;

  201.         if (url_feof(f))

  202.             return -EIO;

  203.     }

  204. 

  205.     av_new_packet(pkt, s->img_size);

  206.     pkt->stream_index = 0;

  207. 

  208.     switch(s->img_fmt) {

  209.     case IMGFMT_PGMYUV:

  210.         ret = pgm_read(s, f, pkt->data, pkt->size, 1);

  211.         break;

  212.     case IMGFMT_PGM:

  213.         ret = pgm_read(s, f, pkt->data, pkt->size, 0);

  214.         break;

  215.     case IMGFMT_YUV:

  216.         ret = yuv_read(s, filename, pkt->data, pkt->size);

  217.         break;

  218.     case IMGFMT_PPM:

  219.         ret = ppm_read(s, f, pkt->data, pkt->size);

  220.         break;

  221.     default:

  222.         return -EIO;

  223.     }

  224.     

  225.     if (!s->is_pipe) {

  226.         url_fclose(f);

  227.     }

  228. 

  229.     if (ret < 0) {

  230.         av_free_packet(pkt);

  231.         return -EIO; /* signal EOF */

  232.     } else {

  233.         s->img_number++;

  234.         return 0;

  235.     }

  236. }

  237. 

  238. static int sizes[][2] = {

  239.     { 640, 480 },

  240.     { 720, 480 },

  241.     { 720, 576 },

  242.     { 352, 288 },

  243.     { 352, 240 },

  244.     { 160, 128 },

  245.     { 512, 384 },

  246.     { 640, 352 },

  247.     { 640, 240 },

  248. };

  249. 

  250. static int infer_size(int *width_ptr, int *height_ptr, int size)

  251. {

  252.     int i;

  253. 

  254.     for(i=0;i<sizeof(sizes)/sizeof(sizes[0]);i++) {

  255.         if ((sizes[i][0] * sizes[i][1]) == size) {

  256.             *width_ptr = sizes[i][0];

  257.             *height_ptr = sizes[i][1];

  258.             return 0;

  259.         }

  260.     }

  261.     return -1;

  262. }

  263. 

  264. static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)

  265. {

  266.     VideoData *s = s1->priv_data;

  267.     int i, h;

  268.     char buf[1024];

  269.     char buf1[32];

  270.     ByteIOContext pb1, *f = &pb1;

  271.     AVStream *st;

  272. 

  273.     st = av_new_stream(s1, 0);

  274.     if (!st) {

  275.         av_free(s);

  276.         return -ENOMEM;

  277.     }

  278. 

  279.     strcpy(s->path, s1->filename);

  280.     s->img_number = 0;

  281. 

  282.     /* find format */

  283.     if (s1->iformat->flags & AVFMT_NOFILE)

  284.         s->is_pipe = 0;

  285.     else

  286.         s->is_pipe = 1;

  287.         

  288.     if (s1->iformat == &pgmyuvpipe_iformat ||

  289.         s1->iformat == &pgmyuv_iformat)

  290.         s->img_fmt = IMGFMT_PGMYUV;

  291.     else if (s1->iformat == &pgmpipe_iformat ||

  292.              s1->iformat == &pgm_iformat)

  293.         s->img_fmt = IMGFMT_PGM;

  294.     else if (s1->iformat == &imgyuv_iformat)

  295.         s->img_fmt = IMGFMT_YUV;

  296.     else if (s1->iformat == &ppmpipe_iformat ||

  297.              s1->iformat == &ppm_iformat)

  298.         s->img_fmt = IMGFMT_PPM;

  299.     else

  300.         goto fail;

  301. 

  302.     if (!s->is_pipe) {

  303.         /* try to find the first image */

  304.         for(i=0;i<5;i++) {

  305.             if (get_frame_filename(buf, sizeof(buf), s->path, s->img_number) < 0)

  306.                 goto fail;

  307.             if (url_fopen(f, buf, URL_RDONLY) >= 0)

  308.                 break;

  309.             s->img_number++;

  310.         }

  311.         if (i == 5)

  312.             goto fail;

  313.     } else {

  314.         f = &s1->pb;

  315.     }

  316.     

  317.     /* find the image size */

  318.     /* XXX: use generic file format guessing, as mpeg */

  319.     switch(s->img_fmt) {

  320.     case IMGFMT_PGM:

  321.     case IMGFMT_PGMYUV:

  322.     case IMGFMT_PPM:

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

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

  325.         s->width = atoi(buf1);

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

  327.         h = atoi(buf1);

  328.         if (s->img_fmt == IMGFMT_PGMYUV)

  329.             h = (h * 2) / 3;

  330.         s->height = h;

  331.         if (s->width <= 0 ||

  332.             s->height <= 0 ||

  333.             (s->width % 2) != 0 ||

  334.             (s->height % 2) != 0) {

  335.             goto fail1;

  336.         }

  337.         break;

  338.     case IMGFMT_YUV:

  339.         /* infer size by using the file size. */

  340.         {

  341.             int img_size;

  342.             URLContext *h;

  343. 

  344.             /* XXX: hack hack */

  345.             h = url_fileno(f);

  346.             img_size = url_seek(h, 0, SEEK_END);

  347.             if (infer_size(&s->width, &s->height, img_size) < 0) {

  348.                 goto fail1;

  349.             }

  350.         }

  351.         break;

  352.     }

  353. 

  354.     if (!s->is_pipe) {

  355.         url_fclose(f);

  356.     } else {

  357.         url_fseek(f, 0, SEEK_SET);

  358.     }

  359.     

  360. 

  361.     st->codec.codec_type = CODEC_TYPE_VIDEO;

  362.     st->codec.codec_id = CODEC_ID_RAWVIDEO;

  363.     st->codec.width = s->width;

  364.     st->codec.height = s->height;

  365.     if (s->img_fmt == IMGFMT_PPM) {

  366.         st->codec.pix_fmt = PIX_FMT_RGB24;

  367.         s->img_size = (s->width * s->height * 3);

  368.     } else {

  369.         st->codec.pix_fmt = PIX_FMT_YUV420P;

  370.         s->img_size = (s->width * s->height * 3) / 2;

  371.     }

  372.     if (!ap || !ap->frame_rate)

  373.         st->codec.frame_rate = 25 * FRAME_RATE_BASE;

  374.     else

  375.         st->codec.frame_rate = ap->frame_rate;

  376.     

  377.     return 0;

  378.  fail1:

  379.     if (!s->is_pipe)

  380.         url_fclose(f);

  381.  fail:

  382.     av_free(s);

  383.     return -EIO;

  384. }

  385. 

  386. static int img_read_close(AVFormatContext *s1)

  387. {

  388.     return 0;

  389. }

  390. 

  391. /******************************************************/

  392. /* image output */

  393. 

  394. static int pgm_save(AVPicture *picture, int width, int height, ByteIOContext *pb, int is_yuv) 

  395. {

  396.     int i, h;

  397.     char buf[100];

  398.     UINT8 *ptr, *ptr1, *ptr2;

  399. 

  400.     h = height;

  401.     if (is_yuv)

  402.         h = (height * 3) / 2;

  403.     snprintf(buf, sizeof(buf), 

  404.              "P5\n%d %d\n%d\n",

  405.              width, h, 255);

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

  407.     

  408.     ptr = picture->data[0];

  409.     for(i=0;i<height;i++) {

  410.         put_buffer(pb, ptr, width);

  411.         ptr += picture->linesize[0];

  412.     }

  413. 

  414.     if (is_yuv) {

  415.         height >>= 1;

  416.         width >>= 1;

  417.         ptr1 = picture->data[1];

  418.         ptr2 = picture->data[2];

  419.         for(i=0;i<height;i++) {

  420.             put_buffer(pb, ptr1, width);

  421.             put_buffer(pb, ptr2, width);

  422.             ptr1 += picture->linesize[1];

  423.             ptr2 += picture->linesize[2];

  424.         }

  425.     }

  426.     put_flush_packet(pb);

  427.     return 0;

  428. }

  429. 

  430. static int ppm_save(AVPicture *picture, int width, int height, ByteIOContext *pb) 

  431. {

  432.     int i;

  433.     char buf[100];

  434.     UINT8 *ptr;

  435. 

  436.     snprintf(buf, sizeof(buf), 

  437.              "P6\n%d %d\n%d\n",

  438.              width, height, 255);

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

  440.     

  441.     ptr = picture->data[0];

  442.     for(i=0;i<height;i++) {

  443.         put_buffer(pb, ptr, width * 3);

  444.         ptr += picture->linesize[0];

  445.     }

  446. 

  447.     put_flush_packet(pb);

  448.     return 0;

  449. }

  450. 

  451. static int yuv_save(AVPicture *picture, int width, int height, const char *filename)

  452. {

  453.     ByteIOContext pb1, *pb = &pb1;

  454.     char fname[1024], *p;

  455.     int i, j;

  456.     UINT8 *ptr;

  457.     static char *ext = "YUV";

  458. 

  459.     strcpy(fname, filename);

  460.     p = strrchr(fname, '.');

  461.     if (!p || p[1] != 'Y')

  462.         return -EIO;

  463. 

  464.     for(i=0;i<3;i++) {

  465.         if (i == 1) {

  466.             width >>= 1;

  467.             height >>= 1;

  468.         }

  469. 

  470.         p[1] = ext[i];

  471.         if (url_fopen(pb, fname, URL_WRONLY) < 0)

  472.             return -EIO;

  473.     

  474.         ptr = picture->data[i];

  475.         for(j=0;j<height;j++) {

  476.             put_buffer(pb, ptr, width);

  477.             ptr += picture->linesize[i];

  478.         }

  479.         put_flush_packet(pb);

  480.         url_fclose(pb);

  481.     }

  482.     return 0;

  483. }

  484. 

  485. static int img_write_header(AVFormatContext *s)

  486. {

  487.     VideoData *img = s->priv_data;

  488. 

  489.     img->img_number = 1;

  490.     strcpy(img->path, s->filename);

  491. 

  492.     /* find format */

  493.     if (s->oformat->flags & AVFMT_NOFILE)

  494.         img->is_pipe = 0;

  495.     else

  496.         img->is_pipe = 1;

  497.         

  498.     if (s->oformat == &pgmyuvpipe_oformat ||

  499.         s->oformat == &pgmyuv_oformat) {

  500.         img->img_fmt = IMGFMT_PGMYUV;

  501.     } else if (s->oformat == &pgmpipe_oformat ||

  502.                s->oformat == &pgm_oformat) {

  503.         img->img_fmt = IMGFMT_PGM;

  504.     } else if (s->oformat == &imgyuv_oformat) {

  505.         img->img_fmt = IMGFMT_YUV;

  506.     } else if (s->oformat == &ppmpipe_oformat ||

  507.                s->oformat == &ppm_oformat) {

  508.         img->img_fmt = IMGFMT_PPM;

  509.     } else {

  510.         goto fail;

  511.     }

  512.     return 0;

  513.  fail:

  514.     av_free(img);

  515.     return -EIO;

  516. }

  517. 

  518. static int img_write_packet(AVFormatContext *s, int stream_index,

  519.                             UINT8 *buf, int size, int force_pts)

  520. {

  521.     VideoData *img = s->priv_data;

  522.     AVStream *st = s->streams[stream_index];

  523.     ByteIOContext pb1, *pb;

  524.     AVPicture picture;

  525.     int width, height, ret, size1;

  526.     char filename[1024];

  527. 

  528.     width = st->codec.width;

  529.     height = st->codec.height;

  530. 

  531.     switch(st->codec.pix_fmt) {

  532.     case PIX_FMT_YUV420P:

  533.         size1 = (width * height * 3) / 2;

  534.         if (size != size1)

  535.             return -EIO;

  536.         

  537.         picture.data[0] = buf;

  538.         picture.data[1] = picture.data[0] + width * height;

  539.         picture.data[2] = picture.data[1] + (width * height) / 4;

  540.         picture.linesize[0] = width;

  541.         picture.linesize[1] = width >> 1; 

  542.         picture.linesize[2] = width >> 1;

  543.         break;

  544.     case PIX_FMT_RGB24:

  545.         size1 = (width * height * 3);

  546.         if (size != size1)

  547.             return -EIO;

  548.         picture.data[0] = buf;

  549.         picture.linesize[0] = width * 3;

  550.         break;

  551.     default:

  552.         return -EIO;

  553.     }

  554.     

  555. /*

  556.     This if-statement destroys pipes - I do not see why it is necessary

  557.     if (get_frame_filename(filename, sizeof(filename), 

  558.                            img->path, img->img_number) < 0)

  559.         return -EIO;

  560. */

  561.     get_frame_filename(filename, sizeof(filename), 

  562.                        img->path, img->img_number);

  563.     if (!img->is_pipe) {

  564.         pb = &pb1;

  565.         if (url_fopen(pb, filename, URL_WRONLY) < 0)

  566.             return -EIO;

  567.     } else {

  568.         pb = &s->pb;

  569.     }

  570.     switch(img->img_fmt) {

  571.     case IMGFMT_PGMYUV:

  572.         ret = pgm_save(&picture, width, height, pb, 1);

  573.         break;

  574.     case IMGFMT_PGM:

  575.         ret = pgm_save(&picture, width, height, pb, 0);

  576.         break;

  577.     case IMGFMT_YUV:

  578.         ret = yuv_save(&picture, width, height, filename);

  579.         break;

  580.     case IMGFMT_PPM:

  581.         ret = ppm_save(&picture, width, height, pb);

  582.         break;

  583.     }

  584.     if (!img->is_pipe) {

  585.         url_fclose(pb);

  586.     }

  587. 

  588.     img->img_number++;

  589.     return 0;

  590. }

  591. 

  592. static int img_write_trailer(AVFormatContext *s)

  593. {

  594.     return 0;

  595. }

  596. 

  597. AVInputFormat pgm_iformat = {

  598.     "pgm",

  599.     "pgm image format",

  600.     sizeof(VideoData),

  601.     NULL,

  602.     img_read_header,

  603.     img_read_packet,

  604.     img_read_close,

  605.     NULL,

  606.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  607.     extensions: "pgm",

  608. };

  609. 

  610. AVOutputFormat pgm_oformat = {

  611.     "pgm",

  612.     "pgm image format",

  613.     "",

  614.     "pgm",

  615.     sizeof(VideoData),

  616.     CODEC_ID_NONE,

  617.     CODEC_ID_RAWVIDEO,

  618.     img_write_header,

  619.     img_write_packet,

  620.     img_write_trailer,

  621.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  622. };

  623. 

  624. AVInputFormat pgmyuv_iformat = {

  625.     "pgmyuv",

  626.     "pgm with YUV content image format",

  627.     sizeof(VideoData),

  628.     NULL, /* no probe */

  629.     img_read_header,

  630.     img_read_packet,

  631.     img_read_close,

  632.     NULL,

  633.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  634. };

  635. 

  636. AVOutputFormat pgmyuv_oformat = {

  637.     "pgmyuv",

  638.     "pgm with YUV content image format",

  639.     "",

  640.     "pgm",

  641.     sizeof(VideoData),

  642.     CODEC_ID_NONE,

  643.     CODEC_ID_RAWVIDEO,

  644.     img_write_header,

  645.     img_write_packet,

  646.     img_write_trailer,

  647.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  648. };

  649. 

  650. AVInputFormat ppm_iformat = {

  651.     "ppm",

  652.     "ppm image format",

  653.     sizeof(VideoData),

  654.     NULL,

  655.     img_read_header,

  656.     img_read_packet,

  657.     img_read_close,

  658.     NULL,

  659.     AVFMT_NOFILE | AVFMT_NEEDNUMBER | AVFMT_RGB24,

  660.     extensions: "ppm",

  661. };

  662. 

  663. AVOutputFormat ppm_oformat = {

  664.     "ppm",

  665.     "ppm image format",

  666.     "",

  667.     "ppm",

  668.     sizeof(VideoData),

  669.     CODEC_ID_NONE,

  670.     CODEC_ID_RAWVIDEO,

  671.     img_write_header,

  672.     img_write_packet,

  673.     img_write_trailer,

  674.     AVFMT_NOFILE | AVFMT_NEEDNUMBER | AVFMT_RGB24,

  675. };

  676. 

  677. AVInputFormat imgyuv_iformat = {

  678.     ".Y.U.V",

  679.     ".Y.U.V format",

  680.     sizeof(VideoData),

  681.     NULL,

  682.     img_read_header,

  683.     img_read_packet,

  684.     img_read_close,

  685.     NULL,

  686.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  687.     extensions: "Y",

  688. };

  689. 

  690. AVOutputFormat imgyuv_oformat = {

  691.     ".Y.U.V",

  692.     ".Y.U.V format",

  693.     "",

  694.     "Y",

  695.     sizeof(VideoData),

  696.     CODEC_ID_NONE,

  697.     CODEC_ID_RAWVIDEO,

  698.     img_write_header,

  699.     img_write_packet,

  700.     img_write_trailer,

  701.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  702. };

  703. 

  704. AVInputFormat pgmpipe_iformat = {

  705.     "pgmpipe",

  706.     "PGM pipe format",

  707.     sizeof(VideoData),

  708.     NULL, /* no probe */

  709.     img_read_header,

  710.     img_read_packet,

  711.     img_read_close,

  712.     NULL,

  713. };

  714. 

  715. AVOutputFormat pgmpipe_oformat = {

  716.     "pgmpipe",

  717.     "PGM pipe format",

  718.     "",

  719.     "pgm",

  720.     sizeof(VideoData),

  721.     CODEC_ID_NONE,

  722.     CODEC_ID_RAWVIDEO,

  723.     img_write_header,

  724.     img_write_packet,

  725.     img_write_trailer,

  726. };

  727. 

  728. AVInputFormat pgmyuvpipe_iformat = {

  729.     "pgmyuvpipe",

  730.     "PGM YUV pipe format",

  731.     sizeof(VideoData),

  732.     NULL, /* no probe */

  733.     img_read_header,

  734.     img_read_packet,

  735.     img_read_close,

  736.     NULL,

  737. };

  738. 

  739. AVOutputFormat pgmyuvpipe_oformat = {

  740.     "pgmyuvpipe",

  741.     "PGM YUV pipe format",

  742.     "",

  743.     "pgm",

  744.     sizeof(VideoData),

  745.     CODEC_ID_NONE,

  746.     CODEC_ID_RAWVIDEO,

  747.     img_write_header,

  748.     img_write_packet,

  749.     img_write_trailer,

  750. };

  751. 

  752. AVInputFormat ppmpipe_iformat = {

  753.     "ppmpipe",

  754.     "PPM pipe format",

  755.     sizeof(VideoData),

  756.     NULL, /* no probe */

  757.     img_read_header,

  758.     img_read_packet,

  759.     img_read_close,

  760.     NULL,

  761.     flags: AVFMT_RGB24,

  762. };

  763. 

  764. AVOutputFormat ppmpipe_oformat = {

  765.     "ppmpipe",

  766.     "PPM pipe format",

  767.     "",

  768.     "ppm",

  769.     sizeof(VideoData),

  770.     CODEC_ID_NONE,

  771.     CODEC_ID_RAWVIDEO,

  772.     img_write_header,

  773.     img_write_packet,

  774.     img_write_trailer,

  775.     flags: AVFMT_RGB24,

  776. };

  777. 

  778. 

  779. int img_init(void)

  780. {

  781.     av_register_input_format(&pgm_iformat);

  782.     av_register_output_format(&pgm_oformat);

  783. 

  784.     av_register_input_format(&pgmyuv_iformat);

  785.     av_register_output_format(&pgmyuv_oformat);

  786. 

  787.     av_register_input_format(&ppm_iformat);

  788.     av_register_output_format(&ppm_oformat);

  789. 

  790.     av_register_input_format(&imgyuv_iformat);

  791.     av_register_output_format(&imgyuv_oformat);

  792.     

  793.     av_register_input_format(&pgmpipe_iformat);

  794.     av_register_output_format(&pgmpipe_oformat);

  795. 

  796.     av_register_input_format(&pgmyuvpipe_iformat);

  797.     av_register_output_format(&pgmyuvpipe_oformat);

  798. 

  799.     av_register_input_format(&ppmpipe_iformat);

  800.     av_register_output_format(&ppmpipe_oformat);

  801.     return 0;

  802. }