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