source/blender/imbuf/intern/util.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  19  * All rights reserved.
  20  *
  21  * The Original Code is: all of this file.
  22  *
  23  * Contributor(s): none yet.
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  * util.c
  27  *
  28  */
  29
  30 /** \file blender/imbuf/intern/util.c
  31  *  \ingroup imbuf
  32  */
  33
  34
  35 #ifdef _WIN32
  36 #  include <io.h>
  37 #  define open _open
  38 #  define read _read
  39 #  define close _close
  40 #endif
  41
  42 #include <stdlib.h>
  43
  44 #include "BLI_path_util.h"
  45 #include "BLI_fileops.h"
  46 #include "BLI_utildefines.h"
  47 #include "BLI_string.h"
  48
  49 #include "DNA_userdef_types.h"
  50 #include "BKE_global.h"
  51
  52 #include "imbuf.h"
  53 #include "IMB_imbuf_types.h"
  54 #include "IMB_imbuf.h"
  55 #include "IMB_filetype.h"
  56
  57 #include "IMB_anim.h"
  58
  59 #ifdef WITH_QUICKTIME
  60 #include "quicktime_import.h"
  61 #endif
  62
  63 #ifdef WITH_FFMPEG
  64 #include <libavcodec/avcodec.h>
  65 #include <libavformat/avformat.h>
  66 #include <libavdevice/avdevice.h>
  67 #include <libavutil/log.h>
  68
  69 #include "ffmpeg_compat.h"
  70
  71 #endif
  72
  73 #define UTIL_DEBUG 0
  74
  75 const char *imb_ext_image[] = {
  76         ".png",
  77         ".tga",
  78         ".bmp",
  79         ".jpg", ".jpeg",
  80         ".sgi", ".rgb", ".rgba",
  81 #ifdef WITH_TIFF
  82         ".tif", ".tiff", ".tx",
  83 #endif
  84 #ifdef WITH_OPENJPEG
  85         ".jp2",
  86         ".j2c",
  87 #endif
  88 #ifdef WITH_HDR
  89         ".hdr",
  90 #endif
  91 #ifdef WITH_DDS
  92         ".dds",
  93 #endif
  94 #ifdef WITH_CINEON
  95         ".dpx",
  96         ".cin",
  97 #endif
  98 #ifdef WITH_OPENEXR
  99         ".exr",
 100 #endif
 101         NULL
 102 };
 103
 104 const char *imb_ext_image_qt[] = {
 105         ".gif",
 106         ".psd",
 107         ".pct", ".pict",
 108         ".pntg",
 109         ".qtif",
 110         NULL
 111 };
 112
 113 const char *imb_ext_movie[] = {
 114         ".avi",
 115         ".flc",
 116         ".mov",
 117         ".movie",
 118         ".mp4",
 119         ".m4v",
 120         ".m2v",
 121         ".m2t",
 122         ".m2ts",
 123         ".mts",
 124         ".mv",
 125         ".avs",
 126         ".wmv",
 127         ".ogv",
 128         ".dv",
 129         ".mpeg",
 130         ".mpg",
 131         ".mpg2",
 132         ".vob",
 133         ".mkv",
 134         ".flv",
 135         ".divx",
 136         ".xvid",
 137         ".mxf",
 138         NULL
 139 };
 140
 141 /* sort of wrong being here... */
 142 const char *imb_ext_audio[] = {
 143         ".wav",
 144         ".ogg",
 145         ".oga",
 146         ".mp3",
 147         ".mp2",
 148         ".ac3",
 149         ".aac",
 150         ".flac",
 151         ".wma",
 152         ".eac3",
 153         ".aif",
 154         ".aiff",
 155         ".m4a",
 156         NULL
 157 };
 158
 159 static int IMB_ispic_name(const char *name)
 160 {
 161         ImFileType *type;
 162         struct stat st;
 163         int fp, buf[10];
 164
 165         if (UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
 166
 167         if (stat(name, &st) == -1)
 168                 return FALSE;
 169         if (((st.st_mode) & S_IFMT) != S_IFREG)
 170                 return FALSE;
 171
 172         if ((fp = BLI_open(name, O_BINARY | O_RDONLY, 0)) < 0)
 173                 return FALSE;
 174
 175         if (read(fp, buf, 32) != 32) {
 176                 close(fp);
 177                 return FALSE;
 178         }
 179
 180         close(fp);
 181
 182         /* XXX move this exception */
 183         if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
 184                 return JPG;
 185
 186         for (type = IMB_FILE_TYPES; type->is_a; type++)
 187                 if (type->is_a((uchar *)buf))
 188                         return type->filetype;
 189
 190         return FALSE;
 191 }
 192
 193 int IMB_ispic(const char *filename)
 194 {
 195         if (U.uiflag & USER_FILTERFILEEXTS) {
 196                 if ((BLI_testextensie_array(filename, imb_ext_image)) ||
 197                     (G.have_quicktime && BLI_testextensie_array(filename, imb_ext_image_qt)))
 198                 {
 199                         return IMB_ispic_name(filename);
 200                 }
 201                 else {
 202                         return FALSE;
 203                 }
 204         }
 205         else { /* no FILTERFILEEXTS */
 206                 return IMB_ispic_name(filename);
 207         }
 208 }
 209
 210
 211
 212 static int isavi(const char *name)
 213 {
 214 #ifdef WITH_AVI
 215         return AVI_is_avi(name);
 216 #else
 217         (void)name;
 218         return FALSE;
 219 #endif
 220 }
 221
 222 #ifdef WITH_QUICKTIME
 223 static int isqtime(const char *name)
 224 {
 225         return anim_is_quicktime(name);
 226 }
 227 #endif
 228
 229 #ifdef WITH_FFMPEG
 230
 231 #ifdef _MSC_VER
 232 #define va_copy(dst, src) ((dst) = (src))
 233 #endif
 234
 235 /* BLI_vsnprintf in ffmpeg_log_callback() causes invalid warning */
 236 #ifdef __GNUC__
 237 #  pragma GCC diagnostic push
 238 #  pragma GCC diagnostic ignored "-Wmissing-format-attribute"
 239 #endif
 240
 241 static char ffmpeg_last_error[1024];
 242
 243 static void ffmpeg_log_callback(void *ptr, int level, const char *format, va_list arg)
 244 {
 245         if (ELEM(level, AV_LOG_FATAL, AV_LOG_ERROR)) {
 246                 size_t n;
 247                 va_list arg2;
 248
 249                 va_copy(arg2, arg);
 250
 251                 n = BLI_vsnprintf(ffmpeg_last_error, sizeof(ffmpeg_last_error), format, arg2);
 252
 253                 /* strip trailing \n */
 254                 ffmpeg_last_error[n - 1] = '\0';
 255         }
 256
 257         if (G.debug & G_DEBUG_FFMPEG) {
 258                 /* call default logger to print all message to console */
 259                 av_log_default_callback(ptr, level, format, arg);
 260         }
 261 }
 262
 263 #ifdef __GNUC__
 264 #  pragma GCC diagnostic pop
 265 #endif
 266
 267 void IMB_ffmpeg_init(void)
 268 {
 269         av_register_all();
 270         avdevice_register_all();
 271
 272         ffmpeg_last_error[0] = '\0';
 273
 274         /* set own callback which could store last error to report to UI */
 275         av_log_set_callback(ffmpeg_log_callback);
 276 }
 277
 278 const char *IMB_ffmpeg_last_error(void)
 279 {
 280         return ffmpeg_last_error;
 281 }
 282
 283 static int isffmpeg(const char *filename)
 284 {
 285         AVFormatContext *pFormatCtx = NULL;
 286         unsigned int i;
 287         int videoStream;
 288         AVCodec *pCodec;
 289         AVCodecContext *pCodecCtx;
 290
 291         if (BLI_testextensie(filename, ".swf") ||
 292             BLI_testextensie(filename, ".jpg") ||
 293             BLI_testextensie(filename, ".png") ||
 294             BLI_testextensie(filename, ".dds") ||
 295             BLI_testextensie(filename, ".tga") ||
 296             BLI_testextensie(filename, ".bmp") ||
 297             BLI_testextensie(filename, ".exr") ||
 298             BLI_testextensie(filename, ".cin") ||
 299             BLI_testextensie(filename, ".wav"))
 300         {
 301                 return 0;
 302         }
 303
 304         if (avformat_open_input(&pFormatCtx, filename, NULL, NULL) != 0) {
 305                 if (UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
 306                 return 0;
 307         }
 308
 309         if (av_find_stream_info(pFormatCtx) < 0) {
 310                 if (UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_find_stream_info failed\n");
 311                 av_close_input_file(pFormatCtx);
 312                 return 0;
 313         }
 314
 315         if (UTIL_DEBUG) av_dump_format(pFormatCtx, 0, filename, 0);
 316
 317
 318         /* Find the first video stream */
 319         videoStream = -1;
 320         for (i = 0; i < pFormatCtx->nb_streams; i++)
 321                 if (pFormatCtx->streams[i] &&
 322                     pFormatCtx->streams[i]->codec &&
 323                     (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
 324                 {
 325                         videoStream = i;
 326                         break;
 327                 }
 328
 329         if (videoStream == -1) {
 330                 av_close_input_file(pFormatCtx);
 331                 return 0;
 332         }
 333
 334         pCodecCtx = pFormatCtx->streams[videoStream]->codec;
 335
 336         /* Find the decoder for the video stream */
 337         pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
 338         if (pCodec == NULL) {
 339                 av_close_input_file(pFormatCtx);
 340                 return 0;
 341         }
 342
 343         if (avcodec_open(pCodecCtx, pCodec) < 0) {
 344                 av_close_input_file(pFormatCtx);
 345                 return 0;
 346         }
 347
 348         avcodec_close(pCodecCtx);
 349         av_close_input_file(pFormatCtx);
 350
 351         return 1;
 352 }
 353 #endif
 354
 355 #ifdef WITH_REDCODE
 356 static int isredcode(const char *filename)
 357 {
 358         struct redcode_handle *h = redcode_open(filename);
 359         if (!h) {
 360                 return 0;
 361         }
 362         redcode_close(h);
 363         return 1;
 364 }
 365
 366 #endif
 367
 368 int imb_get_anim_type(const char *name)
 369 {
 370         int type;
 371         struct stat st;
 372
 373         if (UTIL_DEBUG) printf("in getanimtype: %s\n", name);
 374
 375 #ifndef _WIN32
 376 #   ifdef WITH_QUICKTIME
 377         if (isqtime(name)) return (ANIM_QTIME);
 378 #   endif
 379 #   ifdef WITH_FFMPEG
 380         /* stat test below fails on large files > 4GB */
 381         if (isffmpeg(name)) return (ANIM_FFMPEG);
 382 #   endif
 383         if (BLI_stat(name, &st) == -1) return(0);
 384         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
 385
 386         if (isavi(name)) return (ANIM_AVI);
 387
 388         if (ismovie(name)) return (ANIM_MOVIE);
 389 #else
 390         if (BLI_stat(name, &st) == -1) return(0);
 391         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
 392
 393         if (ismovie(name)) return (ANIM_MOVIE);
 394 #   ifdef WITH_QUICKTIME
 395         if (isqtime(name)) return (ANIM_QTIME);
 396 #   endif
 397 #   ifdef WITH_FFMPEG
 398         if (isffmpeg(name)) return (ANIM_FFMPEG);
 399 #   endif
 400
 401
 402         if (isavi(name)) return (ANIM_AVI);
 403 #endif
 404 #ifdef WITH_REDCODE
 405         if (isredcode(name)) return (ANIM_REDCODE);
 406 #endif
 407         type = IMB_ispic(name);
 408         if (type) {
 409                 return ANIM_SEQUENCE;
 410         }
 411
 412         return ANIM_NONE;
 413 }
 414
 415 int IMB_isanim(const char *filename)
 416 {
 417         int type;
 418
 419         if (U.uiflag & USER_FILTERFILEEXTS) {
 420                 if (G.have_quicktime) {
 421                         if (BLI_testextensie(filename, ".avi")   ||
 422                             BLI_testextensie(filename, ".flc")   ||
 423                             BLI_testextensie(filename, ".dv")    ||
 424                             BLI_testextensie(filename, ".r3d")   ||
 425                             BLI_testextensie(filename, ".mov")   ||
 426                             BLI_testextensie(filename, ".movie") ||
 427                             BLI_testextensie(filename, ".mv"))
 428                         {
 429                                 type = imb_get_anim_type(filename);
 430                         }
 431                         else {
 432                                 return(FALSE);
 433                         }
 434                 }
 435                 else { /* no quicktime */
 436                         if (BLI_testextensie(filename, ".avi") ||
 437                             BLI_testextensie(filename, ".dv")  ||
 438                             BLI_testextensie(filename, ".r3d") ||
 439                             BLI_testextensie(filename, ".mv"))
 440                         {
 441                                 type = imb_get_anim_type(filename);
 442                         }
 443                         else {
 444                                 return(FALSE);
 445                         }
 446                 }
 447         }
 448         else { /* no FILTERFILEEXTS */
 449                 type = imb_get_anim_type(filename);
 450         }
 451
 452         return (type && type != ANIM_SEQUENCE);
 453 }