cinelerra-5.1/cinelerra/tracking.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 1997-2014 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 "arender.h"
  23 #include "condition.h"
  24 #include "cplayback.h"
  25 #include "cwindow.h"
  26 #include "cwindowgui.h"
  27 #include "edl.h"
  28 #include "edlsession.h"
  29 #include "levelwindow.h"
  30 #include "levelwindowgui.h"
  31 #include "localsession.h"
  32 #include "mainclock.h"
  33 #include "meterpanel.h"
  34 #include "mwindow.h"
  35 #include "mwindowgui.h"
  36 #include "tracking.h"
  37 #include "patchbay.h"
  38 #include "playbackengine.h"
  39 #include "renderengine.h"
  40 #include "mainsession.h"
  41 #include "trackcanvas.h"
  42
  43
  44
  45 // States
  46 #define PLAYING 0
  47 #define DONE 1
  48
  49
  50
  51 Tracking::Tracking(MWindow *mwindow)
  52  : Thread(1, 0, 0)
  53 {
  54         this->mwindow = mwindow;
  55         state = DONE;
  56         startup_lock = new Condition(0, "Tracking::startup_lock");
  57 }
  58
  59 Tracking::~Tracking()
  60 {
  61         if(state == PLAYING)
  62         {
  63 // Stop loop
  64                 state = DONE;
  65 // Not working in NPTL for some reason
  66 //              Thread::cancel();
  67                 Thread::join();
  68         }
  69
  70
  71         delete startup_lock;
  72 }
  73
  74 void Tracking::create_objects()
  75 {
  76 //      start();
  77 }
  78
  79 int Tracking::start_playback(double new_position)
  80 {
  81         if(state != PLAYING)
  82         {
  83                 last_position = new_position;
  84                 state = PLAYING;
  85                 draw();
  86                 Thread::start();
  87                 startup_lock->lock("Tracking::start_playback");
  88         }
  89         return 0;
  90 }
  91
  92 int Tracking::stop_playback()
  93 {
  94         if(state != DONE)
  95         {
  96 // Stop loop
  97                 state = DONE;
  98 // Not working in NPTL for some reason
  99 //              Thread::cancel();
 100                 Thread::join();
 101
 102 // Final position is updated continuously during playback
 103 // Get final position
 104                 double position = get_tracking_position();
 105 // Update cursor
 106                 update_tracker(position);
 107
 108                 stop_meters();
 109                 state = DONE;
 110         }
 111         return 0;
 112 }
 113
 114 PlaybackEngine* Tracking::get_playback_engine()
 115 {
 116         return mwindow->cwindow->playback_engine;
 117 }
 118
 119 double Tracking::get_tracking_position()
 120 {
 121         return get_playback_engine()->get_tracking_position();
 122 }
 123
 124 void Tracking::update_meters(int64_t position)
 125 {
 126         double output_levels[MAXCHANNELS];
 127         int do_audio = get_playback_engine()->get_output_levels(output_levels, position);
 128
 129         if(do_audio)
 130         {
 131                 module_levels.remove_all();
 132                 get_playback_engine()->get_module_levels(&module_levels, position);
 133
 134                 mwindow->cwindow->gui->lock_window("Tracking::update_meters 1");
 135                 mwindow->cwindow->gui->meters->update(output_levels);
 136                 mwindow->cwindow->gui->unlock_window();
 137
 138                 mwindow->lwindow->gui->lock_window("Tracking::update_meters 2");
 139                 mwindow->lwindow->gui->panel->update(output_levels);
 140                 mwindow->lwindow->gui->unlock_window();
 141
 142                 mwindow->gui->lock_window("Tracking::update_meters 3");
 143                 mwindow->gui->update_meters(&module_levels);
 144                 mwindow->gui->unlock_window();
 145         }
 146 }
 147
 148 void Tracking::stop_meters()
 149 {
 150         mwindow->cwindow->gui->lock_window("Tracking::stop_meters 1");
 151         mwindow->cwindow->gui->meters->stop_meters();
 152         mwindow->cwindow->gui->unlock_window();
 153
 154         mwindow->gui->lock_window("Tracking::stop_meters 2");
 155         mwindow->gui->stop_meters();
 156         mwindow->gui->unlock_window();
 157
 158         mwindow->lwindow->gui->lock_window("Tracking::stop_meters 3");
 159         mwindow->lwindow->gui->panel->stop_meters();
 160         mwindow->lwindow->gui->unlock_window();
 161 }
 162
 163
 164
 165
 166 void Tracking::update_tracker(double position)
 167 {
 168 }
 169
 170 void Tracking::draw()
 171 {
 172 //      gui->lock_window("Tracking::draw");
 173 //      if(!visible)
 174 //      {
 175 //              pixel = get_pixel(last_position);
 176 //      }
 177 //
 178 //      gui->canvas->set_color(GREEN);
 179 //      gui->canvas->set_inverse();
 180 //      gui->canvas->draw_line(pixel, 0, pixel, gui->canvas->get_h());
 181 //      gui->canvas->set_opaque();
 182 //      gui->canvas->flash(pixel, 0, pixel + 1, gui->canvas->get_h());
 183 //      visible ^= 1;
 184 //      gui->unlock_window();
 185 }
 186
 187
 188 void Tracking::run()
 189 {
 190         startup_lock->unlock();
 191
 192         double position;
 193         while(state != DONE)
 194         {
 195                 Thread::enable_cancel();
 196                 timer.delay(1000 / TRACKING_RATE);
 197                 Thread::disable_cancel();
 198
 199                 if(state != DONE)
 200                 {
 201
 202 // can be stopped during wait
 203                         if(get_playback_engine()->tracking_active)
 204                         {
 205 // Get position of cursor
 206                                 position = get_tracking_position();
 207
 208 // Update cursor
 209                                 update_tracker(position);
 210                         }
 211                 }
 212         }
 213 }
 214
 215
 216
 217
 218