Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Image format
  3.  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
  4.  * Copyright (c) 2004 Michael Niedermayer
  5.  *
  6.  * This file is part of FFmpeg.
  7.  *
  8.  * FFmpeg is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * FFmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with FFmpeg; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21.  */
  22.  
  23. #define _BSD_SOURCE
  24. #include <sys/stat.h>
  25. #include "libavutil/avstring.h"
  26. #include "libavutil/log.h"
  27. #include "libavutil/opt.h"
  28. #include "libavutil/pixdesc.h"
  29. #include "libavutil/parseutils.h"
  30. #include "libavutil/intreadwrite.h"
  31. #include "avformat.h"
  32. #include "avio_internal.h"
  33. #include "internal.h"
  34. #include "img2.h"
  35.  
  36. #if HAVE_GLOB
  37. /* Locally define as 0 (bitwise-OR no-op) any missing glob options that
  38.    are non-posix glibc/bsd extensions. */
  39. #ifndef GLOB_NOMAGIC
  40. #define GLOB_NOMAGIC 0
  41. #endif
  42. #ifndef GLOB_BRACE
  43. #define GLOB_BRACE 0
  44. #endif
  45.  
  46. #endif /* HAVE_GLOB */
  47.  
  48. static const int sizes[][2] = {
  49.     { 640, 480 },
  50.     { 720, 480 },
  51.     { 720, 576 },
  52.     { 352, 288 },
  53.     { 352, 240 },
  54.     { 160, 128 },
  55.     { 512, 384 },
  56.     { 640, 352 },
  57.     { 640, 240 },
  58. };
  59.  
  60. static int infer_size(int *width_ptr, int *height_ptr, int size)
  61. {
  62.     int i;
  63.  
  64.     for (i = 0; i < FF_ARRAY_ELEMS(sizes); i++) {
  65.         if ((sizes[i][0] * sizes[i][1]) == size) {
  66.             *width_ptr  = sizes[i][0];
  67.             *height_ptr = sizes[i][1];
  68.             return 0;
  69.         }
  70.     }
  71.  
  72.     return -1;
  73. }
  74.  
  75. static int is_glob(const char *path)
  76. {
  77. #if HAVE_GLOB
  78.     size_t span = 0;
  79.     const char *p = path;
  80.  
  81.     while (p = strchr(p, '%')) {
  82.         if (*(++p) == '%') {
  83.             ++p;
  84.             continue;
  85.         }
  86.         if (span = strspn(p, "*?[]{}"))
  87.             break;
  88.     }
  89.     /* Did we hit a glob char or get to the end? */
  90.     return span != 0;
  91. #else
  92.     return 0;
  93. #endif
  94. }
  95.  
  96. /**
  97.  * Get index range of image files matched by path.
  98.  *
  99.  * @param pfirst_index pointer to index updated with the first number in the range
  100.  * @param plast_index  pointer to index updated with the last number in the range
  101.  * @param path         path which has to be matched by the image files in the range
  102.  * @param start_index  minimum accepted value for the first index in the range
  103.  * @return -1 if no image file could be found
  104.  */
  105. static int find_image_range(int *pfirst_index, int *plast_index,
  106.                             const char *path, int start_index, int start_index_range)
  107. {
  108.     char buf[1024];
  109.     int range, last_index, range1, first_index;
  110.  
  111.     /* find the first image */
  112.     for (first_index = start_index; first_index < start_index + start_index_range; first_index++) {
  113.         if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0) {
  114.             *pfirst_index =
  115.             *plast_index  = 1;
  116.             if (avio_check(buf, AVIO_FLAG_READ) > 0)
  117.                 return 0;
  118.             return -1;
  119.         }
  120.         if (avio_check(buf, AVIO_FLAG_READ) > 0)
  121.             break;
  122.     }
  123.     if (first_index == start_index + start_index_range)
  124.         goto fail;
  125.  
  126.     /* find the last image */
  127.     last_index = first_index;
  128.     for (;;) {
  129.         range = 0;
  130.         for (;;) {
  131.             if (!range)
  132.                 range1 = 1;
  133.             else
  134.                 range1 = 2 * range;
  135.             if (av_get_frame_filename(buf, sizeof(buf), path,
  136.                                       last_index + range1) < 0)
  137.                 goto fail;
  138.             if (avio_check(buf, AVIO_FLAG_READ) <= 0)
  139.                 break;
  140.             range = range1;
  141.             /* just in case... */
  142.             if (range >= (1 << 30))
  143.                 goto fail;
  144.         }
  145.         /* we are sure than image last_index + range exists */
  146.         if (!range)
  147.             break;
  148.         last_index += range;
  149.     }
  150.     *pfirst_index = first_index;
  151.     *plast_index  = last_index;
  152.     return 0;
  153.  
  154. fail:
  155.     return -1;
  156. }
  157.  
  158. static int img_read_probe(AVProbeData *p)
  159. {
  160.     if (p->filename && ff_guess_image2_codec(p->filename)) {
  161.         if (av_filename_number_test(p->filename))
  162.             return AVPROBE_SCORE_MAX;
  163.         else if (is_glob(p->filename))
  164.             return AVPROBE_SCORE_MAX;
  165.         else if (p->filename[strcspn(p->filename, "*?{")]) // probably PT_GLOB
  166.             return AVPROBE_SCORE_EXTENSION + 2; // score chosen to be a tad above the image pipes
  167.         else if (p->buf_size == 0)
  168.             return 0;
  169.         else if (av_match_ext(p->filename, "raw") || av_match_ext(p->filename, "gif"))
  170.             return 5;
  171.         else
  172.             return AVPROBE_SCORE_EXTENSION;
  173.     }
  174.     return 0;
  175. }
  176.  
  177. int ff_img_read_header(AVFormatContext *s1)
  178. {
  179.     VideoDemuxData *s = s1->priv_data;
  180.     int first_index = 1, last_index = 1;
  181.     AVStream *st;
  182.     enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;
  183.  
  184.     s1->ctx_flags |= AVFMTCTX_NOHEADER;
  185.  
  186.     st = avformat_new_stream(s1, NULL);
  187.     if (!st) {
  188.         return AVERROR(ENOMEM);
  189.     }
  190.  
  191.     if (s->pixel_format &&
  192.         (pix_fmt = av_get_pix_fmt(s->pixel_format)) == AV_PIX_FMT_NONE) {
  193.         av_log(s1, AV_LOG_ERROR, "No such pixel format: %s.\n",
  194.                s->pixel_format);
  195.         return AVERROR(EINVAL);
  196.     }
  197.  
  198.     av_strlcpy(s->path, s1->filename, sizeof(s->path));
  199.     s->img_number = 0;
  200.     s->img_count  = 0;
  201.  
  202.     /* find format */
  203.     if (s1->iformat->flags & AVFMT_NOFILE)
  204.         s->is_pipe = 0;
  205.     else {
  206.         s->is_pipe       = 1;
  207.         st->need_parsing = AVSTREAM_PARSE_FULL;
  208.     }
  209.  
  210.     if (s->ts_from_file == 2) {
  211. #if !HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
  212.         av_log(s1, AV_LOG_ERROR, "POSIX.1-2008 not supported, nanosecond file timestamps unavailable\n");
  213.         return AVERROR(ENOSYS);
  214. #endif
  215.         avpriv_set_pts_info(st, 64, 1, 1000000000);
  216.     } else if (s->ts_from_file)
  217.         avpriv_set_pts_info(st, 64, 1, 1);
  218.     else
  219.         avpriv_set_pts_info(st, 64, s->framerate.den, s->framerate.num);
  220.  
  221.     if (s->width && s->height) {
  222.         st->codec->width  = s->width;
  223.         st->codec->height = s->height;
  224.     }
  225.  
  226.     if (!s->is_pipe) {
  227.         if (s->pattern_type == PT_GLOB_SEQUENCE) {
  228.         s->use_glob = is_glob(s->path);
  229.         if (s->use_glob) {
  230. #if HAVE_GLOB
  231.             char *p = s->path, *q, *dup;
  232.             int gerr;
  233. #endif
  234.  
  235.             av_log(s1, AV_LOG_WARNING, "Pattern type 'glob_sequence' is deprecated: "
  236.                    "use pattern_type 'glob' instead\n");
  237. #if HAVE_GLOB
  238.             dup = q = av_strdup(p);
  239.             while (*q) {
  240.                 /* Do we have room for the next char and a \ insertion? */
  241.                 if ((p - s->path) >= (sizeof(s->path) - 2))
  242.                   break;
  243.                 if (*q == '%' && strspn(q + 1, "%*?[]{}"))
  244.                     ++q;
  245.                 else if (strspn(q, "\\*?[]{}"))
  246.                     *p++ = '\\';
  247.                 *p++ = *q++;
  248.             }
  249.             *p = 0;
  250.             av_free(dup);
  251.  
  252.             gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
  253.             if (gerr != 0) {
  254.                 return AVERROR(ENOENT);
  255.             }
  256.             first_index = 0;
  257.             last_index = s->globstate.gl_pathc - 1;
  258. #endif
  259.         }
  260.         }
  261.         if ((s->pattern_type == PT_GLOB_SEQUENCE && !s->use_glob) || s->pattern_type == PT_SEQUENCE) {
  262.             if (find_image_range(&first_index, &last_index, s->path,
  263.                                  s->start_number, s->start_number_range) < 0) {
  264.                 av_log(s1, AV_LOG_ERROR,
  265.                        "Could find no file with path '%s' and index in the range %d-%d\n",
  266.                        s->path, s->start_number, s->start_number + s->start_number_range - 1);
  267.                 return AVERROR(ENOENT);
  268.             }
  269.         } else if (s->pattern_type == PT_GLOB) {
  270. #if HAVE_GLOB
  271.             int gerr;
  272.             gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate);
  273.             if (gerr != 0) {
  274.                 return AVERROR(ENOENT);
  275.             }
  276.             first_index = 0;
  277.             last_index = s->globstate.gl_pathc - 1;
  278.             s->use_glob = 1;
  279. #else
  280.             av_log(s1, AV_LOG_ERROR,
  281.                    "Pattern type 'glob' was selected but globbing "
  282.                    "is not supported by this libavformat build\n");
  283.             return AVERROR(ENOSYS);
  284. #endif
  285.         } else if (s->pattern_type != PT_GLOB_SEQUENCE && s->pattern_type != PT_NONE) {
  286.             av_log(s1, AV_LOG_ERROR,
  287.                    "Unknown value '%d' for pattern_type option\n", s->pattern_type);
  288.             return AVERROR(EINVAL);
  289.         }
  290.         s->img_first  = first_index;
  291.         s->img_last   = last_index;
  292.         s->img_number = first_index;
  293.         /* compute duration */
  294.         if (!s->ts_from_file) {
  295.             st->start_time = 0;
  296.             st->duration   = last_index - first_index + 1;
  297.         }
  298.     }
  299.  
  300.     if (s1->video_codec_id) {
  301.         st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  302.         st->codec->codec_id   = s1->video_codec_id;
  303.     } else if (s1->audio_codec_id) {
  304.         st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  305.         st->codec->codec_id   = s1->audio_codec_id;
  306.     } else if (s1->iformat->raw_codec_id) {
  307.         st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  308.         st->codec->codec_id   = s1->iformat->raw_codec_id;
  309.     } else {
  310.         const char *str = strrchr(s->path, '.');
  311.         s->split_planes       = str && !av_strcasecmp(str + 1, "y");
  312.         st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  313.         if (s1->pb) {
  314.             int probe_buffer_size = 2048;
  315.             uint8_t *probe_buffer = av_realloc(NULL, probe_buffer_size + AVPROBE_PADDING_SIZE);
  316.             AVInputFormat *fmt = NULL;
  317.             AVProbeData pd = { 0 };
  318.  
  319.             if (!probe_buffer)
  320.                 return AVERROR(ENOMEM);
  321.  
  322.             probe_buffer_size = avio_read(s1->pb, probe_buffer, probe_buffer_size);
  323.             if (probe_buffer_size < 0) {
  324.                 av_free(probe_buffer);
  325.                 return probe_buffer_size;
  326.             }
  327.             memset(probe_buffer + probe_buffer_size, 0, AVPROBE_PADDING_SIZE);
  328.  
  329.             pd.buf = probe_buffer;
  330.             pd.buf_size = probe_buffer_size;
  331.             pd.filename = s1->filename;
  332.  
  333.             while ((fmt = av_iformat_next(fmt))) {
  334.                 if (fmt->read_header != ff_img_read_header ||
  335.                     !fmt->read_probe ||
  336.                     (fmt->flags & AVFMT_NOFILE) ||
  337.                     !fmt->raw_codec_id)
  338.                     continue;
  339.                 if (fmt->read_probe(&pd) > 0) {
  340.                     st->codec->codec_id = fmt->raw_codec_id;
  341.                     break;
  342.                 }
  343.             }
  344.             if (s1->flags & AVFMT_FLAG_CUSTOM_IO) {
  345.                 avio_seek(s1->pb, 0, SEEK_SET);
  346.             } else
  347.                 ffio_rewind_with_probe_data(s1->pb, &probe_buffer, probe_buffer_size);
  348.         }
  349.         if (st->codec->codec_id == AV_CODEC_ID_NONE)
  350.             st->codec->codec_id = ff_guess_image2_codec(s->path);
  351.         if (st->codec->codec_id == AV_CODEC_ID_LJPEG)
  352.             st->codec->codec_id = AV_CODEC_ID_MJPEG;
  353.         if (st->codec->codec_id == AV_CODEC_ID_ALIAS_PIX) // we cannot distingiush this from BRENDER_PIX
  354.             st->codec->codec_id = AV_CODEC_ID_NONE;
  355.     }
  356.     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
  357.         pix_fmt != AV_PIX_FMT_NONE)
  358.         st->codec->pix_fmt = pix_fmt;
  359.  
  360.     return 0;
  361. }
  362.  
  363. int ff_img_read_packet(AVFormatContext *s1, AVPacket *pkt)
  364. {
  365.     VideoDemuxData *s = s1->priv_data;
  366.     char filename_bytes[1024];
  367.     char *filename = filename_bytes;
  368.     int i, res;
  369.     int size[3]           = { 0 }, ret[3] = { 0 };
  370.     AVIOContext *f[3]     = { NULL };
  371.     AVCodecContext *codec = s1->streams[0]->codec;
  372.  
  373.     if (!s->is_pipe) {
  374.         /* loop over input */
  375.         if (s->loop && s->img_number > s->img_last) {
  376.             s->img_number = s->img_first;
  377.         }
  378.         if (s->img_number > s->img_last)
  379.             return AVERROR_EOF;
  380.         if (s->pattern_type == PT_NONE) {
  381.             av_strlcpy(filename_bytes, s->path, sizeof(filename_bytes));
  382.         } else if (s->use_glob) {
  383. #if HAVE_GLOB
  384.             filename = s->globstate.gl_pathv[s->img_number];
  385. #endif
  386.         } else {
  387.         if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes),
  388.                                   s->path,
  389.                                   s->img_number) < 0 && s->img_number > 1)
  390.             return AVERROR(EIO);
  391.         }
  392.         for (i = 0; i < 3; i++) {
  393.             if (avio_open2(&f[i], filename, AVIO_FLAG_READ,
  394.                            &s1->interrupt_callback, NULL) < 0) {
  395.                 if (i >= 1)
  396.                     break;
  397.                 av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",
  398.                        filename);
  399.                 return AVERROR(EIO);
  400.             }
  401.             size[i] = avio_size(f[i]);
  402.  
  403.             if (!s->split_planes)
  404.                 break;
  405.             filename[strlen(filename) - 1] = 'U' + i;
  406.         }
  407.  
  408.         if (codec->codec_id == AV_CODEC_ID_NONE) {
  409.             AVProbeData pd = { 0 };
  410.             AVInputFormat *ifmt;
  411.             uint8_t header[PROBE_BUF_MIN + AVPROBE_PADDING_SIZE];
  412.             int ret;
  413.             int score = 0;
  414.  
  415.             ret = avio_read(f[0], header, PROBE_BUF_MIN);
  416.             if (ret < 0)
  417.                 return ret;
  418.             memset(header + ret, 0, sizeof(header) - ret);
  419.             avio_skip(f[0], -ret);
  420.             pd.buf = header;
  421.             pd.buf_size = ret;
  422.             pd.filename = filename;
  423.  
  424.             ifmt = av_probe_input_format3(&pd, 1, &score);
  425.             if (ifmt && ifmt->read_packet == ff_img_read_packet && ifmt->raw_codec_id)
  426.                 codec->codec_id = ifmt->raw_codec_id;
  427.         }
  428.  
  429.         if (codec->codec_id == AV_CODEC_ID_RAWVIDEO && !codec->width)
  430.             infer_size(&codec->width, &codec->height, size[0]);
  431.     } else {
  432.         f[0] = s1->pb;
  433.         if (avio_feof(f[0]) && s->loop && s->is_pipe)
  434.             avio_seek(f[0], 0, SEEK_SET);
  435.         if (avio_feof(f[0]))
  436.             return AVERROR_EOF;
  437.         if (s->frame_size > 0) {
  438.             size[0] = s->frame_size;
  439.         } else if (!s1->streams[0]->parser) {
  440.             size[0] = avio_size(s1->pb);
  441.         } else {
  442.             size[0] = 4096;
  443.         }
  444.     }
  445.  
  446.     res = av_new_packet(pkt, size[0] + size[1] + size[2]);
  447.     if (res < 0) {
  448.         goto fail;
  449.     }
  450.     pkt->stream_index = 0;
  451.     pkt->flags       |= AV_PKT_FLAG_KEY;
  452.     if (s->ts_from_file) {
  453.         struct stat img_stat;
  454.         if (stat(filename, &img_stat)) {
  455.             res = AVERROR(EIO);
  456.             goto fail;
  457.         }
  458.         pkt->pts = (int64_t)img_stat.st_mtime;
  459. #if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
  460.         if (s->ts_from_file == 2)
  461.             pkt->pts = 1000000000*pkt->pts + img_stat.st_mtim.tv_nsec;
  462. #endif
  463.         av_add_index_entry(s1->streams[0], s->img_number, pkt->pts, 0, 0, AVINDEX_KEYFRAME);
  464.     } else if (!s->is_pipe) {
  465.         pkt->pts      = s->pts;
  466.     }
  467.  
  468.     if (s->is_pipe)
  469.         pkt->pos = avio_tell(f[0]);
  470.  
  471.     pkt->size = 0;
  472.     for (i = 0; i < 3; i++) {
  473.         if (f[i]) {
  474.             ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
  475.             if (s->loop && s->is_pipe && ret[i] == AVERROR_EOF) {
  476.                 if (avio_seek(f[i], 0, SEEK_SET) >= 0) {
  477.                     pkt->pos = 0;
  478.                     ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]);
  479.                 }
  480.             }
  481.             if (!s->is_pipe)
  482.                 avio_closep(&f[i]);
  483.             if (ret[i] > 0)
  484.                 pkt->size += ret[i];
  485.         }
  486.     }
  487.  
  488.     if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) {
  489.         av_free_packet(pkt);
  490.         if (ret[0] < 0) {
  491.             res = ret[0];
  492.         } else if (ret[1] < 0) {
  493.             res = ret[1];
  494.         } else if (ret[2] < 0) {
  495.             res = ret[2];
  496.         } else {
  497.             res = AVERROR_EOF;
  498.         }
  499.         goto fail;
  500.     } else {
  501.         s->img_count++;
  502.         s->img_number++;
  503.         s->pts++;
  504.         return 0;
  505.     }
  506.  
  507. fail:
  508.     if (!s->is_pipe) {
  509.         for (i = 0; i < 3; i++) {
  510.             avio_closep(&f[i]);
  511.         }
  512.     }
  513.     return res;
  514. }
  515.  
  516. static int img_read_close(struct AVFormatContext* s1)
  517. {
  518. #if HAVE_GLOB
  519.     VideoDemuxData *s = s1->priv_data;
  520.     if (s->use_glob) {
  521.         globfree(&s->globstate);
  522.     }
  523. #endif
  524.     return 0;
  525. }
  526.  
  527. static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
  528. {
  529.     VideoDemuxData *s1 = s->priv_data;
  530.     AVStream *st = s->streams[0];
  531.  
  532.     if (s1->ts_from_file) {
  533.         int index = av_index_search_timestamp(st, timestamp, flags);
  534.         if(index < 0)
  535.             return -1;
  536.         s1->img_number = st->index_entries[index].pos;
  537.         return 0;
  538.     }
  539.  
  540.     if (timestamp < 0 || !s1->loop && timestamp > s1->img_last - s1->img_first)
  541.         return -1;
  542.     s1->img_number = timestamp%(s1->img_last - s1->img_first + 1) + s1->img_first;
  543.     s1->pts = timestamp;
  544.     return 0;
  545. }
  546.  
  547. #define OFFSET(x) offsetof(VideoDemuxData, x)
  548. #define DEC AV_OPT_FLAG_DECODING_PARAM
  549. const AVOption ff_img_options[] = {
  550.     { "framerate",    "set the video framerate",             OFFSET(framerate),    AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0,   DEC },
  551.     { "loop",         "force loop over input file sequence", OFFSET(loop),         AV_OPT_TYPE_INT,    {.i64 = 0   }, 0, 1,       DEC },
  552.  
  553.     { "pattern_type", "set pattern type",                    OFFSET(pattern_type), AV_OPT_TYPE_INT,    {.i64=PT_GLOB_SEQUENCE}, 0,       INT_MAX, DEC, "pattern_type"},
  554.     { "glob_sequence","select glob/sequence pattern type",   0, AV_OPT_TYPE_CONST,  {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" },
  555.     { "glob",         "select glob pattern type",            0, AV_OPT_TYPE_CONST,  {.i64=PT_GLOB         }, INT_MIN, INT_MAX, DEC, "pattern_type" },
  556.     { "sequence",     "select sequence pattern type",        0, AV_OPT_TYPE_CONST,  {.i64=PT_SEQUENCE     }, INT_MIN, INT_MAX, DEC, "pattern_type" },
  557.     { "none",         "disable pattern matching",            0, AV_OPT_TYPE_CONST,  {.i64=PT_NONE         }, INT_MIN, INT_MAX, DEC, "pattern_type" },
  558.  
  559.     { "pixel_format", "set video pixel format",              OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0,       DEC },
  560.     { "start_number", "set first number in the sequence",    OFFSET(start_number), AV_OPT_TYPE_INT,    {.i64 = 0   }, INT_MIN, INT_MAX, DEC },
  561.     { "start_number_range", "set range for looking at the first sequence number", OFFSET(start_number_range), AV_OPT_TYPE_INT, {.i64 = 5}, 1, INT_MAX, DEC },
  562.     { "video_size",   "set video size",                      OFFSET(width),        AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0,   DEC },
  563.     { "frame_size",   "force frame size in bytes",           OFFSET(frame_size),   AV_OPT_TYPE_INT,    {.i64 = 0   }, 0, INT_MAX, DEC },
  564.     { "ts_from_file", "set frame timestamp from file's one", OFFSET(ts_from_file), AV_OPT_TYPE_INT,    {.i64 = 0   }, 0, 2,       DEC, "ts_type" },
  565.     { "none", "none",                   0, AV_OPT_TYPE_CONST,    {.i64 = 0   }, 0, 2,       DEC, "ts_type" },
  566.     { "sec",  "second precision",       0, AV_OPT_TYPE_CONST,    {.i64 = 1   }, 0, 2,       DEC, "ts_type" },
  567.     { "ns",   "nano second precision",  0, AV_OPT_TYPE_CONST,    {.i64 = 2   }, 0, 2,       DEC, "ts_type" },
  568.     { NULL },
  569. };
  570.  
  571. #if CONFIG_IMAGE2_DEMUXER
  572. static const AVClass img2_class = {
  573.     .class_name = "image2 demuxer",
  574.     .item_name  = av_default_item_name,
  575.     .option     = ff_img_options,
  576.     .version    = LIBAVUTIL_VERSION_INT,
  577. };
  578. AVInputFormat ff_image2_demuxer = {
  579.     .name           = "image2",
  580.     .long_name      = NULL_IF_CONFIG_SMALL("image2 sequence"),
  581.     .priv_data_size = sizeof(VideoDemuxData),
  582.     .read_probe     = img_read_probe,
  583.     .read_header    = ff_img_read_header,
  584.     .read_packet    = ff_img_read_packet,
  585.     .read_close     = img_read_close,
  586.     .read_seek      = img_read_seek,
  587.     .flags          = AVFMT_NOFILE,
  588.     .priv_class     = &img2_class,
  589. };
  590. #endif
  591. #if CONFIG_IMAGE2PIPE_DEMUXER
  592. static const AVClass img2pipe_class = {
  593.     .class_name = "image2pipe demuxer",
  594.     .item_name  = av_default_item_name,
  595.     .option     = ff_img_options,
  596.     .version    = LIBAVUTIL_VERSION_INT,
  597. };
  598. AVInputFormat ff_image2pipe_demuxer = {
  599.     .name           = "image2pipe",
  600.     .long_name      = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
  601.     .priv_data_size = sizeof(VideoDemuxData),
  602.     .read_header    = ff_img_read_header,
  603.     .read_packet    = ff_img_read_packet,
  604.     .priv_class     = &img2pipe_class,
  605. };
  606. #endif
  607.  
  608. static int bmp_probe(AVProbeData *p)
  609. {
  610.     const uint8_t *b = p->buf;
  611.     int ihsize;
  612.  
  613.     if (AV_RB16(b) != 0x424d)
  614.         return 0;
  615.  
  616.     ihsize = AV_RL32(b+14);
  617.     if (ihsize < 12 || ihsize > 255)
  618.         return 0;
  619.  
  620.     if (!AV_RN32(b + 6)) {
  621.         return AVPROBE_SCORE_EXTENSION + 1;
  622.     }
  623.     return AVPROBE_SCORE_EXTENSION / 4;
  624. }
  625.  
  626. static int dds_probe(AVProbeData *p)
  627. {
  628.     const uint8_t *b = p->buf;
  629.  
  630.     if (   AV_RB64(b) == 0x444453207c000000
  631.         && AV_RL32(b +  8)
  632.         && AV_RL32(b + 12))
  633.         return AVPROBE_SCORE_MAX - 1;
  634.     return 0;
  635. }
  636.  
  637. static int dpx_probe(AVProbeData *p)
  638. {
  639.     const uint8_t *b = p->buf;
  640.     int w, h;
  641.     int is_big = (AV_RN32(b) == AV_RN32("SDPX"));
  642.  
  643.     if (p->buf_size < 0x304+8)
  644.         return 0;
  645.     w = is_big ? AV_RB32(p->buf + 0x304) : AV_RL32(p->buf + 0x304);
  646.     h = is_big ? AV_RB32(p->buf + 0x308) : AV_RL32(p->buf + 0x308);
  647.     if (w <= 0 || h <= 0)
  648.         return 0;
  649.  
  650.     if (is_big || AV_RN32(b) == AV_RN32("XPDS"))
  651.         return AVPROBE_SCORE_EXTENSION + 1;
  652.     return 0;
  653. }
  654.  
  655. static int exr_probe(AVProbeData *p)
  656. {
  657.     const uint8_t *b = p->buf;
  658.  
  659.     if (AV_RL32(b) == 20000630)
  660.         return AVPROBE_SCORE_EXTENSION + 1;
  661.     return 0;
  662. }
  663.  
  664. static int j2k_probe(AVProbeData *p)
  665. {
  666.     const uint8_t *b = p->buf;
  667.  
  668.     if (AV_RB64(b) == 0x0000000c6a502020 ||
  669.         AV_RB32(b) == 0xff4fff51)
  670.         return AVPROBE_SCORE_EXTENSION + 1;
  671.     return 0;
  672. }
  673.  
  674. static int jpeg_probe(AVProbeData *p)
  675. {
  676.     const uint8_t *b = p->buf;
  677.     int i, state = 0xD8, exif_size = 0;
  678.  
  679.     if (AV_RB16(b) != 0xFFD8 ||
  680.         AV_RB32(b) == 0xFFD8FFF7)
  681.     return 0;
  682.  
  683.     b += 2;
  684.     if (AV_RB16(b) == 0xFFE1 && AV_RB32(b + 4) == AV_RB32("Exif")) {
  685.         exif_size = AV_RB16(b + 2) + 2;
  686.         b += exif_size;
  687.     }
  688.     for (i = 0; i + exif_size < p->buf_size - 2; i++) {
  689.         int c;
  690.         if (b[i] != 0xFF)
  691.             continue;
  692.         c = b[i + 1];
  693.         switch (c) {
  694.         case 0xD8:
  695.             return 0;
  696.         case 0xC0:
  697.         case 0xC1:
  698.         case 0xC2:
  699.         case 0xC3:
  700.         case 0xC5:
  701.         case 0xC6:
  702.         case 0xC7:
  703.             if (state != 0xD8)
  704.                 return 0;
  705.             state = 0xC0;
  706.             break;
  707.         case 0xDA:
  708.             if (state != 0xC0)
  709.                 return 0;
  710.             state = 0xDA;
  711.             break;
  712.         case 0xD9:
  713.             if (state != 0xDA)
  714.                 return 0;
  715.             state = 0xD9;
  716.             break;
  717.         default:
  718.             if (  (c >= 0x02 && c <= 0xBF)
  719.                 || c == 0xC8)
  720.                 return 0;
  721.         }
  722.     }
  723.  
  724.     if (state == 0xD9)
  725.         return AVPROBE_SCORE_EXTENSION + 1;
  726.     return AVPROBE_SCORE_EXTENSION / 8;
  727. }
  728.  
  729. static int jpegls_probe(AVProbeData *p)
  730. {
  731.     const uint8_t *b = p->buf;
  732.  
  733.     if (AV_RB32(b) == 0xffd8fff7)
  734.          return AVPROBE_SCORE_EXTENSION + 1;
  735.     return 0;
  736. }
  737.  
  738. static int qdraw_probe(AVProbeData *p)
  739. {
  740.     const uint8_t *b = p->buf;
  741.  
  742.     if (   p->buf_size >= 528
  743.         && (AV_RB64(b + 520) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
  744.         && AV_RB16(b + 520)
  745.         && AV_RB16(b + 518))
  746.         return AVPROBE_SCORE_MAX * 3 / 4;
  747.     if (   (AV_RB64(b + 8) & 0xFFFFFFFFFFFF) == 0x001102ff0c00
  748.         && AV_RB16(b + 8)
  749.         && AV_RB16(b + 6))
  750.         return AVPROBE_SCORE_EXTENSION / 4;
  751.     return 0;
  752. }
  753.  
  754. static int pictor_probe(AVProbeData *p)
  755. {
  756.     const uint8_t *b = p->buf;
  757.  
  758.     if (AV_RL16(b) == 0x1234)
  759.         return AVPROBE_SCORE_EXTENSION / 4;
  760.     return 0;
  761. }
  762.  
  763. static int png_probe(AVProbeData *p)
  764. {
  765.     const uint8_t *b = p->buf;
  766.  
  767.     if (AV_RB64(b) == 0x89504e470d0a1a0a)
  768.         return AVPROBE_SCORE_MAX - 1;
  769.     return 0;
  770. }
  771.  
  772. static int sgi_probe(AVProbeData *p)
  773. {
  774.     const uint8_t *b = p->buf;
  775.  
  776.     if (AV_RB16(b) == 474 &&
  777.         (b[2] & ~1) == 0 &&
  778.         (b[3] & ~3) == 0 && b[3] &&
  779.         (AV_RB16(b + 4) & ~7) == 0 && AV_RB16(b + 4))
  780.         return AVPROBE_SCORE_EXTENSION + 1;
  781.     return 0;
  782. }
  783.  
  784. static int sunrast_probe(AVProbeData *p)
  785. {
  786.     const uint8_t *b = p->buf;
  787.  
  788.     if (AV_RB32(b) == 0x59a66a95)
  789.         return AVPROBE_SCORE_EXTENSION + 1;
  790.     return 0;
  791. }
  792.  
  793. static int tiff_probe(AVProbeData *p)
  794. {
  795.     const uint8_t *b = p->buf;
  796.  
  797.     if (AV_RB32(b) == 0x49492a00 ||
  798.         AV_RB32(b) == 0x4D4D002a)
  799.         return AVPROBE_SCORE_EXTENSION + 1;
  800.     return 0;
  801. }
  802.  
  803. static int webp_probe(AVProbeData *p)
  804. {
  805.     const uint8_t *b = p->buf;
  806.  
  807.     if (AV_RB32(b)     == 0x52494646 &&
  808.         AV_RB32(b + 8) == 0x57454250)
  809.         return AVPROBE_SCORE_MAX - 1;
  810.     return 0;
  811. }
  812.  
  813. #define IMAGEAUTO_DEMUXER(imgname, codecid)\
  814. static const AVClass imgname ## _class = {\
  815.     .class_name = AV_STRINGIFY(imgname) " demuxer",\
  816.     .item_name  = av_default_item_name,\
  817.     .option     = ff_img_options,\
  818.     .version    = LIBAVUTIL_VERSION_INT,\
  819. };\
  820. AVInputFormat ff_image_ ## imgname ## _pipe_demuxer = {\
  821.     .name           = AV_STRINGIFY(imgname) "_pipe",\
  822.     .long_name      = NULL_IF_CONFIG_SMALL("piped " AV_STRINGIFY(imgname) " sequence"),\
  823.     .priv_data_size = sizeof(VideoDemuxData),\
  824.     .read_probe     = imgname ## _probe,\
  825.     .read_header    = ff_img_read_header,\
  826.     .read_packet    = ff_img_read_packet,\
  827.     .priv_class     = & imgname ## _class,\
  828.     .flags          = AVFMT_GENERIC_INDEX, \
  829.     .raw_codec_id   = codecid,\
  830. };
  831.  
  832. IMAGEAUTO_DEMUXER(bmp,     AV_CODEC_ID_BMP)
  833. IMAGEAUTO_DEMUXER(dds,     AV_CODEC_ID_DDS)
  834. IMAGEAUTO_DEMUXER(dpx,     AV_CODEC_ID_DPX)
  835. IMAGEAUTO_DEMUXER(exr,     AV_CODEC_ID_EXR)
  836. IMAGEAUTO_DEMUXER(j2k,     AV_CODEC_ID_JPEG2000)
  837. IMAGEAUTO_DEMUXER(jpeg,    AV_CODEC_ID_MJPEG)
  838. IMAGEAUTO_DEMUXER(jpegls,  AV_CODEC_ID_JPEGLS)
  839. IMAGEAUTO_DEMUXER(pictor,  AV_CODEC_ID_PICTOR)
  840. IMAGEAUTO_DEMUXER(png,     AV_CODEC_ID_PNG)
  841. IMAGEAUTO_DEMUXER(qdraw,   AV_CODEC_ID_QDRAW)
  842. IMAGEAUTO_DEMUXER(sgi,     AV_CODEC_ID_SGI)
  843. IMAGEAUTO_DEMUXER(sunrast, AV_CODEC_ID_SUNRAST)
  844. IMAGEAUTO_DEMUXER(tiff,    AV_CODEC_ID_TIFF)
  845. IMAGEAUTO_DEMUXER(webp,    AV_CODEC_ID_WEBP)
  846.