== 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
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 }