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 48static 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 60static 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 75static 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 */ 105static 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 154fail: 155 return -1; 156} 157 158static 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 (av_match_ext(p->filename, "raw") || av_match_ext(p->filename, "gif")) 166 return 5; 167 else 168 return AVPROBE_SCORE_EXTENSION; 169 } 170 return 0; 171} 172 173int ff_img_read_header(AVFormatContext *s1) 174{ 175 VideoDemuxData *s = s1->priv_data; 176 int first_index, last_index; 177 AVStream *st; 178 enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE; 179 180 s1->ctx_flags |= AVFMTCTX_NOHEADER; 181 182 st = avformat_new_stream(s1, NULL); 183 if (!st) { 184 return AVERROR(ENOMEM); 185 } 186 187 if (s->pixel_format && 188 (pix_fmt = av_get_pix_fmt(s->pixel_format)) == AV_PIX_FMT_NONE) { 189 av_log(s1, AV_LOG_ERROR, "No such pixel format: %s.\n", 190 s->pixel_format); 191 return AVERROR(EINVAL); 192 } 193 194 av_strlcpy(s->path, s1->filename, sizeof(s->path)); 195 s->img_number = 0; 196 s->img_count = 0; 197 198 /* find format */ 199 if (s1->iformat->flags & AVFMT_NOFILE) 200 s->is_pipe = 0; 201 else { 202 s->is_pipe = 1; 203 st->need_parsing = AVSTREAM_PARSE_FULL; 204 } 205 206 if (s->ts_from_file == 2) { 207#if !HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC 208 av_log(s1, AV_LOG_ERROR, "POSIX.1-2008 not supported, nanosecond file timestamps unavailable\n"); 209 return AVERROR(ENOSYS); 210#endif 211 avpriv_set_pts_info(st, 64, 1, 1000000000); 212 } else if (s->ts_from_file) 213 avpriv_set_pts_info(st, 64, 1, 1); 214 else 215 avpriv_set_pts_info(st, 64, s->framerate.den, s->framerate.num); 216 217 if (s->width && s->height) { 218 st->codec->width = s->width; 219 st->codec->height = s->height; 220 } 221 222 if (!s->is_pipe) { 223 if (s->pattern_type == PT_GLOB_SEQUENCE) { 224 s->use_glob = is_glob(s->path); 225 if (s->use_glob) { 226 char *p = s->path, *q, *dup; 227 int gerr; 228 229 av_log(s1, AV_LOG_WARNING, "Pattern type 'glob_sequence' is deprecated: " 230 "use pattern_type 'glob' instead\n"); 231#if HAVE_GLOB 232 dup = q = av_strdup(p); 233 while (*q) { 234 /* Do we have room for the next char and a \ insertion? */ 235 if ((p - s->path) >= (sizeof(s->path) - 2)) 236 break; 237 if (*q == '%' && strspn(q + 1, "%*?[]{}")) 238 ++q; 239 else if (strspn(q, "\\*?[]{}")) 240 *p++ = '\\'; 241 *p++ = *q++; 242 } 243 *p = 0; 244 av_free(dup); 245 246 gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate); 247 if (gerr != 0) { 248 return AVERROR(ENOENT); 249 } 250 first_index = 0; 251 last_index = s->globstate.gl_pathc - 1; 252#endif 253 } 254 } 255 if ((s->pattern_type == PT_GLOB_SEQUENCE && !s->use_glob) || s->pattern_type == PT_SEQUENCE) { 256 if (find_image_range(&first_index, &last_index, s->path, 257 s->start_number, s->start_number_range) < 0) { 258 av_log(s1, AV_LOG_ERROR, 259 "Could find no file with path '%s' and index in the range %d-%d\n", 260 s->path, s->start_number, s->start_number + s->start_number_range - 1); 261 return AVERROR(ENOENT); 262 } 263 } else if (s->pattern_type == PT_GLOB) { 264#if HAVE_GLOB 265 int gerr; 266 gerr = glob(s->path, GLOB_NOCHECK|GLOB_BRACE|GLOB_NOMAGIC, NULL, &s->globstate); 267 if (gerr != 0) { 268 return AVERROR(ENOENT); 269 } 270 first_index = 0; 271 last_index = s->globstate.gl_pathc - 1; 272 s->use_glob = 1; 273#else 274 av_log(s1, AV_LOG_ERROR, 275 "Pattern type 'glob' was selected but globbing " 276 "is not supported by this libavformat build\n"); 277 return AVERROR(ENOSYS); 278#endif 279 } else if (s->pattern_type != PT_GLOB_SEQUENCE) { 280 av_log(s1, AV_LOG_ERROR, 281 "Unknown value '%d' for pattern_type option\n", s->pattern_type); 282 return AVERROR(EINVAL); 283 } 284 s->img_first = first_index; 285 s->img_last = last_index; 286 s->img_number = first_index; 287 /* compute duration */ 288 if (!s->ts_from_file) { 289 st->start_time = 0; 290 st->duration = last_index - first_index + 1; 291 } 292 } 293 294 if (s1->video_codec_id) { 295 st->codec->codec_type = AVMEDIA_TYPE_VIDEO; 296 st->codec->codec_id = s1->video_codec_id; 297 } else if (s1->audio_codec_id) { 298 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; 299 st->codec->codec_id = s1->audio_codec_id; 300 } else if (s1->iformat->raw_codec_id) { 301 st->codec->codec_type = AVMEDIA_TYPE_VIDEO; 302 st->codec->codec_id = s1->iformat->raw_codec_id; 303 } else { 304 const char *str = strrchr(s->path, '.'); 305 s->split_planes = str && !av_strcasecmp(str + 1, "y"); 306 st->codec->codec_type = AVMEDIA_TYPE_VIDEO; 307 if (s1->pb) { 308 int probe_buffer_size = 2048; 309 uint8_t *probe_buffer = av_realloc(NULL, probe_buffer_size + AVPROBE_PADDING_SIZE); 310 AVInputFormat *fmt = NULL; 311 AVProbeData pd; 312 313 if (!probe_buffer) 314 return AVERROR(ENOMEM); 315 316 probe_buffer_size = avio_read(s1->pb, probe_buffer, probe_buffer_size); 317 if (probe_buffer_size < 0) { 318 av_free(probe_buffer); 319 return probe_buffer_size; 320 } 321 memset(probe_buffer + probe_buffer_size, 0, AVPROBE_PADDING_SIZE); 322 323 pd.buf = probe_buffer; 324 pd.buf_size = probe_buffer_size; 325 pd.filename = s1->filename; 326 327 while ((fmt = av_iformat_next(fmt))) { 328 if (fmt->read_header != ff_img_read_header || 329 !fmt->read_probe || 330 (fmt->flags & AVFMT_NOFILE) || 331 !fmt->raw_codec_id) 332 continue; 333 if (fmt->read_probe(&pd) > 0) { 334 st->codec->codec_id = fmt->raw_codec_id; 335 break; 336 } 337 } 338 ffio_rewind_with_probe_data(s1->pb, &probe_buffer, probe_buffer_size); 339 } 340 if (st->codec->codec_id == AV_CODEC_ID_NONE) 341 st->codec->codec_id = ff_guess_image2_codec(s->path); 342 if (st->codec->codec_id == AV_CODEC_ID_LJPEG) 343 st->codec->codec_id = AV_CODEC_ID_MJPEG; 344 if (st->codec->codec_id == AV_CODEC_ID_ALIAS_PIX) // we cannot distingiush this from BRENDER_PIX 345 st->codec->codec_id = AV_CODEC_ID_NONE; 346 } 347 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && 348 pix_fmt != AV_PIX_FMT_NONE) 349 st->codec->pix_fmt = pix_fmt; 350 351 return 0; 352} 353 354int ff_img_read_packet(AVFormatContext *s1, AVPacket *pkt) 355{ 356 VideoDemuxData *s = s1->priv_data; 357 char filename_bytes[1024]; 358 char *filename = filename_bytes; 359 int i; 360 int size[3] = { 0 }, ret[3] = { 0 }; 361 AVIOContext *f[3] = { NULL }; 362 AVCodecContext *codec = s1->streams[0]->codec; 363 364 if (!s->is_pipe) { 365 /* loop over input */ 366 if (s->loop && s->img_number > s->img_last) { 367 s->img_number = s->img_first; 368 } 369 if (s->img_number > s->img_last) 370 return AVERROR_EOF; 371 if (s->use_glob) { 372#if HAVE_GLOB 373 filename = s->globstate.gl_pathv[s->img_number]; 374#endif 375 } else { 376 if (av_get_frame_filename(filename_bytes, sizeof(filename_bytes), 377 s->path, 378 s->img_number) < 0 && s->img_number > 1) 379 return AVERROR(EIO); 380 } 381 for (i = 0; i < 3; i++) { 382 if (avio_open2(&f[i], filename, AVIO_FLAG_READ, 383 &s1->interrupt_callback, NULL) < 0) { 384 if (i >= 1) 385 break; 386 av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n", 387 filename); 388 return AVERROR(EIO); 389 } 390 size[i] = avio_size(f[i]); 391 392 if (!s->split_planes) 393 break; 394 filename[strlen(filename) - 1] = 'U' + i; 395 } 396 397 if (codec->codec_id == AV_CODEC_ID_NONE) { 398 AVProbeData pd; 399 AVInputFormat *ifmt; 400 uint8_t header[PROBE_BUF_MIN + AVPROBE_PADDING_SIZE]; 401 int ret; 402 int score = 0; 403 404 ret = avio_read(f[0], header, PROBE_BUF_MIN); 405 if (ret < 0) 406 return ret; 407 memset(header + ret, 0, sizeof(header) - ret); 408 avio_skip(f[0], -ret); 409 pd.buf = header; 410 pd.buf_size = ret; 411 pd.filename = filename; 412 413 ifmt = av_probe_input_format3(&pd, 1, &score); 414 if (ifmt && ifmt->read_packet == ff_img_read_packet && ifmt->raw_codec_id) 415 codec->codec_id = ifmt->raw_codec_id; 416 } 417 418 if (codec->codec_id == AV_CODEC_ID_RAWVIDEO && !codec->width) 419 infer_size(&codec->width, &codec->height, size[0]); 420 } else { 421 f[0] = s1->pb; 422 if (url_feof(f[0])) 423 return AVERROR(EIO); 424 if (s->frame_size > 0) { 425 size[0] = s->frame_size; 426 } else if (!s1->streams[0]->parser) { 427 size[0] = avio_size(s1->pb); 428 } else { 429 size[0] = 4096; 430 } 431 } 432 433 if (av_new_packet(pkt, size[0] + size[1] + size[2]) < 0) 434 return AVERROR(ENOMEM); 435 pkt->stream_index = 0; 436 pkt->flags |= AV_PKT_FLAG_KEY; 437 if (s->ts_from_file) { 438 struct stat img_stat; 439 if (stat(filename, &img_stat)) 440 return AVERROR(EIO); 441 pkt->pts = (int64_t)img_stat.st_mtime; 442#if HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC 443 if (s->ts_from_file == 2) 444 pkt->pts = 1000000000*pkt->pts + img_stat.st_mtim.tv_nsec; 445#endif 446 av_add_index_entry(s1->streams[0], s->img_number, pkt->pts, 0, 0, AVINDEX_KEYFRAME); 447 } else if (!s->is_pipe) { 448 pkt->pts = s->pts; 449 } 450 451 pkt->size = 0; 452 for (i = 0; i < 3; i++) { 453 if (f[i]) { 454 ret[i] = avio_read(f[i], pkt->data + pkt->size, size[i]); 455 if (!s->is_pipe) 456 avio_close(f[i]); 457 if (ret[i] > 0) 458 pkt->size += ret[i]; 459 } 460 } 461 462 if (ret[0] <= 0 || ret[1] < 0 || ret[2] < 0) { 463 av_free_packet(pkt); 464 return AVERROR(EIO); /* signal EOF */ 465 } else { 466 s->img_count++; 467 s->img_number++; 468 s->pts++; 469 return 0; 470 } 471} 472 473static int img_read_close(struct AVFormatContext* s1) 474{ 475 VideoDemuxData *s = s1->priv_data; 476#if HAVE_GLOB 477 if (s->use_glob) { 478 globfree(&s->globstate); 479 } 480#endif 481 return 0; 482} 483 484static int img_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) 485{ 486 VideoDemuxData *s1 = s->priv_data; 487 AVStream *st = s->streams[0]; 488 489 if (s1->ts_from_file) { 490 int index = av_index_search_timestamp(st, timestamp, flags); 491 if(index < 0) 492 return -1; 493 s1->img_number = st->index_entries[index].pos; 494 return 0; 495 } 496 497 if (timestamp < 0 || !s1->loop && timestamp > s1->img_last - s1->img_first) 498 return -1; 499 s1->img_number = timestamp%(s1->img_last - s1->img_first + 1) + s1->img_first; 500 s1->pts = timestamp; 501 return 0; 502} 503 504#define OFFSET(x) offsetof(VideoDemuxData, x) 505#define DEC AV_OPT_FLAG_DECODING_PARAM 506static const AVOption options[] = { 507 { "framerate", "set the video framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, DEC }, 508 { "loop", "force loop over input file sequence", OFFSET(loop), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, DEC }, 509 510 { "pattern_type", "set pattern type", OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_GLOB_SEQUENCE}, 0, INT_MAX, DEC, "pattern_type"}, 511 { "glob_sequence","select glob/sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" }, 512 { "glob", "select glob pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB }, INT_MIN, INT_MAX, DEC, "pattern_type" }, 513 { "sequence", "select sequence pattern type", 0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE }, INT_MIN, INT_MAX, DEC, "pattern_type" }, 514 515 { "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, 516 { "start_number", "set first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC }, 517 { "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 }, 518 { "video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC }, 519 { "frame_size", "force frame size in bytes", OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC }, 520 { "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" }, 521 { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 2, DEC, "ts_type" }, 522 { "sec", "second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 2, DEC, "ts_type" }, 523 { "ns", "nano second precision", 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 2, DEC, "ts_type" }, 524 { NULL }, 525}; 526 527#if CONFIG_IMAGE2_DEMUXER 528static const AVClass img2_class = { 529 .class_name = "image2 demuxer", 530 .item_name = av_default_item_name, 531 .option = options, 532 .version = LIBAVUTIL_VERSION_INT, 533}; 534AVInputFormat ff_image2_demuxer = { 535 .name = "image2", 536 .long_name = NULL_IF_CONFIG_SMALL("image2 sequence"), 537 .priv_data_size = sizeof(VideoDemuxData), 538 .read_probe = img_read_probe, 539 .read_header = ff_img_read_header, 540 .read_packet = ff_img_read_packet, 541 .read_close = img_read_close, 542 .read_seek = img_read_seek, 543 .flags = AVFMT_NOFILE, 544 .priv_class = &img2_class, 545}; 546#endif 547#if CONFIG_IMAGE2PIPE_DEMUXER 548static const AVClass img2pipe_class = { 549 .class_name = "image2pipe demuxer", 550 .item_name = av_default_item_name, 551 .option = options, 552 .version = LIBAVUTIL_VERSION_INT, 553}; 554AVInputFormat ff_image2pipe_demuxer = { 555 .name = "image2pipe", 556 .long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"), 557 .priv_data_size = sizeof(VideoDemuxData), 558 .read_header = ff_img_read_header, 559 .read_packet = ff_img_read_packet, 560 .priv_class = &img2pipe_class, 561}; 562#endif 563 564static int bmp_probe(AVProbeData *p) 565{ 566 const uint8_t *b = p->buf; 567 int ihsize; 568 569 if (AV_RB16(b) != 0x424d) 570 return 0; 571 572 ihsize = AV_RL32(b+14); 573 if (ihsize < 12 || ihsize > 255) 574 return 0; 575 576 if (!AV_RN32(b + 6)) { 577 return AVPROBE_SCORE_EXTENSION + 1; 578 } else { 579 return AVPROBE_SCORE_EXTENSION / 4; 580 } 581 return 0; 582} 583 584static int dpx_probe(AVProbeData *p) 585{ 586 const uint8_t *b = p->buf; 587 588 if (AV_RN32(b) == AV_RN32("SDPX") || AV_RN32(b) == AV_RN32("XPDS")) 589 return AVPROBE_SCORE_EXTENSION + 1; 590 return 0; 591} 592 593static int exr_probe(AVProbeData *p) 594{ 595 const uint8_t *b = p->buf; 596 597 if (AV_RL32(b) == 20000630) 598 return AVPROBE_SCORE_EXTENSION + 1; 599 return 0; 600} 601 602static int j2k_probe(AVProbeData *p) 603{ 604 const uint8_t *b = p->buf; 605 606 if (AV_RB64(b) == 0x0000000c6a502020 || 607 AV_RB32(b) == 0xff4fff51) 608 return AVPROBE_SCORE_EXTENSION + 1; 609 return 0; 610} 611 612static int pictor_probe(AVProbeData *p) 613{ 614 const uint8_t *b = p->buf; 615 616 if (AV_RL16(b) == 0x1234) 617 return AVPROBE_SCORE_EXTENSION / 4; 618 return 0; 619} 620 621static int png_probe(AVProbeData *p) 622{ 623 const uint8_t *b = p->buf; 624 625 if (AV_RB64(b) == 0x89504e470d0a1a0a) 626 return AVPROBE_SCORE_MAX - 1; 627 return 0; 628} 629 630static int sgi_probe(AVProbeData *p) 631{ 632 const uint8_t *b = p->buf; 633 634 if (AV_RB16(b) == 474 && 635 (b[2] & ~1) == 0 && 636 (b[3] & ~3) == 0 && b[3] && 637 (AV_RB16(b + 4) & ~7) == 0 && AV_RB16(b + 4)) 638 return AVPROBE_SCORE_EXTENSION + 1; 639 return 0; 640} 641 642static int sunrast_probe(AVProbeData *p) 643{ 644 const uint8_t *b = p->buf; 645 646 if (AV_RB32(b) == 0x59a66a95) 647 return AVPROBE_SCORE_EXTENSION + 1; 648 return 0; 649} 650 651static int tiff_probe(AVProbeData *p) 652{ 653 const uint8_t *b = p->buf; 654 655 if (AV_RB32(b) == 0x49492a00) 656 return AVPROBE_SCORE_EXTENSION + 1; 657 return 0; 658} 659 660#define IMAGEAUTO_DEMUXER(imgname, codecid)\ 661static const AVClass imgname ## _class = {\ 662 .class_name = AV_STRINGIFY(imgname) " demuxer",\ 663 .item_name = av_default_item_name,\ 664 .option = options,\ 665 .version = LIBAVUTIL_VERSION_INT,\ 666};\ 667AVInputFormat ff_image_ ## imgname ## _pipe_demuxer = {\ 668 .name = AV_STRINGIFY(imgname) "_pipe",\ 669 .long_name = NULL_IF_CONFIG_SMALL("piped " AV_STRINGIFY(imgname) " sequence"),\ 670 .priv_data_size = sizeof(VideoDemuxData),\ 671 .read_probe = imgname ## _probe,\ 672 .read_header = ff_img_read_header,\ 673 .read_packet = ff_img_read_packet,\ 674 .priv_class = & imgname ## _class,\ 675 .raw_codec_id = codecid,\ 676}; 677 678IMAGEAUTO_DEMUXER(bmp, AV_CODEC_ID_BMP) 679IMAGEAUTO_DEMUXER(dpx, AV_CODEC_ID_DPX) 680IMAGEAUTO_DEMUXER(exr, AV_CODEC_ID_EXR) 681IMAGEAUTO_DEMUXER(j2k, AV_CODEC_ID_JPEG2000) 682IMAGEAUTO_DEMUXER(pictor, AV_CODEC_ID_PICTOR) 683IMAGEAUTO_DEMUXER(png, AV_CODEC_ID_PNG) 684IMAGEAUTO_DEMUXER(sgi, AV_CODEC_ID_SGI) 685IMAGEAUTO_DEMUXER(sunrast, AV_CODEC_ID_SUNRAST) 686IMAGEAUTO_DEMUXER(tiff, AV_CODEC_ID_TIFF) 687