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 #include "ffmpeg_compat.h"
  67
  68 #endif
  69
  70 #define UTIL_DEBUG 0
  71
  72 const char *imb_ext_image[] = {
  73         ".png",
  74         ".tga",
  75         ".bmp",
  76         ".jpg", ".jpeg",
  77         ".sgi", ".rgb", ".rgba",
  78 #ifdef WITH_TIFF
  79         ".tif", ".tiff", ".tx",
  80 #endif
  81 #ifdef WITH_OPENJPEG
  82         ".jp2",
  83 #endif
  84 #ifdef WITH_HDR
  85         ".hdr",
  86 #endif
  87 #ifdef WITH_DDS
  88         ".dds",
  89 #endif
  90 #ifdef WITH_CINEON
  91         ".dpx",
  92         ".cin",
  93 #endif
  94 #ifdef WITH_OPENEXR
  95         ".exr",
  96 #endif
  97         NULL};
  98
  99 const char *imb_ext_image_qt[] = {
 100         ".gif",
 101         ".psd",
 102         ".pct", ".pict",
 103         ".pntg",
 104         ".qtif",
 105         NULL};
 106
 107 const char *imb_ext_movie[] = {
 108         ".avi",
 109         ".flc",
 110         ".mov",
 111         ".movie",
 112         ".mp4",
 113         ".m4v",
 114         ".m2v",
 115         ".m2t",
 116         ".mts",
 117         ".mv",
 118         ".avs",
 119         ".wmv",
 120         ".ogv",
 121         ".dv",
 122         ".mpeg",
 123         ".mpg",
 124         ".mpg2",
 125         ".vob",
 126         ".mkv",
 127         ".flv",
 128         ".divx",
 129         ".xvid",
 130         ".mxf",
 131         NULL};
 132
 133 /* sort of wrong being here... */
 134 const char *imb_ext_audio[] = {
 135         ".wav",
 136         ".ogg",
 137         ".oga",
 138         ".mp3",
 139         ".mp2",
 140         ".ac3",
 141         ".aac",
 142         ".flac",
 143         ".wma",
 144         ".eac3",
 145         NULL};
 146
 147 static int IMB_ispic_name(const char *name)
 148 {
 149         ImFileType *type;
 150         struct stat st;
 151         int fp, buf[10];
 152
 153         if(UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
 154
 155         if(stat(name,&st) == -1)
 156                 return FALSE;
 157         if(((st.st_mode) & S_IFMT) != S_IFREG)
 158                 return FALSE;
 159
 160         if((fp = open(name,O_BINARY|O_RDONLY)) < 0)
 161                 return FALSE;
 162
 163         if(read(fp, buf, 32) != 32) {
 164                 close(fp);
 165                 return FALSE;
 166         }
 167
 168         close(fp);
 169
 170         /* XXX move this exception */
 171         if((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
 172                 return JPG;
 173
 174         for(type=IMB_FILE_TYPES; type->is_a; type++)
 175                 if(type->is_a((uchar*)buf))
 176                         return type->filetype;
 177
 178         return FALSE;
 179 }
 180
 181 int IMB_ispic(const char *filename)
 182 {
 183         if(U.uiflag & USER_FILTERFILEEXTS) {
 184                 if(     (BLI_testextensie_array(filename, imb_ext_image)) ||
 185                         (G.have_quicktime && BLI_testextensie_array(filename, imb_ext_image_qt))
 186                 ) {
 187                         return IMB_ispic_name(filename);
 188                 }
 189                 else  {
 190                         return FALSE;
 191                 }
 192         }
 193         else { /* no FILTERFILEEXTS */
 194                 return IMB_ispic_name(filename);
 195         }
 196 }
 197
 198
 199
 200 static int isavi (const char *name) {
 201         return AVI_is_avi (name);
 202 }
 203
 204 #ifdef WITH_QUICKTIME
 205 static int isqtime (const char *name) {
 206         return anim_is_quicktime (name);
 207 }
 208 #endif
 209
 210 #ifdef WITH_FFMPEG
 211
 212 void silence_log_ffmpeg(int quiet)
 213 {
 214         if (quiet)
 215         {
 216                 av_log_set_level(AV_LOG_QUIET);
 217         }
 218         else
 219         {
 220                 av_log_set_level(AV_LOG_INFO);
 221         }
 222 }
 223
 224 extern void do_init_ffmpeg(void);
 225 void do_init_ffmpeg(void)
 226 {
 227         static int ffmpeg_init = 0;
 228         if (!ffmpeg_init) {
 229                 ffmpeg_init = 1;
 230                 av_register_all();
 231                 avdevice_register_all();
 232
 233                 if ((G.f & G_DEBUG) == 0)
 234                 {
 235                         silence_log_ffmpeg(1);
 236                 }
 237         }
 238 }
 239
 240 static int isffmpeg (const char *filename) {
 241         AVFormatContext *pFormatCtx;
 242         unsigned int i;
 243         int videoStream;
 244         AVCodec *pCodec;
 245         AVCodecContext *pCodecCtx;
 246
 247         do_init_ffmpeg();
 248
 249         if( BLI_testextensie(filename, ".swf") ||
 250                 BLI_testextensie(filename, ".jpg") ||
 251                 BLI_testextensie(filename, ".png") ||
 252                 BLI_testextensie(filename, ".dds") ||
 253                 BLI_testextensie(filename, ".tga") ||
 254                 BLI_testextensie(filename, ".bmp") ||
 255                 BLI_testextensie(filename, ".exr") ||
 256                 BLI_testextensie(filename, ".cin") ||
 257                 BLI_testextensie(filename, ".wav")) return 0;
 258
 259         if(av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL)!=0) {
 260                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
 261                 return 0;
 262         }
 263
 264         if(av_find_stream_info(pFormatCtx)<0) {
 265                 if(UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_find_stream_info failed\n");
 266                 av_close_input_file(pFormatCtx);
 267                 return 0;
 268         }
 269
 270         if(UTIL_DEBUG) av_dump_format(pFormatCtx, 0, filename, 0);
 271
 272
 273                 /* Find the first video stream */
 274         videoStream=-1;
 275         for(i=0; i<pFormatCtx->nb_streams; i++)
 276                 if(pFormatCtx->streams[i] &&
 277                    pFormatCtx->streams[i]->codec &&
 278                   (pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO))
 279                 {
 280                         videoStream=i;
 281                         break;
 282                 }
 283
 284         if(videoStream==-1) {
 285                 av_close_input_file(pFormatCtx);
 286                 return 0;
 287         }
 288
 289         pCodecCtx = pFormatCtx->streams[videoStream]->codec;
 290
 291                 /* Find the decoder for the video stream */
 292         pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
 293         if(pCodec==NULL) {
 294                 av_close_input_file(pFormatCtx);
 295                 return 0;
 296         }
 297
 298         if(avcodec_open(pCodecCtx, pCodec)<0) {
 299                 av_close_input_file(pFormatCtx);
 300                 return 0;
 301         }
 302
 303         avcodec_close(pCodecCtx);
 304         av_close_input_file(pFormatCtx);
 305
 306         return 1;
 307 }
 308 #endif
 309
 310 #ifdef WITH_REDCODE
 311 static int isredcode(const char * filename)
 312 {
 313         struct redcode_handle * h = redcode_open(filename);
 314         if (!h) {
 315                 return 0;
 316         }
 317         redcode_close(h);
 318         return 1;
 319 }
 320
 321 #endif
 322
 323 int imb_get_anim_type(const char * name) {
 324         int type;
 325         struct stat st;
 326
 327         if(UTIL_DEBUG) printf("in getanimtype: %s\n", name);
 328
 329 #ifndef _WIN32
 330 #       ifdef WITH_QUICKTIME
 331         if (isqtime(name)) return (ANIM_QTIME);
 332 #       endif
 333 #       ifdef WITH_FFMPEG
 334         /* stat test below fails on large files > 4GB */
 335         if (isffmpeg(name)) return (ANIM_FFMPEG);
 336 #       endif
 337         if (stat(name,&st) == -1) return(0);
 338         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
 339
 340         if (isavi(name)) return (ANIM_AVI);
 341
 342         if (ismovie(name)) return (ANIM_MOVIE);
 343 #else
 344         if (stat(name,&st) == -1) return(0);
 345         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
 346
 347         if (ismovie(name)) return (ANIM_MOVIE);
 348 #       ifdef WITH_QUICKTIME
 349         if (isqtime(name)) return (ANIM_QTIME);
 350 #       endif
 351 #       ifdef WITH_FFMPEG
 352         if (isffmpeg(name)) return (ANIM_FFMPEG);
 353 #       endif
 354         if (isavi(name)) return (ANIM_AVI);
 355 #endif
 356 #ifdef WITH_REDCODE
 357         if (isredcode(name)) return (ANIM_REDCODE);
 358 #endif
 359         type = IMB_ispic(name);
 360         if (type) return(ANIM_SEQUENCE);
 361         return(0);
 362 }
 363
 364 int IMB_isanim(const char *filename) {
 365         int type;
 366
 367         if(U.uiflag & USER_FILTERFILEEXTS) {
 368                 if (G.have_quicktime){
 369                         if(             BLI_testextensie(filename, ".avi")
 370                                 ||      BLI_testextensie(filename, ".flc")
 371                                 ||      BLI_testextensie(filename, ".dv")
 372                                 ||      BLI_testextensie(filename, ".r3d")
 373                                 ||      BLI_testextensie(filename, ".mov")
 374                                 ||      BLI_testextensie(filename, ".movie")
 375                                 ||      BLI_testextensie(filename, ".mv")) {
 376                                 type = imb_get_anim_type(filename);
 377                         } else {
 378                                 return(FALSE);
 379                         }
 380                 } else { // no quicktime
 381                         if(             BLI_testextensie(filename, ".avi")
 382                                 ||      BLI_testextensie(filename, ".dv")
 383                                 ||      BLI_testextensie(filename, ".r3d")
 384                                 ||      BLI_testextensie(filename, ".mv")) {
 385                                 type = imb_get_anim_type(filename);
 386                         }
 387                         else  {
 388                                 return(FALSE);
 389                         }
 390                 }
 391         } else { // no FILTERFILEEXTS
 392                 type = imb_get_anim_type(filename);
 393         }
 394
 395         return (type && type!=ANIM_SEQUENCE);
 396 }