rework set default transtion, nested proxy edl fixes, doubleclick proxy media fix...
[goodguy/history.git] / cinelerra-5.1 / cinelerra / mainindexes.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "asset.h"
23 #include "bcsignals.h"
24 #include "bchash.h"
25 #include "edl.h"
26 #include "file.h"
27 #include "filesystem.h"
28 #include "indexfile.h"
29 #include "indexstate.h"
30 #include "condition.h"
31 #include "language.h"
32 #include "loadfile.h"
33 #include "guicast.h"
34 #include "mainerror.h"
35 #include "mainindexes.h"
36 #include "mainprogress.h"
37 #include "mutex.h"
38 #include "mwindow.h"
39 #include "mwindowgui.h"
40 #include "preferences.h"
41
42 #include <string.h>
43
44
45 MainIndexes::MainIndexes(MWindow *mwindow)
46  : Thread(1, 0, 0)
47 {
48         set_synchronous(1);
49         this->mwindow = mwindow;
50         input_lock = new Condition(0, "MainIndexes::input_lock");
51         next_lock = new Mutex("MainIndexes::next_lock");
52         index_lock = new Mutex("MainIndexes::index_lock");
53         interrupt_lock = new Condition(1, "MainIndexes::interrupt_lock");
54         interrupt_flag = 0;
55         indexfile = 0;
56         done = 0;
57 }
58
59 MainIndexes::~MainIndexes()
60 {
61         mwindow->mainprogress->cancelled = 1;
62         stop_loop();
63         delete next_lock;
64         delete input_lock;
65         delete interrupt_lock;
66         delete indexfile;
67         delete index_lock;
68 }
69
70 void MainIndexes::add_next_asset(File *file, Indexable *indexable)
71 {
72         next_lock->lock("MainIndexes::add_next_asset");
73
74 SET_TRACE
75 // Test current asset
76         IndexFile indexfile(mwindow, indexable);
77         IndexState *index_state = indexable->index_state;
78
79 SET_TRACE
80         int ret = indexfile.open_index();
81         if( !ret ) {
82                 index_state->index_status = INDEX_READY;
83                 indexfile.close_index();
84         }
85         else {
86 // Put source in stack
87                 index_state->index_status = INDEX_NOTTESTED;
88                 next_indexables.append(indexable);
89                 indexable->add_user();
90         }
91         next_lock->unlock();
92 }
93
94 void MainIndexes::start_loop()
95 {
96         interrupt_flag = 0;
97         Thread::start();
98 }
99
100 void MainIndexes::stop_loop()
101 {
102         interrupt_flag = 1;
103         done = 1;
104         input_lock->unlock();
105         interrupt_lock->unlock();
106         Thread::join();
107 }
108
109
110 void MainIndexes::start_build()
111 {
112 //printf("MainIndexes::start_build 1\n");
113         interrupt_flag = 0;
114 // Locked up when indexes were already being built and an indexable was
115 // pasted.
116 //      interrupt_lock.lock();
117         input_lock->unlock();
118 }
119
120 void MainIndexes::interrupt_build()
121 {
122 //printf("MainIndexes::interrupt_build 1\n");
123         interrupt_flag = 1;
124         index_lock->lock("MainIndexes::interrupt_build");
125         if(indexfile) indexfile->interrupt_index();
126         index_lock->unlock();
127 //printf("MainIndexes::interrupt_build 2\n");
128         interrupt_lock->lock("MainIndexes::interrupt_build");
129 //printf("MainIndexes::interrupt_build 3\n");
130         interrupt_lock->unlock();
131 //printf("MainIndexes::interrupt_build 4\n");
132 }
133
134 void MainIndexes::load_next_sources()
135 {
136 // Transfer from new list
137         next_lock->lock("MainIndexes::load_next_sources");
138         for(int i = 0; i < next_indexables.size(); i++)
139                 current_indexables.append(next_indexables.get(i));
140
141 // Clear pointers from new list only
142         next_indexables.remove_all();
143         next_lock->unlock();
144 }
145
146
147 void MainIndexes::run()
148 {
149         while(!done) {
150 // Wait for new indexables to be released
151                 input_lock->lock("MainIndexes::run 1");
152                 if(done) return;
153
154                 interrupt_lock->lock("MainIndexes::run 2");
155                 load_next_sources();
156                 interrupt_flag = 0;
157
158 // test index of each indexable
159                 MainProgressBar *progress = 0;
160
161                 next_lock->lock("MainIndexes::run");
162                 for( int i=0; i<current_indexables.size() && !interrupt_flag; ++i ) {
163                         Indexable *indexable = current_indexables[i];
164                         IndexState *index_state = indexable->index_state;
165 // if status is known, no probe
166                         if( index_state->index_status != INDEX_NOTTESTED ) continue;
167                         next_lock->unlock();
168
169                         IndexFile indexfile(mwindow, indexable);
170                         int ret = indexfile.open_index();
171                         if( !ret ) {
172                                 indexfile.close_index();
173 // use existing index
174                                 index_state->index_status = INDEX_READY;
175                                 if(mwindow->gui) mwindow->gui->lock_window("MainIndexes::run 2");
176                                 mwindow->edl->set_index_file(indexable);
177                                 if(mwindow->gui) mwindow->gui->unlock_window();
178                                 continue;
179                         }
180 // Doesn't exist
181                         if( !progress ) {
182                                 if(mwindow->gui) mwindow->gui->lock_window("MainIndexes::run 1");
183                                 progress = mwindow->mainprogress->start_progress(_("Building Indexes..."), 1);
184                                 if(mwindow->gui) mwindow->gui->unlock_window();
185                         }
186 // only if audio tracks
187                         indexfile.create_index(progress);
188                         if( progress->is_cancelled() )
189                                 interrupt_flag = 1;
190                         next_lock->lock("MainIndexes::run");
191                 }
192
193                 for( int i=0; i<current_indexables.size(); ++i )
194                         current_indexables[i]->remove_user();
195                 current_indexables.remove_all();
196                 next_lock->unlock();
197
198                 if(progress) {  // progress box is only created when an index is built
199                         if(mwindow->gui) mwindow->gui->lock_window("MainIndexes::run 3");
200                         progress->stop_progress();
201                         delete progress;
202                         if(mwindow->gui) mwindow->gui->unlock_window();
203                         progress = 0;
204                 }
205
206                 interrupt_lock->unlock();
207         }
208 }
209