attempt to support d1 for mac mission
[btb/d2x.git] / main / movie.c
1 /* $Id: movie.c,v 1.14 2003-01-09 00:57:42 btb Exp $ */
2 /*
3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
13 */
14
15 #ifdef HAVE_CONFIG_H
16 #include <conf.h>
17 #endif
18
19 #ifdef RCS
20 static char rcsid[] = "$Id: movie.c,v 1.14 2003-01-09 00:57:42 btb Exp $";
21 #endif
22
23 #define DEBUG_LEVEL CON_NORMAL
24
25 #include <string.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <fcntl.h>
29 #include <unistd.h>
30 #include <ctype.h>
31
32 #include "movie.h"
33 #include "console.h"
34 #include "args.h"
35 #include "key.h"
36 #include "digi.h"
37 #include "songs.h"
38 #include "inferno.h"
39 #include "palette.h"
40 #include "strutil.h"
41 #include "error.h"
42 #include "u_mem.h"
43 #include "byteswap.h"
44 #include "gr.h"
45 #include "gamefont.h"
46 #include "cfile.h"
47 #include "menu.h"
48 #include "mvelib.h"
49 #include "text.h"
50 #include "fileutil.h"
51 #include "mveplay.h"
52
53 extern int MenuHiresAvailable;
54 extern char CDROM_dir[];
55
56 #define VID_PLAY 0
57 #define VID_PAUSE 1
58
59 int Vid_State;
60
61
62 // Subtitle data
63 typedef struct {
64         short first_frame,last_frame;
65         char *msg;
66 } subtitle;
67
68 #define MAX_SUBTITLES 500
69 #define MAX_ACTIVE_SUBTITLES 3
70 subtitle Subtitles[MAX_SUBTITLES];
71 int Num_subtitles;
72
73
74 typedef struct {
75         char name[FILENAME_LEN];
76         int offset,len;
77 } ml_entry;
78
79 #define MLF_ON_CD    1
80 #define MAX_MOVIES_PER_LIB    50    //determines size of malloc
81
82
83 typedef struct {
84         char     name[100]; //[FILENAME_LEN];
85         int      n_movies;
86         ubyte    flags,pad[3];
87         ml_entry *movies;
88 } movielib;
89
90 #ifdef D2_OEM
91 char movielib_files[][FILENAME_LEN] = {"intro-l.mvl","other-l.mvl","robots-l.mvl","oem-l.mvl"};
92 #else
93 char movielib_files[][FILENAME_LEN] = {"intro-l.mvl","other-l.mvl","robots-l.mvl"};
94 #endif
95
96 #define N_BUILTIN_MOVIE_LIBS (sizeof(movielib_files)/sizeof(*movielib_files))
97 #define N_MOVIE_LIBS (N_BUILTIN_MOVIE_LIBS+1)
98 #define EXTRA_ROBOT_LIB N_BUILTIN_MOVIE_LIBS
99 movielib *movie_libs[N_MOVIE_LIBS];
100
101 int MVEPaletteCalls = 0;
102
103 //do we have the robot movies available
104 int robot_movies = 0; //0 means none, 1 means lowres, 2 means hires
105
106 int MovieHires = 0;   //default for now is lores
107
108 int RoboFile = 0;
109 off_t Robo_filepos;
110 MVESTREAM *Robo_mve;
111 grs_bitmap *Robo_bitmap;
112
113
114 //      Function Prototypes
115 int RunMovie(char *filename, int highres_flag, int allow_abort,int dx,int dy);
116
117 int open_movie_file(char *filename,int must_have);
118
119 void change_filename_ext( char *dest, char *src, char *ext );
120 void decode_text_line(char *p);
121 void draw_subtitles(int frame_num);
122
123
124 //filename will actually get modified to be either low-res or high-res
125 //returns status.  see values in movie.h
126 int PlayMovie(const char *filename, int must_have)
127 {
128         char name[FILENAME_LEN],*p;
129         int c, ret;
130 #if 0
131         int save_sample_rate;
132 #endif
133
134 #ifndef RELEASE
135         if (FindArg("-nomovies"))
136                 return MOVIE_NOT_PLAYED;
137 #endif
138
139         strcpy(name,filename);
140
141         if ((p=strchr(name,'.')) == NULL)               //add extension, if missing
142                 strcat(name,".mve");
143
144         //check for escape already pressed & abort if so
145         while ((c=key_inkey()) != 0)
146                 if (c == KEY_ESC)
147                         return MOVIE_ABORTED;
148
149         // Stop all digital sounds currently playing.
150         digi_stop_all();
151
152         // Stop all songs
153         songs_stop_all();
154
155 #if 0
156         save_sample_rate = digi_sample_rate;
157         digi_sample_rate = SAMPLE_RATE_22K;             //always 22K for movies
158         digi_reset(); digi_reset();
159 #else
160         digi_close();
161 #endif
162
163         ret = RunMovie(name,MovieHires,must_have,-1,-1);
164
165 #if 0
166         gr_palette_clear();             //clear out palette in case movie aborted
167 #endif
168
169 #if 0
170         digi_sample_rate = save_sample_rate;            //restore rate for game
171         digi_reset(); digi_reset();
172 #else
173         digi_init();
174 #endif
175
176         Screen_mode = -1;               //force screen reset
177
178         return ret;
179 }
180
181 #if 0
182 typedef struct bkg {
183         short x, y, w, h;           // The location of the menu.
184         grs_bitmap * bmp;               // The background under the menu.
185 } bkg;
186
187 bkg movie_bg = {0,0,0,0,NULL};
188 #endif
189
190 #define BOX_BORDER (MenuHires?40:20)
191
192 void show_pause_message(char *msg)
193 {
194         int w,h,aw;
195         int x,y;
196
197         gr_set_current_canvas(NULL);
198         gr_set_curfont( SMALL_FONT );
199
200         gr_get_string_size(msg,&w,&h,&aw);
201
202         x = (grd_curscreen->sc_w-w)/2;
203         y = (grd_curscreen->sc_h-h)/2;
204
205 #if 0
206         if (movie_bg.bmp) {
207                 gr_free_bitmap(movie_bg.bmp);
208                 movie_bg.bmp = NULL;
209         }
210
211         // Save the background of the display
212         movie_bg.x=x; movie_bg.y=y; movie_bg.w=w; movie_bg.h=h;
213
214         movie_bg.bmp = gr_create_bitmap( w+BOX_BORDER, h+BOX_BORDER );
215
216         gr_bm_ubitblt(w+BOX_BORDER, h+BOX_BORDER, 0, 0, x-BOX_BORDER/2, y-BOX_BORDER/2, &(grd_curcanv->cv_bitmap), movie_bg.bmp );
217 #endif
218
219         gr_setcolor(0);
220         gr_rect(x-BOX_BORDER/2,y-BOX_BORDER/2,x+w+BOX_BORDER/2-1,y+h+BOX_BORDER/2-1);
221
222         gr_set_fontcolor( 255, -1 );
223
224         gr_ustring( 0x8000, y, msg );
225
226         gr_update();
227 }
228
229 void clear_pause_message()
230 {
231 #if 0
232         if (movie_bg.bmp) {
233
234                 gr_bitmap(movie_bg.x-BOX_BORDER/2, movie_bg.y-BOX_BORDER/2, movie_bg.bmp);
235
236                 gr_free_bitmap(movie_bg.bmp);
237                 movie_bg.bmp = NULL;
238         }
239 #endif
240 }
241
242 //returns status.  see movie.h
243 int RunMovie(char *filename, int hires_flag, int must_have,int dx,int dy)
244 {
245         int filehndl;
246         int result=1,aborted=0;
247         int frame_num;
248         MVESTREAM *mve;
249         grs_bitmap *mve_bitmap;
250         int key;
251         int x, y, w, h;
252
253         result=1;
254
255         // Open Movie file.  If it doesn't exist, no movie, just return.
256
257         filehndl = open_movie_file(filename,must_have);
258
259         if (filehndl == -1) {
260 #ifndef EDITOR
261                 if (must_have)
262                         Warning("movie: RunMovie: Cannot open movie <%s>\n",filename);
263 #endif
264                 return MOVIE_NOT_PLAYED;
265         }
266
267         if (hires_flag) {
268                 gr_set_mode(SM(640,480));
269                 x = 24;
270                 y = 84;
271                 w = 592;
272                 h = 312;
273         } else {
274                 gr_set_mode(SM(320,200));
275                 x = 0;
276                 y = 32;
277                 w = 320;
278                 h = 136;
279         }
280
281         frame_num = 0;
282
283         FontHires = FontHiresAvailable && hires_flag;
284
285     mve = mve_open(filehndl);
286
287         mve_bitmap = gr_create_bitmap(w, h); // w, h must match the mve exactly!
288
289         mveplay_initializeMovie(mve, mve_bitmap);
290
291         while(result) {
292
293                 result = mveplay_stepMovie(mve);
294
295                 gr_bitmap(x, y, mve_bitmap);
296
297                 draw_subtitles(frame_num);
298
299                 key = key_inkey();
300
301                 switch (key) {
302                 case KEY_ESC:
303                         // If ESCAPE pressed, then quit movie.
304                         result = 0;
305                         aborted = 1;
306                         break;
307                 case KEY_PAUSE:
308                         // If PAUSE pressed, then pause movie
309                         show_pause_message(TXT_PAUSE);
310                         while (!key_inkey()) ;
311                         mveplay_restartTimer(mve);
312                         clear_pause_message();
313                         break;
314 #ifdef GR_SUPPORTS_FULLSCREEN_TOGGLE
315                 case KEY_CTRLED+KEY_SHIFTED+KEY_PADENTER:
316                 case KEY_ALTED+KEY_CTRLED+KEY_PADENTER:
317                 case KEY_ALTED+KEY_SHIFTED+KEY_PADENTER:
318                         gr_toggle_fullscreen();
319                         break;
320 #endif
321                 }
322
323                 frame_num++;
324         }
325
326         Assert(aborted || !result);      ///movie should be over
327
328     mveplay_shutdownMovie(mve);
329
330         gr_free_bitmap(mve_bitmap);
331
332     mve_close(mve);
333
334         close(filehndl);                           // Close Movie File
335
336         // Restore old graphic state
337
338         Screen_mode=-1;  //force reset of screen mode
339
340         return (aborted?MOVIE_ABORTED:MOVIE_PLAYED_FULL);
341 }
342
343
344 int InitMovieBriefing()
345 {
346         if (MenuHires)
347                 gr_set_mode(SM(640,480));
348         else
349                 gr_set_mode(SM(320,200));
350
351         return 1;
352 }
353
354
355 //returns 1 if frame updated ok
356 int RotateRobot()
357 {
358         int ret;
359
360         ret = mveplay_stepMovie(Robo_mve);
361         gr_bitmap(MenuHires?280:140, MenuHires?200:80, Robo_bitmap);
362
363         if (!ret) {
364                 mveplay_shutdownMovie(Robo_mve);
365                 mve_close(Robo_mve);
366                 lseek(RoboFile, Robo_filepos, SEEK_SET);
367                 Robo_mve = mve_open(RoboFile);
368                 mveplay_initializeMovie(Robo_mve, Robo_bitmap);
369         }
370
371         return 1;
372 }
373
374
375 void DeInitRobotMovie(void)
376 {
377         mveplay_shutdownMovie(Robo_mve);
378         mve_close(Robo_mve);
379
380         gr_free_bitmap(Robo_bitmap);
381
382         close(RoboFile);
383 }
384
385
386 int InitRobotMovie(char *filename)
387 {
388         RoboFile = open_movie_file(filename, 1);
389
390         if (RoboFile == -1) {
391                 Warning("movie: InitRobotMovie: Cannot open movie file <%s>",filename);
392                 return MOVIE_NOT_PLAYED;
393         }
394
395         Robo_filepos = lseek(RoboFile, 0, SEEK_CUR);
396
397         Robo_mve = mve_open(RoboFile);
398
399         Robo_bitmap = gr_create_bitmap(MenuHires?320:160, MenuHires?200:88);
400
401         mveplay_initializeMovie(Robo_mve, Robo_bitmap);
402
403         return 1;
404 }
405
406
407 /*
408  *              Subtitle system code
409  */
410
411 ubyte *subtitle_raw_data;
412
413
414 //search for next field following whitespace 
415 ubyte *next_field(ubyte *p)
416 {
417         while (*p && !isspace(*p))
418                 p++;
419
420         if (!*p)
421                 return NULL;
422
423         while (*p && isspace(*p))
424                 p++;
425
426         if (!*p)
427                 return NULL;
428
429         return p;
430 }
431
432
433 int init_subtitles(char *filename)
434 {
435         CFILE *ifile;
436         int size,read_count;
437         ubyte *p;
438         int have_binary = 0;
439
440         Num_subtitles = 0;
441
442         if (! FindArg("-subtitles"))
443                 return 0;
444
445         ifile = cfopen(filename,"rb");          //try text version
446
447         if (!ifile) {                                                           //no text version, try binary version
448                 char filename2[FILENAME_LEN];
449                 change_filename_ext(filename2,filename,".TXB");
450                 ifile = cfopen(filename2,"rb");
451                 if (!ifile)
452                         return 0;
453                 have_binary = 1;
454         }
455
456         size = cfilelength(ifile);
457    
458         MALLOC (subtitle_raw_data, ubyte, size+1);
459
460         read_count = cfread(subtitle_raw_data, 1, size, ifile);
461
462         cfclose(ifile);
463
464         subtitle_raw_data[size] = 0;
465
466         if (read_count != size) {
467                 d_free(subtitle_raw_data);
468                 return 0;
469         }
470
471         p = subtitle_raw_data;
472
473         while (p && p < subtitle_raw_data+size) {
474                 char *endp;
475
476                 endp = strchr(p,'\n'); 
477                 if (endp) {
478                         if (endp[-1] == '\r')
479                                 endp[-1] = 0;           //handle 0d0a pair
480                         *endp = 0;                      //string termintor
481                 }
482
483                 if (have_binary)
484                         decode_text_line(p);
485
486                 if (*p != ';') {
487                         Subtitles[Num_subtitles].first_frame = atoi(p);
488                         p = next_field(p); if (!p) continue;
489                         Subtitles[Num_subtitles].last_frame = atoi(p);
490                         p = next_field(p); if (!p) continue;
491                         Subtitles[Num_subtitles].msg = p;
492
493                         Assert(Num_subtitles==0 || Subtitles[Num_subtitles].first_frame >= Subtitles[Num_subtitles-1].first_frame);
494                         Assert(Subtitles[Num_subtitles].last_frame >= Subtitles[Num_subtitles].first_frame);
495
496                         Num_subtitles++;
497                 }
498
499                 p = endp+1;
500
501         }
502
503         return 1;
504 }
505
506
507 void close_subtitles()
508 {
509         if (subtitle_raw_data)
510                 d_free(subtitle_raw_data);
511         subtitle_raw_data = NULL;
512         Num_subtitles = 0;
513 }
514
515
516 //draw the subtitles for this frame
517 void draw_subtitles(int frame_num)
518 {
519         static int active_subtitles[MAX_ACTIVE_SUBTITLES];
520         static int num_active_subtitles,next_subtitle,line_spacing;
521         int t,y;
522         int must_erase=0;
523
524         if (frame_num == 0) {
525                 num_active_subtitles = 0;
526                 next_subtitle = 0;
527                 gr_set_curfont( GAME_FONT );
528                 line_spacing = grd_curcanv->cv_font->ft_h + (grd_curcanv->cv_font->ft_h >> 2);
529                 gr_set_fontcolor(255,-1);
530         }
531
532         //get rid of any subtitles that have expired
533         for (t=0;t<num_active_subtitles;)
534                 if (frame_num > Subtitles[active_subtitles[t]].last_frame) {
535                         int t2;
536                         for (t2=t;t2<num_active_subtitles-1;t2++)
537                                 active_subtitles[t2] = active_subtitles[t2+1];
538                         num_active_subtitles--;
539                         must_erase = 1;
540                 }
541                 else
542                         t++;
543
544         //get any subtitles new for this frame 
545         while (next_subtitle < Num_subtitles && frame_num >= Subtitles[next_subtitle].first_frame) {
546                 if (num_active_subtitles >= MAX_ACTIVE_SUBTITLES)
547                         Error("Too many active subtitles!");
548                 active_subtitles[num_active_subtitles++] = next_subtitle;
549                 next_subtitle++;
550         }
551
552         //find y coordinate for first line of subtitles
553         y = grd_curcanv->cv_bitmap.bm_h-((line_spacing+1)*MAX_ACTIVE_SUBTITLES+2);
554
555         //erase old subtitles if necessary
556         if (must_erase) {
557                 gr_setcolor(0);
558                 gr_rect(0,y,grd_curcanv->cv_bitmap.bm_w-1,grd_curcanv->cv_bitmap.bm_h-1);
559         }
560
561         //now draw the current subtitles
562         for (t=0;t<num_active_subtitles;t++)
563                 if (active_subtitles[t] != -1) {
564                         gr_string(0x8000,y,Subtitles[active_subtitles[t]].msg);
565                         y += line_spacing+1;
566                 }
567
568         gr_update();
569 }
570
571
572 int request_cd(void)
573 {
574         con_printf(DEBUG_LEVEL, "STUB: movie: request_cd\n");
575         return 0;
576 }
577
578
579 movielib *init_new_movie_lib(char *filename,FILE *fp)
580 {
581         int nfiles,offset;
582         int i,n;
583         movielib *table;
584
585         //read movie file header
586
587         nfiles = file_read_int(fp);             //get number of files
588
589         //table = d_malloc(sizeof(*table) + sizeof(ml_entry)*nfiles);
590         MALLOC(table, movielib, 1);
591         MALLOC(table->movies, ml_entry, nfiles);
592
593         strcpy(table->name,filename);
594         table->n_movies = nfiles;
595
596         offset = 4+4+nfiles*(13+4);     //id + nfiles + nfiles * (filename + size)
597
598         for (i=0;i<nfiles;i++) {
599                 int len;
600
601                 n = fread( table->movies[i].name, 13, 1, fp );
602                 if ( n != 1 )
603                         break;          //end of file (probably)
604
605                 len = file_read_int(fp);
606
607                 table->movies[i].len = len;
608                 table->movies[i].offset = offset;
609
610                 offset += table->movies[i].len;
611
612         }
613
614         fclose(fp);
615
616         table->flags = 0;
617
618         return table;
619
620 }
621
622
623 movielib *init_old_movie_lib(char *filename,FILE *fp)
624 {
625         int nfiles,size;
626         int i;
627         movielib *table,*table2;
628
629         nfiles = 0;
630
631         //allocate big table
632         table = d_malloc(sizeof(*table) + sizeof(ml_entry)*MAX_MOVIES_PER_LIB);
633
634         while( 1 ) {
635                 int len;
636
637                 i = fread( table->movies[nfiles].name, 13, 1, fp );
638                 if ( i != 1 )
639                         break;          //end of file (probably)
640
641                 i = fread( &len, 4, 1, fp );
642                 if ( i != 1 )
643                         Error("error reading movie library <%s>",filename);
644
645                 table->movies[nfiles].len = INTEL_INT(len);
646                 table->movies[nfiles].offset = ftell( fp );
647
648                 fseek( fp, INTEL_INT(len), SEEK_CUR );          //skip data
649
650                 nfiles++;
651         }
652
653         //allocate correct-sized table
654         size = sizeof(*table) + sizeof(ml_entry)*nfiles;
655         table2 = d_malloc(size);
656         memcpy(table2,table,size);
657         d_free(table);
658         table = table2;
659
660         strcpy(table->name,filename);
661
662         table->n_movies = nfiles;
663
664         fclose(fp);
665
666         table->flags = 0;
667
668         return table;
669
670 }
671
672
673 //find the specified movie library, and read in list of movies in it
674 movielib *init_movie_lib(char *filename)
675 {
676         //note: this based on cfile_init_hogfile()
677
678         char id[4];
679         FILE * fp;
680
681         fp = fopen( filename, "rb" );
682
683         if ((fp == NULL) && (AltHogdir_initialized)) {
684                 char temp[128];
685                 strcpy(temp, AltHogDir);
686                 strcat(temp, "/");
687                 strcat(temp, filename);
688                 fp = fopen(temp, "rb");
689         }
690
691         if ( fp == NULL )
692                 return NULL;
693
694         fread( id, 4, 1, fp );
695         if ( !strncmp( id, "DMVL", 4 ) )
696                 return init_new_movie_lib(filename,fp);
697         else if ( !strncmp( id, "DHF", 3 ) ) {
698                 fseek(fp,-1,SEEK_CUR);          //old file had 3 char id
699                 return init_old_movie_lib(filename,fp);
700         }
701         else {
702                 fclose(fp);
703                 return NULL;
704         }
705 }
706
707
708 void close_movie(int i)
709 {
710         if (movie_libs[i]) {
711                 d_free(movie_libs[i]->movies);
712                 d_free(movie_libs[i]);
713         }
714 }
715
716
717 void close_movies()
718 {
719         int i;
720
721         for (i=0;i<N_MOVIE_LIBS;i++)
722                 close_movie(i);
723 }
724
725
726 void init_movie(char *filename,int libnum,int is_robots,int required)
727 {
728         int high_res;
729         int try = 0;
730
731 #ifndef RELEASE
732         if (FindArg("-nomovies")) {
733                 movie_libs[libnum] = NULL;
734                 return;
735         }
736 #endif
737
738         //for robots, load highres versions if highres menus set
739         if (is_robots)
740                 high_res = MenuHiresAvailable;
741         else
742                 high_res = MovieHires;
743
744         if (high_res)
745                 strchr(filename,'.')[-1] = 'h';
746
747 try_again:;
748
749         if ((movie_libs[libnum] = init_movie_lib(filename)) == NULL) {
750                 char name2[100];
751
752                 strcpy(name2,CDROM_dir);
753                 strcat(name2,filename);
754                 movie_libs[libnum] = init_movie_lib(name2);
755
756                 if (movie_libs[libnum] != NULL)
757                         movie_libs[libnum]->flags |= MLF_ON_CD;
758                 else {
759                         if (required) {
760                                 Warning("Cannot open movie file <%s>\n",filename);
761                         }
762
763                         if (!try) {                                         // first try
764                                 if (strchr(filename, '.')[-1] == 'h') {         // try again with lowres
765                                         strchr(filename, '.')[-1] = 'l';
766                                         Warning("Trying to open movie file <%s> instead\n", filename);
767                                         try++;
768                                         goto try_again;
769                                 } else if (strchr(filename, '.')[-1] == 'l') {  // try again with highres
770                                         strchr(filename, '.')[-1] = 'h';
771                                         Warning("Trying to open movie file <%s> instead\n", filename);
772                                         try++;
773                                         goto try_again;
774                                 }
775                         }
776                 }
777         }
778
779         if (is_robots && movie_libs[libnum]!=NULL)
780                 robot_movies = high_res?2:1;
781 }
782
783
784 //find and initialize the movie libraries
785 void init_movies()
786 {
787         int i;
788         int is_robots;
789
790         for (i=0;i<N_BUILTIN_MOVIE_LIBS;i++) {
791
792                 if (!strnicmp(movielib_files[i],"robot",5))
793                         is_robots = 1;
794                 else
795                         is_robots = 0;
796
797                 init_movie(movielib_files[i],i,is_robots,1);
798         }
799
800         movie_libs[EXTRA_ROBOT_LIB] = NULL;
801
802         atexit(close_movies);
803 }
804
805
806 void init_extra_robot_movie(char *filename)
807 {
808         close_movie(EXTRA_ROBOT_LIB);
809         init_movie(filename,EXTRA_ROBOT_LIB,1,0);
810 }
811
812
813 //looks through a movie library for a movie file
814 //returns filehandle, with fileposition at movie, or -1 if can't find
815 int search_movie_lib(movielib *lib,char *filename,int must_have)
816 {
817         int i;
818         int filehandle;
819
820         if (lib == NULL)
821                 return -1;
822
823         for (i=0;i<lib->n_movies;i++)
824                 if (!stricmp(filename,lib->movies[i].name)) {   //found the movie in a library 
825                         int from_cd;
826
827                         from_cd = (lib->flags & MLF_ON_CD);
828
829                         if (from_cd)
830                                 songs_stop_redbook();           //ready to read from CD
831
832                         do {            //keep trying until we get the file handle
833
834                                 /* movie_handle = */ filehandle = open(lib->name, O_RDONLY);
835
836                                 if ((filehandle == -1) && (AltHogdir_initialized)) {
837                                         char temp[128];
838                                         strcpy(temp, AltHogDir);
839                                         strcat(temp, "/");
840                                         strcat(temp, lib->name);
841                                         filehandle = open(temp, O_RDONLY);
842                                 }
843
844                                 if (must_have && from_cd && filehandle == -1) {         //didn't get file!
845
846                                         if (request_cd() == -1)         //ESC from requester
847                                                 break;                                          //bail from here. will get error later
848                                 }
849
850                         } while (must_have && from_cd && filehandle == -1);
851
852                         if (filehandle != -1)
853                                 lseek(filehandle,(/* movie_start = */ lib->movies[i].offset),SEEK_SET);
854
855                         return filehandle;
856                 }
857
858         return -1;
859 }
860
861
862 //returns file handle
863 int open_movie_file(char *filename,int must_have)
864 {
865         int filehandle,i;
866
867         for (i=0;i<N_MOVIE_LIBS;i++) {
868                 if ((filehandle = search_movie_lib(movie_libs[i],filename,must_have)) != -1)
869                         return filehandle;
870         }
871
872         return -1;              //couldn't find it
873 }
874
875