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 = 0;
  78         index_state = indexable->index_state;
  79
  80 SET_TRACE
  81         int ret = indexfile.open_index();
  82         if( !ret ) {
  83                 index_state->index_status = INDEX_READY;
  84                 indexfile.close_index();
  85         }
  86         else {
  87 // Put source in stack
  88                 index_state->index_status = INDEX_NOTTESTED;
  89                 next_indexables.append(indexable);
  90                 indexable->add_user();
  91         }
  92         next_lock->unlock();
  93 }
  94
  95 void MainIndexes::delete_current_sources()
  96 {
  97         for(int i = 0; i < current_indexables.size(); i++)
  98                 current_indexables.get(i)->Garbage::remove_user();
  99         current_indexables.remove_all();
 100 }
 101
 102 void MainIndexes::start_loop()
 103 {
 104         interrupt_flag = 0;
 105         Thread::start();
 106 }
 107
 108 void MainIndexes::stop_loop()
 109 {
 110         interrupt_flag = 1;
 111         done = 1;
 112         input_lock->unlock();
 113         interrupt_lock->unlock();
 114         Thread::join();
 115 }
 116
 117
 118 void MainIndexes::start_build()
 119 {
 120 //printf("MainIndexes::start_build 1\n");
 121         interrupt_flag = 0;
 122 // Locked up when indexes were already being built and an indexable was
 123 // pasted.
 124 //      interrupt_lock.lock();
 125         input_lock->unlock();
 126 }
 127
 128 void MainIndexes::interrupt_build()
 129 {
 130 //printf("MainIndexes::interrupt_build 1\n");
 131         interrupt_flag = 1;
 132         index_lock->lock("MainIndexes::interrupt_build");
 133         if(indexfile) indexfile->interrupt_index();
 134         index_lock->unlock();
 135 //printf("MainIndexes::interrupt_build 2\n");
 136         interrupt_lock->lock("MainIndexes::interrupt_build");
 137 //printf("MainIndexes::interrupt_build 3\n");
 138         interrupt_lock->unlock();
 139 //printf("MainIndexes::interrupt_build 4\n");
 140 }
 141
 142 void MainIndexes::load_next_sources()
 143 {
 144         delete_current_sources();
 145
 146 // Transfer from new list
 147         next_lock->lock("MainIndexes::load_next_sources");
 148         for(int i = 0; i < next_indexables.size(); i++)
 149                 current_indexables.append(next_indexables.get(i));
 150
 151 // Clear pointers from new list only
 152         next_indexables.remove_all();
 153         next_lock->unlock();
 154 }
 155
 156
 157 void MainIndexes::run()
 158 {
 159         while(!done) {
 160 // Wait for new indexables to be released
 161                 input_lock->lock("MainIndexes::run 1");
 162                 if(done) return;
 163
 164                 interrupt_lock->lock("MainIndexes::run 2");
 165                 load_next_sources();
 166                 interrupt_flag = 0;
 167
 168 // test index of each indexable
 169                 MainProgressBar *progress = 0;
 170                 int total_sources = current_indexables.size();
 171
 172                 for( int i = 0; i < total_sources && !interrupt_flag; ++i ) {
 173                         Indexable *indexable = current_indexables[i];
 174                         IndexState *index_state = indexable->index_state;
 175 // if status is known, no probe
 176                         if( index_state->index_status != INDEX_NOTTESTED ) continue;
 177
 178                         IndexFile indexfile(mwindow, indexable);
 179                         int ret = indexfile.open_index();
 180                         if( !ret ) {
 181                                 indexfile.close_index();
 182 // use existing index
 183                                 index_state->index_status = INDEX_READY;
 184                                 if(mwindow->gui) mwindow->gui->lock_window("MainIndexes::run 2");
 185                                 mwindow->edl->set_index_file(indexable);
 186                                 if(mwindow->gui) mwindow->gui->unlock_window();
 187                                 continue;
 188                         }
 189 // Doesn't exist
 190                         if( !progress ) {
 191                                 if(mwindow->gui) mwindow->gui->lock_window("MainIndexes::run 1");
 192                                 progress = mwindow->mainprogress->start_progress(_("Building Indexes..."), 1);
 193                                 if(mwindow->gui) mwindow->gui->unlock_window();
 194                         }
 195 // only if audio tracks
 196                         indexfile.create_index(progress);
 197                         if( progress->is_cancelled() )
 198                                 interrupt_flag = 1;
 199                 }
 200
 201                 if(progress) {  // progress box is only created when an index is built
 202                         if(mwindow->gui) mwindow->gui->lock_window("MainIndexes::run 3");
 203                         progress->stop_progress();
 204                         delete progress;
 205                         if(mwindow->gui) mwindow->gui->unlock_window();
 206                         progress = 0;
 207                 }
 208
 209                 interrupt_lock->unlock();
 210         }
 211 }
 212