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