cinelerra/filethread.C

   1 #include "asset.h"
   2 #include "bcsignals.h"
   3 #include "condition.h"
   4 #include "file.h"
   5 #include "filethread.h"
   6 #include "mutex.h"
   7 #include "vframe.h"
   8
   9 #include <unistd.h>
  10
  11 FileThread::FileThread(File *file, int do_audio, int do_video)
  12  : Thread(1, 0, 0)
  13 {
  14         reset();
  15         create_objects(file,
  16                 do_audio,
  17                 do_video);
  18 }
  19
  20 FileThread::~FileThread()
  21 {
  22         delete_objects();
  23
  24
  25
  26         delete file_lock;
  27 }
  28
  29 void FileThread::reset()
  30 {
  31         audio_buffer = 0;
  32         video_buffer = 0;
  33         output_size = 0;
  34         input_lock = 0;
  35         output_lock = 0;
  36         last_buffer = 0;
  37 }
  38
  39
  40 void FileThread::create_objects(File *file,
  41                 int do_audio,
  42                 int do_video)
  43 {
  44         this->file = file;
  45         this->do_audio = do_audio;
  46         this->do_video = do_video;
  47         file_lock = new Mutex("FileThread::file_lock");
  48 }
  49
  50
  51 void FileThread::delete_objects()
  52 {
  53         if(output_lock)
  54         {
  55                 for(int i = 0; i < ring_buffers; i++)
  56                 {
  57                         delete output_lock[i];
  58                 }
  59                 delete [] output_lock;
  60         }
  61
  62         if(input_lock)
  63         {
  64                 for(int i = 0; i < ring_buffers; i++)
  65                 {
  66                         delete input_lock[i];
  67                 }
  68                 delete [] input_lock;
  69         }
  70
  71
  72         if(last_buffer)
  73                 delete [] last_buffer;
  74
  75
  76         reset();
  77 }
  78
  79 void FileThread::run()
  80 {
  81         int done = 0;
  82         int i, j, result;
  83
  84         while(!done)
  85         {
  86                 output_lock[local_buffer]->lock("FileThread::run 1");
  87                 return_value = 0;
  88
  89
  90 // Timer timer;
  91 // timer.update();
  92                 if(!last_buffer[local_buffer])
  93                 {
  94                         if(output_size[local_buffer])
  95                         {
  96                                 file_lock->lock("FileThread::run 2");
  97                                 if(do_audio)
  98                                 {
  99 TRACE("FileThread::run 4");
 100                                         result = file->write_samples(audio_buffer[local_buffer],
 101                                                 output_size[local_buffer]);
 102 TRACE("FileThread::run 5");
 103                                 }
 104                                 else
 105                                 if(do_video)
 106                                 {
 107                                         result = 0;
 108                                         if(compressed)
 109                                         {
 110                                                 for(j = 0; j < file->asset->layers && !result; j++)
 111                                                         for(i = 0; i < output_size[local_buffer] && !result; i++)
 112                                                                 result = file->write_compressed_frame(video_buffer[local_buffer][j][i]);
 113                                         }
 114                                         else
 115                                         {
 116                                                 result = file->write_frames(video_buffer[local_buffer],
 117                                                         output_size[local_buffer]);
 118                                         }
 119                                 }
 120
 121                                 file_lock->unlock();
 122                                 return_value = result;
 123                         }
 124                         else
 125                                 return_value = 0;
 126
 127                         output_size[local_buffer] = 0;
 128                 }
 129                 else
 130                         done = 1;
 131
 132                 input_lock[local_buffer]->unlock();
 133                 local_buffer++;
 134                 if(local_buffer >= ring_buffers) local_buffer = 0;
 135         }
 136 }
 137
 138
 139
 140 int FileThread::stop_writing()
 141 {
 142
 143         int i, buffer, layer, frame;
 144
 145         swap_buffer();
 146         input_lock[current_buffer]->lock("FileThread::stop_writing 1");
 147
 148         last_buffer[current_buffer] = 1;
 149
 150         for(i = 0; i < ring_buffers; i++)
 151                 output_lock[i]->unlock();
 152
 153         swap_buffer();
 154
 155 // wait for thread to finish
 156         Thread::join();
 157
 158 // delete buffers
 159         file_lock->lock("FileThread::stop_writing 2");
 160         if(do_audio)
 161         {
 162                 for(buffer = 0; buffer < ring_buffers; buffer++)
 163                 {
 164                         for(i = 0; i < file->asset->channels; i++)
 165                                 delete [] audio_buffer[buffer][i];
 166                         delete [] audio_buffer[buffer];
 167                 }
 168                 delete [] audio_buffer;
 169                 audio_buffer = 0;
 170         }
 171
 172 // printf("FileThread::stop_writing %d %d %d %d\n",
 173 // do_video,
 174 // ring_buffers,
 175 // file->asset->layers,
 176 // buffer_size);
 177         if(do_video)
 178         {
 179                 for(buffer = 0; buffer < ring_buffers; buffer++)
 180                 {
 181                         for(layer = 0; layer < file->asset->layers; layer++)
 182                         {
 183                                 for(frame = 0; frame < buffer_size; frame++)
 184                                 {
 185                                         delete video_buffer[buffer][layer][frame];
 186                                 }
 187                                 delete [] video_buffer[buffer][layer];
 188                         }
 189                         delete [] video_buffer[buffer];
 190                 }
 191                 delete [] video_buffer;
 192                 video_buffer = 0;
 193         }
 194
 195         file_lock->unlock();
 196         return 0;
 197 }
 198
 199 int FileThread::start_writing(long buffer_size,
 200                 int color_model,
 201                 int ring_buffers,
 202                 int compressed)
 203 {
 204 // allocate buffers
 205         int buffer, layer, frame;
 206         long bytes_per_frame;
 207
 208         this->ring_buffers = ring_buffers;
 209         this->buffer_size = buffer_size;
 210         this->color_model = color_model;
 211         this->compressed = compressed;
 212         this->current_buffer = ring_buffers - 1;
 213         return_value = 0;
 214         local_buffer = 0;
 215
 216         file_lock->lock("FileThread::start_writing 1");
 217
 218
 219
 220
 221 // Buffer is swapped before first get
 222         last_buffer = new int[ring_buffers];
 223         output_size = new long[ring_buffers];
 224
 225
 226         output_lock = new Condition*[ring_buffers];
 227         input_lock = new Condition*[ring_buffers];
 228         for(int i = 0; i < ring_buffers; i++)
 229         {
 230                 output_lock[i] = new Condition(0, "FileThread::output_lock");
 231                 input_lock[i] = new Condition(1, "FileThread::input_lock");
 232                 last_buffer[i] = 0;
 233                 output_size[i] = 0;
 234         }
 235
 236
 237
 238         if(do_audio)
 239         {
 240                 audio_buffer = new double**[ring_buffers];
 241                 for(buffer = 0; buffer < ring_buffers; buffer++)
 242                 {
 243                         audio_buffer[buffer] = new double*[file->asset->channels];
 244
 245                         for(int channel = 0; channel < file->asset->channels; channel++)
 246                         {
 247                                 audio_buffer[buffer][channel] = new double[buffer_size];
 248                         }
 249                 }
 250         }
 251
 252         if(do_video)
 253         {
 254                 this->color_model = color_model;
 255                 bytes_per_frame = VFrame::calculate_data_size(file->asset->width,
 256                         file->asset->height,
 257                         -1,
 258                         color_model);
 259
 260                 video_buffer = new VFrame***[ring_buffers];
 261 // printf("FileThread::start_writing 1 %d %d %d %p\n",
 262 // ring_buffers,
 263 // file->asset->layers,
 264 // buffer_size,
 265 // video_buffer);
 266                 for(buffer = 0; buffer < ring_buffers; buffer++)
 267                 {
 268                         video_buffer[buffer] = new VFrame**[file->asset->layers];
 269                         for(layer = 0; layer < file->asset->layers; layer++)
 270                         {
 271                                 video_buffer[buffer][layer] = new VFrame*[buffer_size];
 272                                 for(frame = 0; frame < buffer_size; frame++)
 273                                 {
 274                                         if(compressed)
 275                                                 video_buffer[buffer][layer][frame] = new VFrame;
 276                                         else
 277                                         {
 278                                                 video_buffer[buffer][layer][frame] =
 279                                                         new VFrame(0,
 280                                                                 file->asset->width,
 281                                                                 file->asset->height,
 282                                                                 color_model);
 283 // printf("FileThread::start_writing 4 %d %d %d %p\n",
 284 // buffer,
 285 // layer,
 286 // frame,
 287 // video_buffer[buffer][layer]);
 288                                         }
 289                                 }
 290                         }
 291                 }
 292         }
 293         file_lock->unlock();
 294
 295         for(int i = 0; i < ring_buffers; i++)
 296         {
 297                 last_buffer[i] = 0;
 298         }
 299
 300
 301         start();
 302         return 0;
 303 }
 304
 305 double** FileThread::get_audio_buffer()
 306 {
 307         swap_buffer();
 308
 309         input_lock[current_buffer]->lock("FileThread::get_audio_buffer");
 310         return audio_buffer[current_buffer];
 311 }
 312
 313 VFrame*** FileThread::get_video_buffer()
 314 {
 315         swap_buffer();
 316
 317         input_lock[current_buffer]->lock("FileThread::get_video_buffer");
 318         return video_buffer[current_buffer];
 319 }
 320
 321 int FileThread::write_buffer(long size)
 322 {
 323         output_size[current_buffer] = size;
 324
 325 // unlock the output lock
 326         output_lock[current_buffer]->unlock();
 327
 328         return return_value;
 329 }
 330
 331 int FileThread::swap_buffer()
 332 {
 333         current_buffer++;
 334         if(current_buffer >= ring_buffers) current_buffer = 0;
 335 }