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

720 lines
16KB
Raw Blame History 

  1. /*

  2.  * Image format

  3.  * Copyright (c) 2000, 2001 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. #define IMGFMT_YUV     1

  22. #define IMGFMT_PGMYUV  2

  23. #define IMGFMT_PGM     3

  24. #define IMGFMT_PPM     4

  25. 

  26. typedef struct {

  27.     int width;

  28.     int height;

  29.     int img_number;

  30.     int img_size;

  31.     int img_fmt;

  32.     int is_pipe;

  33.     char path[1024];

  34. } VideoData;

  35. 

  36. static inline int pnm_space(int c)  

  37. {

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

  39. }

  40. 

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

  42. {

  43.     char *s;

  44.     int c;

  45.     

  46.     do  {

  47.         c=get_byte(f);

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

  49.             do  {

  50.                 c=get_byte(f);

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

  52.             c=get_byte(f);

  53.         }

  54.     } while (pnm_space(c));

  55.     

  56.     s=str;

  57.     do  {

  58.         if (url_feof(f))

  59.             break;

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

  61.             *s++=c;

  62.         c=get_byte(f);

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

  64.     *s = '\0';

  65. }

  66. 

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

  68. {

  69.     int width, height, i;

  70.     char buf1[32];

  71.     UINT8 *picture[3];

  72. 

  73.     width = s->width;

  74.     height = s->height;

  75. 

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

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

  78.         return -EIO;

  79.     }

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

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

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

  83.     

  84.     picture[0] = buf;

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

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

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

  88.     

  89.     height>>=1;

  90.     width>>=1;

  91.     if (is_yuv) {

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

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

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

  95.         }

  96.     } else {

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

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

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

  100.         }

  101.     }

  102.     return 0;

  103. }

  104. 

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

  106. {

  107.     int width, height;

  108.     char buf1[32];

  109.     UINT8 *picture[3];

  110. 

  111.     width = s->width;

  112.     height = s->height;

  113. 

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

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

  116.         return -EIO;

  117.     }

  118.     

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

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

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

  122.     

  123.     picture[0] = buf;

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

  125.     

  126.     return 0;

  127. 

  128. }

  129. 

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

  131. {

  132.     ByteIOContext pb1, *pb = &pb1;

  133.     char fname[1024], *p;

  134.     int size;

  135. 

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

  137.     

  138.     strcpy(fname, filename);

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

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

  141.         return -EIO;

  142. 

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

  144.         return -EIO;

  145.     

  146.     get_buffer(pb, buf, size);

  147.     url_fclose(pb);

  148.     

  149.     p[1] = 'U';

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

  151.         return -EIO;

  152. 

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

  154.     url_fclose(pb);

  155.     

  156.     p[1] = 'V';

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

  158.         return -EIO;

  159. 

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

  161.     url_fclose(pb);

  162.     return 0;

  163. }

  164. 

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

  166. {

  167.     VideoData *s = s1->priv_data;

  168.     char filename[1024];

  169.     int ret;

  170.     ByteIOContext f1, *f;

  171. 

  172. /*

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

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

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

  176.         return -EIO;

  177. */

  178.     get_frame_filename(filename, sizeof(filename),

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

  180.     if (!s->is_pipe) {

  181.         f = &f1;

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

  183.             return -EIO;

  184.     } else {

  185.         f = &s1->pb;

  186.         if (url_feof(f))

  187.             return -EIO;

  188.     }

  189. 

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

  191.     pkt->stream_index = 0;

  192. 

  193.     switch(s->img_fmt) {

  194.     case IMGFMT_PGMYUV:

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

  196.         break;

  197.     case IMGFMT_PGM:

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

  199.         break;

  200.     case IMGFMT_YUV:

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

  202.         break;

  203.     case IMGFMT_PPM:

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

  205.         break;

  206.     default:

  207.         return -EIO;

  208.     }

  209.     

  210.     if (!s->is_pipe) {

  211.         url_fclose(f);

  212.     }

  213. 

  214.     if (ret < 0) {

  215.         av_free_packet(pkt);

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

  217.     } else {

  218.         s->img_number++;

  219.         return 0;

  220.     }

  221. }

  222. 

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

  224.     { 640, 480 },

  225.     { 720, 480 },

  226.     { 720, 576 },

  227.     { 352, 288 },

  228.     { 352, 240 },

  229.     { 160, 128 },

  230.     { 512, 384 },

  231.     { 640, 352 },

  232.     { 640, 240 },

  233. };

  234. 

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

  236. {

  237.     int i;

  238. 

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

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

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

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

  243.             return 0;

  244.         }

  245.     }

  246.     return -1;

  247. }

  248. 

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

  250. {

  251.     VideoData *s;

  252.     int i, h;

  253.     char buf[1024];

  254.     char buf1[32];

  255.     ByteIOContext pb1, *f = &pb1;

  256.     AVStream *st;

  257. 

  258.     s = av_malloc(sizeof(VideoData));

  259.     if (!s)

  260.         return -ENOMEM;

  261. 

  262.     s1->priv_data = s;

  263. 

  264.     s1->nb_streams = 1;

  265.     st = av_mallocz(sizeof(AVStream));

  266.     if (!st) {

  267.         av_free(s);

  268.         return -ENOMEM;

  269.     }

  270.     s1->streams[0] = st;

  271.     

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

  273.     s->img_number = 0;

  274. 

  275.     /* find format */

  276.     if (s1->format->flags & AVFMT_NOFILE)

  277.         s->is_pipe = 0;

  278.     else

  279.         s->is_pipe = 1;

  280.         

  281.     if (s1->format == &pgmyuvpipe_format ||

  282.         s1->format == &pgmyuv_format)

  283.         s->img_fmt = IMGFMT_PGMYUV;

  284.     else if (s1->format == &pgmpipe_format ||

  285.              s1->format == &pgm_format)

  286.         s->img_fmt = IMGFMT_PGM;

  287.     else if (s1->format == &imgyuv_format)

  288.         s->img_fmt = IMGFMT_YUV;

  289.     else if (s1->format == &ppmpipe_format ||

  290.              s1->format == &ppm_format)

  291.         s->img_fmt = IMGFMT_PPM;

  292.     else

  293.         goto fail;

  294. 

  295.     if (!s->is_pipe) {

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

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

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

  299.                 goto fail;

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

  301.                 break;

  302.             s->img_number++;

  303.         }

  304.         if (i == 5)

  305.             goto fail;

  306.     } else {

  307.         f = &s1->pb;

  308.     }

  309.     

  310.     /* find the image size */

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

  312.     switch(s->img_fmt) {

  313.     case IMGFMT_PGM:

  314.     case IMGFMT_PGMYUV:

  315.     case IMGFMT_PPM:

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

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

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

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

  320.         h = atoi(buf1);

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

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

  323.         s->height = h;

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

  325.             s->height <= 0 ||

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

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

  328.             goto fail1;

  329.         }

  330.         break;

  331.     case IMGFMT_YUV:

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

  333.         {

  334.             int img_size;

  335.             URLContext *h;

  336. 

  337.             /* XXX: hack hack */

  338.             h = url_fileno(f);

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

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

  341.                 goto fail1;

  342.             }

  343.         }

  344.         break;

  345.     }

  346. 

  347.     if (!s->is_pipe) {

  348.         url_fclose(f);

  349.     } else {

  350.         url_fseek(f, 0, SEEK_SET);

  351.     }

  352.     

  353. 

  354.     st->codec.codec_type = CODEC_TYPE_VIDEO;

  355.     st->codec.codec_id = CODEC_ID_RAWVIDEO;

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

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

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

  359.         st->codec.pix_fmt = PIX_FMT_RGB24;

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

  361.     } else {

  362.         st->codec.pix_fmt = PIX_FMT_YUV420P;

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

  364.     }

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

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

  367.     else

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

  369.     

  370.     return 0;

  371.  fail1:

  372.     if (!s->is_pipe)

  373.         url_fclose(f);

  374.  fail:

  375.     av_free(s);

  376.     return -EIO;

  377. }

  378. 

  379. static int img_read_close(AVFormatContext *s1)

  380. {

  381.     VideoData *s = s1->priv_data;

  382.     av_free(s);

  383.     return 0;

  384. }

  385. 

  386. /******************************************************/

  387. /* image output */

  388. 

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

  390. {

  391.     int i, h;

  392.     char buf[100];

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

  394. 

  395.     h = height;

  396.     if (is_yuv)

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

  398.     snprintf(buf, sizeof(buf), 

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

  400.              width, h, 255);

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

  402.     

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

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

  405.         put_buffer(pb, ptr, width);

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

  407.     }

  408. 

  409.     if (is_yuv) {

  410.         height >>= 1;

  411.         width >>= 1;

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

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

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

  415.             put_buffer(pb, ptr1, width);

  416.             put_buffer(pb, ptr2, width);

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

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

  419.         }

  420.     }

  421.     put_flush_packet(pb);

  422.     return 0;

  423. }

  424. 

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

  426. {

  427.     int i;

  428.     char buf[100];

  429.     UINT8 *ptr;

  430. 

  431.     snprintf(buf, sizeof(buf), 

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

  433.              width, height, 255);

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

  435.     

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

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

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

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

  440.     }

  441. 

  442.     put_flush_packet(pb);

  443.     return 0;

  444. }

  445. 

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

  447. {

  448.     ByteIOContext pb1, *pb = &pb1;

  449.     char fname[1024], *p;

  450.     int i, j;

  451.     UINT8 *ptr;

  452.     static char *ext = "YUV";

  453. 

  454.     strcpy(fname, filename);

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

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

  457.         return -EIO;

  458. 

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

  460.         if (i == 1) {

  461.             width >>= 1;

  462.             height >>= 1;

  463.         }

  464. 

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

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

  467.             return -EIO;

  468.     

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

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

  471.             put_buffer(pb, ptr, width);

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

  473.         }

  474.         put_flush_packet(pb);

  475.         url_fclose(pb);

  476.     }

  477.     return 0;

  478. }

  479. 

  480. static int img_write_header(AVFormatContext *s)

  481. {

  482.     VideoData *img;

  483. 

  484.     img = av_mallocz(sizeof(VideoData));

  485.     if (!img)

  486.         return -1;

  487.     s->priv_data = img;

  488.     img->img_number = 1;

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

  490. 

  491.     /* find format */

  492.     if (s->format->flags & AVFMT_NOFILE)

  493.         img->is_pipe = 0;

  494.     else

  495.         img->is_pipe = 1;

  496.         

  497.     if (s->format == &pgmyuvpipe_format ||

  498.         s->format == &pgmyuv_format) {

  499.         img->img_fmt = IMGFMT_PGMYUV;

  500.     } else if (s->format == &pgmpipe_format ||

  501.                s->format == &pgm_format) {

  502.         img->img_fmt = IMGFMT_PGM;

  503.     } else if (s->format == &imgyuv_format) {

  504.         img->img_fmt = IMGFMT_YUV;

  505.     } else if (s->format == &ppmpipe_format ||

  506.                s->format == &ppm_format) {

  507.         img->img_fmt = IMGFMT_PPM;

  508.     } else {

  509.         goto fail;

  510.     }

  511.     return 0;

  512.  fail:

  513.     av_free(img);

  514.     return -EIO;

  515. }

  516. 

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

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

  519. {

  520.     VideoData *img = s->priv_data;

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

  522.     ByteIOContext pb1, *pb;

  523.     AVPicture picture;

  524.     int width, height, ret, size1;

  525.     char filename[1024];

  526. 

  527.     width = st->codec.width;

  528.     height = st->codec.height;

  529. 

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

  531.     case PIX_FMT_YUV420P:

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

  533.         if (size != size1)

  534.             return -EIO;

  535.         

  536.         picture.data[0] = buf;

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

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

  539.         picture.linesize[0] = width;

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

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

  542.         break;

  543.     case PIX_FMT_RGB24:

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

  545.         if (size != size1)

  546.             return -EIO;

  547.         picture.data[0] = buf;

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

  549.         break;

  550.     default:

  551.         return -EIO;

  552.     }

  553.     

  554. /*

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

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

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

  558.         return -EIO;

  559. */

  560.     get_frame_filename(filename, sizeof(filename), 

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

  562.     if (!img->is_pipe) {

  563.         pb = &pb1;

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

  565.             return -EIO;

  566.     } else {

  567.         pb = &s->pb;

  568.     }

  569.     switch(img->img_fmt) {

  570.     case IMGFMT_PGMYUV:

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

  572.         break;

  573.     case IMGFMT_PGM:

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

  575.         break;

  576.     case IMGFMT_YUV:

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

  578.         break;

  579.     case IMGFMT_PPM:

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

  581.         break;

  582.     }

  583.     if (!img->is_pipe) {

  584.         url_fclose(pb);

  585.     }

  586. 

  587.     img->img_number++;

  588.     return 0;

  589. }

  590. 

  591. static int img_write_trailer(AVFormatContext *s)

  592. {

  593.     VideoData *img = s->priv_data;

  594.     av_free(img);

  595.     return 0;

  596. }

  597. 

  598. AVFormat pgm_format = {

  599.     "pgm",

  600.     "pgm image format",

  601.     "",

  602.     "pgm",

  603.     CODEC_ID_NONE,

  604.     CODEC_ID_RAWVIDEO,

  605.     img_write_header,

  606.     img_write_packet,

  607.     img_write_trailer,

  608. 

  609.     img_read_header,

  610.     img_read_packet,

  611.     img_read_close,

  612.     NULL,

  613.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  614. };

  615. 

  616. AVFormat pgmyuv_format = {

  617.     "pgmyuv",

  618.     "pgm with YUV content image format",

  619.     "",

  620.     "pgm",

  621.     CODEC_ID_NONE,

  622.     CODEC_ID_RAWVIDEO,

  623.     img_write_header,

  624.     img_write_packet,

  625.     img_write_trailer,

  626. 

  627.     img_read_header,

  628.     img_read_packet,

  629.     img_read_close,

  630.     NULL,

  631.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  632. };

  633. 

  634. AVFormat ppm_format = {

  635.     "ppm",

  636.     "ppm image format",

  637.     "",

  638.     "ppm",

  639.     CODEC_ID_NONE,

  640.     CODEC_ID_RAWVIDEO,

  641.     img_write_header,

  642.     img_write_packet,

  643.     img_write_trailer,

  644. 

  645.     img_read_header,

  646.     img_read_packet,

  647.     img_read_close,

  648.     NULL,

  649.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  650. };

  651. 

  652. AVFormat imgyuv_format = {

  653.     ".Y.U.V",

  654.     ".Y.U.V format",

  655.     "",

  656.     "Y",

  657.     CODEC_ID_NONE,

  658.     CODEC_ID_RAWVIDEO,

  659.     img_write_header,

  660.     img_write_packet,

  661.     img_write_trailer,

  662. 

  663.     img_read_header,

  664.     img_read_packet,

  665.     img_read_close,

  666.     NULL,

  667.     AVFMT_NOFILE | AVFMT_NEEDNUMBER,

  668. };

  669. 

  670. AVFormat pgmpipe_format = {

  671.     "pgmpipe",

  672.     "PGM pipe format",

  673.     "",

  674.     "pgm",

  675.     CODEC_ID_NONE,

  676.     CODEC_ID_RAWVIDEO,

  677.     img_write_header,

  678.     img_write_packet,

  679.     img_write_trailer,

  680. 

  681.     img_read_header,

  682.     img_read_packet,

  683.     img_read_close,

  684.     NULL,

  685. };

  686. 

  687. AVFormat pgmyuvpipe_format = {

  688.     "pgmyuvpipe",

  689.     "PGM YUV pipe format",

  690.     "",

  691.     "pgm",

  692.     CODEC_ID_NONE,

  693.     CODEC_ID_RAWVIDEO,

  694.     img_write_header,

  695.     img_write_packet,

  696.     img_write_trailer,

  697. 

  698.     img_read_header,

  699.     img_read_packet,

  700.     img_read_close,

  701.     NULL,

  702. };

  703. 

  704. AVFormat ppmpipe_format = {

  705.     "ppmpipe",

  706.     "PPM pipe format",

  707.     "",

  708.     "ppm",

  709.     CODEC_ID_NONE,

  710.     CODEC_ID_RAWVIDEO,

  711.     img_write_header,

  712.     img_write_packet,

  713.     img_write_trailer,

  714. 

  715.     img_read_header,

  716.     img_read_packet,

  717.     img_read_close,

  718.     NULL,

  719. };