style cleanup: follow style guide for formatting of if/for/while loops, and else...
[blender.git] / 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 "BLI_blenlib.h"
43
44 #include "DNA_userdef_types.h"
45 #include "BKE_global.h"
46
47 #include "imbuf.h"
48 #include "IMB_imbuf_types.h"
49 #include "IMB_imbuf.h"
50 #include "IMB_filetype.h"
51
52 #include "IMB_anim.h"
53
54 #ifdef WITH_QUICKTIME
55 #include "quicktime_import.h"
56 #endif
57
58 #ifdef WITH_FFMPEG
59 #include <libavcodec/avcodec.h>
60 #include <libavformat/avformat.h>
61 #include <libavdevice/avdevice.h>
62 #include <libavutil/log.h>
63
64 #include "ffmpeg_compat.h"
65
66 #endif
67
68 #define UTIL_DEBUG 0
69
70 const char *imb_ext_image[] = {
71         ".png",
72         ".tga",
73         ".bmp",
74         ".jpg", ".jpeg",
75         ".sgi", ".rgb", ".rgba",
76 #ifdef WITH_TIFF
77         ".tif", ".tiff", ".tx",
78 #endif
79 #ifdef WITH_OPENJPEG
80         ".jp2",
81 #endif
82 #ifdef WITH_HDR
83         ".hdr",
84 #endif
85 #ifdef WITH_DDS
86         ".dds",
87 #endif
88 #ifdef WITH_CINEON
89         ".dpx",
90         ".cin",
91 #endif
92 #ifdef WITH_OPENEXR
93         ".exr",
94 #endif
95         NULL};
96
97 const char *imb_ext_image_qt[] = {
98         ".gif",
99         ".psd",
100         ".pct", ".pict",
101         ".pntg",
102         ".qtif",
103         NULL};
104
105 const char *imb_ext_movie[] = {
106         ".avi",
107         ".flc",
108         ".mov",
109         ".movie",
110         ".mp4",
111         ".m4v",
112         ".m2v",
113         ".m2t",
114         ".m2ts",
115         ".mts",
116         ".mv",
117         ".avs",
118         ".wmv",
119         ".ogv",
120         ".dv",
121         ".mpeg",
122         ".mpg",
123         ".mpg2",
124         ".vob",
125         ".mkv",
126         ".flv",
127         ".divx",
128         ".xvid",
129         ".mxf",
130         NULL};
131
132 /* sort of wrong being here... */
133 const char *imb_ext_audio[] = {
134         ".wav",
135         ".ogg",
136         ".oga",
137         ".mp3",
138         ".mp2",
139         ".ac3",
140         ".aac",
141         ".flac",
142         ".wma",
143         ".eac3",
144         ".aif",
145         ".aiff",
146         ".m4a",
147         NULL};
148
149 static int IMB_ispic_name(const char *name)
150 {
151         ImFileType *type;
152         struct stat st;
153         int fp, buf[10];
154
155         if (UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
156         
157         if (stat(name,&st) == -1)
158                 return FALSE;
159         if (((st.st_mode) & S_IFMT) != S_IFREG)
160                 return FALSE;
161
162         if ((fp = BLI_open(name,O_BINARY|O_RDONLY, 0)) < 0)
163                 return FALSE;
164
165         if (read(fp, buf, 32) != 32) {
166                 close(fp);
167                 return FALSE;
168         }
169
170         close(fp);
171
172         /* XXX move this exception */
173         if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
174                 return JPG;
175
176         for (type=IMB_FILE_TYPES; type->is_a; type++)
177                 if (type->is_a((uchar*)buf))
178                         return type->filetype;
179
180         return FALSE;
181 }
182
183 int IMB_ispic(const char *filename)
184 {
185         if (U.uiflag & USER_FILTERFILEEXTS) {
186                 if (    (BLI_testextensie_array(filename, imb_ext_image)) ||
187                         (G.have_quicktime && BLI_testextensie_array(filename, imb_ext_image_qt))
188                 ) {
189                         return IMB_ispic_name(filename);
190                 }
191                 else  {
192                         return FALSE;
193                 }
194         }
195         else { /* no FILTERFILEEXTS */
196                 return IMB_ispic_name(filename);
197         }
198 }
199
200
201
202 static int isavi (const char *name)
203 {
204         return AVI_is_avi (name);
205 }
206
207 #ifdef WITH_QUICKTIME
208 static int isqtime (const char *name)
209 {
210         return anim_is_quicktime (name);
211 }
212 #endif
213
214 #ifdef WITH_FFMPEG
215
216 void silence_log_ffmpeg(int quiet)
217 {
218         if (quiet) {
219                 av_log_set_level(AV_LOG_QUIET);
220         }
221         else {
222                 av_log_set_level(AV_LOG_DEBUG);
223         }
224 }
225
226 extern void do_init_ffmpeg(void);
227 void do_init_ffmpeg(void)
228 {
229         static int ffmpeg_init = 0;
230         if (!ffmpeg_init) {
231                 ffmpeg_init = 1;
232                 av_register_all();
233                 avdevice_register_all();
234                 
235                 if ((G.f & G_DEBUG) == 0) {
236                         silence_log_ffmpeg(1);
237                 }
238                 else {
239                         silence_log_ffmpeg(0);
240                 }
241         }
242 }
243
244 static int isffmpeg (const char *filename)
245 {
246         AVFormatContext *pFormatCtx;
247         unsigned int i;
248         int videoStream;
249         AVCodec *pCodec;
250         AVCodecContext *pCodecCtx;
251
252         do_init_ffmpeg();
253
254         if ( BLI_testextensie(filename, ".swf") ||
255                 BLI_testextensie(filename, ".jpg") ||
256                 BLI_testextensie(filename, ".png") ||
257                 BLI_testextensie(filename, ".dds") ||
258                 BLI_testextensie(filename, ".tga") ||
259                 BLI_testextensie(filename, ".bmp") ||
260                 BLI_testextensie(filename, ".exr") ||
261                 BLI_testextensie(filename, ".cin") ||
262                 BLI_testextensie(filename, ".wav")) return 0;
263
264         if (av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL)!=0) {
265                 if (UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_open_input_file failed\n");
266                 return 0;
267         }
268
269         if (av_find_stream_info(pFormatCtx)<0) {
270                 if (UTIL_DEBUG) fprintf(stderr, "isffmpeg: av_find_stream_info failed\n");
271                 av_close_input_file(pFormatCtx);
272                 return 0;
273         }
274
275         if (UTIL_DEBUG) av_dump_format(pFormatCtx, 0, filename, 0);
276
277
278                 /* Find the first video stream */
279         videoStream=-1;
280         for (i=0; i<pFormatCtx->nb_streams; i++)
281                 if (pFormatCtx->streams[i] &&
282                    pFormatCtx->streams[i]->codec && 
283                   (pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO))
284                 {
285                         videoStream=i;
286                         break;
287                 }
288
289         if (videoStream==-1) {
290                 av_close_input_file(pFormatCtx);
291                 return 0;
292         }
293
294         pCodecCtx = pFormatCtx->streams[videoStream]->codec;
295
296                 /* Find the decoder for the video stream */
297         pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
298         if (pCodec==NULL) {
299                 av_close_input_file(pFormatCtx);
300                 return 0;
301         }
302
303         if (avcodec_open(pCodecCtx, pCodec)<0) {
304                 av_close_input_file(pFormatCtx);
305                 return 0;
306         }
307
308         avcodec_close(pCodecCtx);
309         av_close_input_file(pFormatCtx);
310
311         return 1;
312 }
313 #endif
314
315 #ifdef WITH_REDCODE
316 static int isredcode(const char * filename)
317 {
318         struct redcode_handle * h = redcode_open(filename);
319         if (!h) {
320                 return 0;
321         }
322         redcode_close(h);
323         return 1;
324 }
325
326 #endif
327
328 int imb_get_anim_type(const char * name)
329 {
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 {
372         int type;
373         
374         if (U.uiflag & USER_FILTERFILEEXTS) {
375                 if (G.have_quicktime) {
376                         if (            BLI_testextensie(filename, ".avi")
377                                 ||      BLI_testextensie(filename, ".flc")
378                                 ||      BLI_testextensie(filename, ".dv")
379                                 ||      BLI_testextensie(filename, ".r3d")
380                                 ||      BLI_testextensie(filename, ".mov")
381                                 ||      BLI_testextensie(filename, ".movie")
382                                 ||      BLI_testextensie(filename, ".mv")) {
383                                 type = imb_get_anim_type(filename);
384                         }
385                         else {
386                                 return(FALSE);                  
387                         }
388                 }
389                 else { // no quicktime
390                         if (            BLI_testextensie(filename, ".avi")
391                                 ||      BLI_testextensie(filename, ".dv")
392                                 ||      BLI_testextensie(filename, ".r3d")
393                                 ||      BLI_testextensie(filename, ".mv")) {
394                                 type = imb_get_anim_type(filename);
395                         }
396                         else  {
397                                 return(FALSE);
398                         }
399                 }
400         }
401         else { // no FILTERFILEEXTS
402                 type = imb_get_anim_type(filename);
403         }
404         
405         return (type && type!=ANIM_SEQUENCE);
406 }