source/blender/imbuf/intern/util.c

   1 /*
   2  *
   3  * ***** BEGIN GPL LICENSE BLOCK *****
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (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 Foundation,
  17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  20  * All rights reserved.
  21  *
  22  * The Original Code is: all of this file.
  23  *
  24  * Contributor(s): none yet.
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  * util.c
  28  *
  29  * $Id$
  30  */
  31
  32 /** \file blender/imbuf/intern/util.c
  33  *  \ingroup imbuf
  34  */
  35
  36
  37 #ifdef _WIN32
  38 #include <io.h>
  39 #define open _open
  40 #define read _read
  41 #define close _close
  42 #endif
  43
  44 #include "BLI_blenlib.h"
  45
  46 #include "DNA_userdef_types.h"
  47 #include "BKE_global.h"
  48
  49 #include "imbuf.h"
  50 #include "IMB_imbuf_types.h"
  51 #include "IMB_imbuf.h"
  52 #include "IMB_filetype.h"
  53
  54 #include "IMB_anim.h"
  55
  56 #ifdef WITH_QUICKTIME
  57 #include "quicktime_import.h"
  58 #endif
  59
  60 #ifdef WITH_FFMPEG
  61 #include <libavcodec/avcodec.h>
  62 #include <libavformat/avformat.h>
  63 #include <libavdevice/avdevice.h>
  64 #include <libavutil/log.h>
  65
  66 #if (LIBAVFORMAT_VERSION_MAJOR > 52) || ((LIBAVFORMAT_VERSION_MAJOR >= 52) && (LIBAVFORMAT_VERSION_MINOR >= 101))
  67 #define FFMPEG_HAVE_AV_DUMP_FORMAT 1
  68 #endif
  69
  70 #ifndef FFMPEG_HAVE_AV_DUMP_FORMAT
  71 #define av_dump_format dump_format
  72 #endif
  73
  74 #endif
  75
  76 #define UTIL_DEBUG 0
  77
  78 const char *imb_ext_image[] = {
  79         ".png",
  80         ".tga",
  81         ".bmp",
  82         ".jpg", ".jpeg",
  83         ".sgi", ".rgb", ".rgba",
  84 #ifdef WITH_TIFF
  85         ".tif", ".tiff", ".tx",
  86 #endif
  87 #ifdef WITH_OPENJPEG
  88         ".jp2",
  89 #endif
  90 #ifdef WITH_HDR
  91         ".hdr",
  92 #endif
  93 #ifdef WITH_DDS
  94         ".dds",
  95 #endif
  96 #ifdef WITH_CINEON
  97         ".dpx",
  98         ".cin",
  99 #endif
 100 #ifdef WITH_OPENEXR
 101         ".exr",
 102 #endif
 103         NULL};
 104
 105 const char *imb_ext_image_qt[] = {
 106         ".gif",
 107         ".psd",
 108         ".pct", ".pict",
 109         ".pntg",
 110         ".qtif",
 111         NULL};
 112
 113 const char *imb_ext_movie[] = {
 114         ".avi",
 115         ".flc",
 116         ".mov",
 117         ".movie",
 118         ".mp4",
 119         ".m4v",
 120         ".m2v",
 121         ".m2t",
 122         ".mts",
 123         ".mv",
 124         ".avs",
 125         ".wmv",
 126         ".ogv",
 127         ".dv",
 128         ".mpeg",
 129         ".mpg",
 130         ".mpg2",
 131         ".vob",
 132         ".mkv",
 133         ".flv",
 134         ".divx",
 135         ".xvid",
 136         ".mxf",
 137         NULL};
 138
 139 /* sort of wrong being here... */
 140 const char *imb_ext_audio[] = {
 141         ".wav",
 142         ".ogg",
 143         ".oga",
 144         ".mp3",
 145         ".mp2",
 146         ".ac3",
 147         ".aac",
 148         ".flac",
 149         ".wma",
 150         ".eac3",
 151         NULL};
 152
 153 static int IMB_ispic_name(const char *name)
 154 {
 155         ImFileType *type;
 156         struct stat st;
 157         int fp, buf[10];
 158
 159         if(UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
 160
 161         if(stat(name,&st) == -1)
 162                 return FALSE;
 163         if(((st.st_mode) & S_IFMT) != S_IFREG)
 164                 return FALSE;
 165
 166         if((fp = open(name,O_BINARY|O_RDONLY)) < 0)
 167                 return FALSE;
 168
 169         if(read(fp, buf, 32) != 32) {
 170                 close(fp);
 171                 return FALSE;
 172         }
 173
 174         close(fp);
 175
 176         /* XXX move this exception */
 177         if((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
 178                 return JPG;
 179
 180         for(type=IMB_FILE_TYPES; type->is_a; type++)
 181                 if(type->is_a((uchar*)buf))
 182                         return type->filetype;
 183
 184         return FALSE;
 185 }
 186
 187 int IMB_ispic(const char *filename)
 188 {
 189         if(U.uiflag & USER_FILTERFILEEXTS) {
 190                 if(     (BLI_testextensie_array(filename, imb_ext_image)) ||
 191                         (G.have_quicktime && BLI_testextensie_array(filename, imb_ext_image_qt))
 192                 ) {
 193                         return IMB_ispic_name(filename);
 194                 }
 195                 else  {
 196                         return FALSE;
 197                 }
 198         }
 199         else { /* no FILTERFILEEXTS */
 200                 return IMB_ispic_name(filename);
 201         }
 202 }
 203
 204
 205
 206 static int isavi (const char *name) {
 207         return AVI_is_avi (name);
 208 }
 209
 210 #ifdef WITH_QUICKTIME
 211 static int isqtime (const char *name) {
 212         return anim_is_quicktime (name);
 213 }
 214 #endif
 215
 216 #ifdef WITH_FFMPEG
 217
 218 void silence_log_ffmpeg(int quiet)
 219 {
 220         if (quiet)
 221         {
 222                 av_log_set_level(AV_LOG_QUIET);
 223         }
 224         else
 225         {
 226                 av_log_set_level(AV_LOG_INFO);
 227         }
 228 }
 229
 230 extern void do_init_ffmpeg(void);
 231 void do_init_ffmpeg(void)
 232 {
 233         static int ffmpeg_init = 0;
 234         if (!ffmpeg_init) {
 235                 ffmpeg_init = 1;
 236                 av_register_all();
 237                 avdevice_register_all();
 238
 239                 if ((G.f & G_DEBUG) == 0)
 240                 {
 241                         silence_log_ffmpeg(1);
 242                 }
 243         }
 244 }
 245
 246 static int isffmpeg (const char *filename) {
 247         AVFormatContext *pFormatCtx;
 248         unsigned int i;
 249         int videoStream;
 250         AVCodec *pCodec;
 251         AVCodecContext *pCodecCtx;
 252
 253         do_init_ffmpeg();
 254
 255         if( BLI_testextensie(filename, ".swf") ||
 256                 BLI_testextensie(filename, ".jpg") ||
 257                 BLI_testextensie(filename, ".png") ||
 258                 BLI_testextensie(filename, ".dds") ||
 259                 BLI_testextensie(filename, ".tga") ||
 260                 BLI_testextensie(filename, ".bmp") ||
 261                 BLI_testextensie(filename, ".exr") ||
 262                 BLI_testextensie(filename, ".cin") ||
 263                 BLI_testextensie(filename, ".wav")) return 0;
 264
 265         if(av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL)!=0) {
 266                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
 267                 return 0;
 268         }
 269
 270         if(av_find_stream_info(pFormatCtx)<0) {
 271                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_find_stream_info failed\n");
 272                 av_close_input_file(pFormatCtx);
 273                 return 0;
 274         }
 275
 276         if(UTIL_DEBUG) av_dump_format(pFormatCtx, 0, filename, 0);
 277
 278
 279                 /* Find the first video stream */
 280         videoStream=-1;
 281         for(i=0; i<pFormatCtx->nb_streams; i++)
 282                 if(pFormatCtx->streams[i] &&
 283                    pFormatCtx->streams[i]->codec &&
 284                   (pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO))
 285                 {
 286                         videoStream=i;
 287                         break;
 288                 }
 289
 290         if(videoStream==-1) {
 291                 av_close_input_file(pFormatCtx);
 292                 return 0;
 293         }
 294
 295         pCodecCtx = pFormatCtx->streams[videoStream]->codec;
 296
 297                 /* Find the decoder for the video stream */
 298         pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
 299         if(pCodec==NULL) {
 300                 av_close_input_file(pFormatCtx);
 301                 return 0;
 302         }
 303
 304         if(avcodec_open(pCodecCtx, pCodec)<0) {
 305                 av_close_input_file(pFormatCtx);
 306                 return 0;
 307         }
 308
 309         avcodec_close(pCodecCtx);
 310         av_close_input_file(pFormatCtx);
 311
 312         return 1;
 313 }
 314 #endif
 315
 316 #ifdef WITH_REDCODE
 317 static int isredcode(const char * filename)
 318 {
 319         struct redcode_handle * h = redcode_open(filename);
 320         if (!h) {
 321                 return 0;
 322         }
 323         redcode_close(h);
 324         return 1;
 325 }
 326
 327 #endif
 328
 329 int imb_get_anim_type(const char * name) {
 330         int type;
 331         struct stat st;
 332
 333         if(UTIL_DEBUG) printf("in getanimtype: %s\n", name);
 334
 335 #ifndef _WIN32
 336 #       ifdef WITH_QUICKTIME
 337         if (isqtime(name)) return (ANIM_QTIME);
 338 #       endif
 339 #       ifdef WITH_FFMPEG
 340         /* stat test below fails on large files > 4GB */
 341         if (isffmpeg(name)) return (ANIM_FFMPEG);
 342 #       endif
 343         if (stat(name,&st) == -1) return(0);
 344         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
 345
 346         if (isavi(name)) return (ANIM_AVI);
 347
 348         if (ismovie(name)) return (ANIM_MOVIE);
 349 #else
 350         if (stat(name,&st) == -1) return(0);
 351         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
 352
 353         if (ismovie(name)) return (ANIM_MOVIE);
 354 #       ifdef WITH_QUICKTIME
 355         if (isqtime(name)) return (ANIM_QTIME);
 356 #       endif
 357 #       ifdef WITH_FFMPEG
 358         if (isffmpeg(name)) return (ANIM_FFMPEG);
 359 #       endif
 360         if (isavi(name)) return (ANIM_AVI);
 361 #endif
 362 #ifdef WITH_REDCODE
 363         if (isredcode(name)) return (ANIM_REDCODE);
 364 #endif
 365         type = IMB_ispic(name);
 366         if (type) return(ANIM_SEQUENCE);
 367         return(0);
 368 }
 369
 370 int IMB_isanim(const char *filename) {
 371         int type;
 372
 373         if(U.uiflag & USER_FILTERFILEEXTS) {
 374                 if (G.have_quicktime){
 375                         if(             BLI_testextensie(filename, ".avi")
 376                                 ||      BLI_testextensie(filename, ".flc")
 377                                 ||      BLI_testextensie(filename, ".dv")
 378                                 ||      BLI_testextensie(filename, ".r3d")
 379                                 ||      BLI_testextensie(filename, ".mov")
 380                                 ||      BLI_testextensie(filename, ".movie")
 381                                 ||      BLI_testextensie(filename, ".mv")) {
 382                                 type = imb_get_anim_type(filename);
 383                         } else {
 384                                 return(FALSE);
 385                         }
 386                 } else { // no quicktime
 387                         if(             BLI_testextensie(filename, ".avi")
 388                                 ||      BLI_testextensie(filename, ".dv")
 389                                 ||      BLI_testextensie(filename, ".r3d")
 390                                 ||      BLI_testextensie(filename, ".mv")) {
 391                                 type = imb_get_anim_type(filename);
 392                         }
 393                         else  {
 394                                 return(FALSE);
 395                         }
 396                 }
 397         } else { // no FILTERFILEEXTS
 398                 type = imb_get_anim_type(filename);
 399         }
 400
 401         return (type && type!=ANIM_SEQUENCE);
 402 }