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