fixup ffmpeg create filter seperator list, repair track title xml blunder
[goodguy/history.git] / cinelerra-5.1 / cinelerra / resourcethread.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 "asset.h"
24 #include "bcsignals.h"
25 #include "bctimer.h"
26 #include "cache.h"
27 #include "clip.h"
28 #include "condition.h"
29 #include "datatype.h"
30 #include "edl.h"
31 #include "edlsession.h"
32 #include "file.h"
33 #include "framecache.h"
34 #include "mutex.h"
35 #include "mwindow.h"
36 #include "mwindowgui.h"
37 #include "renderengine.h"
38 #include "resourcethread.h"
39 #include "resourcepixmap.h"
40 #include "samples.h"
41 #include "timelinepane.h"
42 #include "trackcanvas.h"
43 #include "transportque.h"
44 #include "vframe.h"
45 #include "vrender.h"
46 #include "wavecache.h"
47
48
49 #include <unistd.h>
50
51 ResourceThreadItem::ResourceThreadItem(ResourcePixmap *pixmap,
52         int pane_number,
53         Indexable *indexable,
54         int data_type,
55         int operation_count)
56 {
57         this->pane_number = pane_number;
58         this->data_type = data_type;
59         this->pixmap = pixmap;
60         this->indexable = indexable;
61
62 // Assets are garbage collected so they don't need to be replicated.
63         this->operation_count = operation_count;
64         indexable->Garbage::add_user();
65         last = 0;
66 }
67
68 ResourceThreadItem::~ResourceThreadItem()
69 {
70         indexable->Garbage::remove_user();
71 }
72
73
74
75
76
77
78
79 VResourceThreadItem::VResourceThreadItem(ResourcePixmap *pixmap,
80         int pane_number,
81         int picon_x,
82         int picon_y,
83         int picon_w,
84         int picon_h,
85         double frame_rate,
86         int64_t position,
87         int layer,
88         Indexable *indexable,
89         int operation_count)
90  : ResourceThreadItem(pixmap,
91         pane_number,
92         indexable,
93         TRACK_VIDEO,
94         operation_count)
95 {
96         this->picon_x = picon_x;
97         this->picon_y = picon_y;
98         this->picon_w = picon_w;
99         this->picon_h = picon_h;
100         this->frame_rate = frame_rate;
101         this->position = position;
102         this->layer = layer;
103 }
104
105 VResourceThreadItem::~VResourceThreadItem()
106 {
107 }
108
109
110
111
112
113
114
115
116 AResourceThreadItem::AResourceThreadItem(ResourcePixmap *pixmap,
117         int pane_number,
118         Indexable *indexable,
119         int x,
120         int channel,
121         int64_t start,
122         int64_t end,
123         int operation_count)
124  : ResourceThreadItem(pixmap,
125         pane_number,
126         indexable,
127         TRACK_AUDIO,
128         operation_count)
129 {
130         this->x = x;
131         this->channel = channel;
132         this->start = start;
133         this->end = end;
134 }
135
136 AResourceThreadItem::~AResourceThreadItem()
137 {
138 }
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156 ResourceThread::ResourceThread(MWindow *mwindow, MWindowGUI *gui)
157  : Thread(1, 0, 0)
158 {
159 //printf("ResourceThread::ResourceThread %d %p\n", __LINE__, this);
160         this->mwindow = mwindow;
161         this->gui = gui;
162         interrupted = 1;
163         done = 1;
164         temp_picon = 0;
165         temp_picon2 = 0;
166         draw_lock = new Condition(0, "ResourceThread::draw_lock", 0);
167 //      interrupted_lock = new Condition(0, "ResourceThread::interrupted_lock", 0);
168         item_lock = new Mutex("ResourceThread::item_lock");
169         audio_buffer = 0;
170         for(int i = 0; i < MAXCHANNELS; i++)
171                 temp_buffer[i] = 0;
172         timer = new Timer;
173         prev_x = -1;
174         prev_h = 0;
175         prev_l = 0;
176         operation_count = 0;
177         render_engine = 0;
178
179         audio_asset = 0;
180         audio_source = 0;
181         video_asset = 0;
182         video_source = 0;
183 }
184
185 ResourceThread::~ResourceThread()
186 {
187         stop();
188         delete draw_lock;
189 //      delete interrupted_lock;
190         delete item_lock;
191         delete temp_picon;
192         delete temp_picon2;
193         delete audio_buffer;
194         for(int i = 0; i < MAXCHANNELS; i++)
195                 delete temp_buffer[i];
196         delete timer;
197         delete render_engine;
198         if( audio_asset ) audio_asset->remove_user();
199         if( video_asset ) video_asset->remove_user();
200 }
201
202 void ResourceThread::create_objects()
203 {
204         done = 0;
205         Thread::start();
206 }
207
208 void ResourceThread::add_picon(ResourcePixmap *pixmap,
209         int pane_number,
210         int picon_x,
211         int picon_y,
212         int picon_w,
213         int picon_h,
214         double frame_rate,
215         int64_t position,
216         int layer,
217         Indexable *indexable)
218 {
219         item_lock->lock("ResourceThread::item_lock");
220
221         items.append(new VResourceThreadItem(pixmap,
222                 pane_number,
223                 picon_x,
224                 picon_y,
225                 picon_w,
226                 picon_h,
227                 frame_rate,
228                 position,
229                 layer,
230                 indexable,
231                 operation_count));
232         item_lock->unlock();
233 }
234
235 void ResourceThread::add_wave(ResourcePixmap *pixmap,
236         int pane_number,
237         Indexable *indexable,
238         int x,
239         int channel,
240         int64_t source_start,
241         int64_t source_end)
242 {
243         item_lock->lock("ResourceThread::item_lock");
244
245         items.append(new AResourceThreadItem(pixmap,
246                 pane_number,
247                 indexable,
248                 x,
249                 channel,
250                 source_start,
251                 source_end,
252                 operation_count));
253         item_lock->unlock();
254 }
255
256
257
258
259
260
261
262
263
264
265
266 void ResourceThread::stop_draw(int reset)
267 {
268         if(!interrupted)
269         {
270                 interrupted = 1;
271                 item_lock->lock("ResourceThread::stop_draw");
272
273 //printf("ResourceThread::stop_draw %d %d\n", __LINE__, reset);
274 //BC_Signals::dump_stack();
275                 if(reset) items.remove_all_objects();
276                 operation_count++;
277                 item_lock->unlock();
278                 prev_x = -1;
279                 prev_h = 0;
280                 prev_l = 0;
281         }
282 }
283
284 void ResourceThread::start_draw()
285 {
286         interrupted = 0;
287 // Tag last audio item to cause refresh.
288         int i = items.total;
289         while( --i>=0 && items[i]->data_type!=TRACK_AUDIO );
290         if( i >= 0 ) items[i]->last = 1;
291         timer->update();
292         draw_lock->unlock();
293 }
294
295 void ResourceThread::run()
296 {
297         while(!done)
298         {
299
300                 draw_lock->lock("ResourceThread::run");
301
302                 while(!interrupted)
303                 {
304 // Pull off item
305                         item_lock->lock("ResourceThread::run");
306                         int total_items = items.size();
307                         ResourceThreadItem *item = 0;
308                         if(items.size())
309                         {
310                                 item = items[0];
311                                 items.remove_number(0);
312                         }
313                         item_lock->unlock();
314 //printf("ResourceThread::run %d %d\n", __LINE__, items.size());
315                         if(!total_items) break;
316
317                         switch( item->data_type ) {
318                         case TRACK_VIDEO:
319                                 do_video((VResourceThreadItem*)item);
320                                 break;
321                         case TRACK_AUDIO:
322                                 do_audio((AResourceThreadItem*)item);
323                                 break;
324                         }
325
326                         delete item;
327                 }
328
329                 get_audio_source(0);
330                 get_video_source(0);
331                 mwindow->age_caches();
332         }
333 }
334
335 void ResourceThread::stop()
336 {
337         if( !done ) {
338                 done = 1;
339                 interrupted = 1;
340                 draw_lock->unlock();
341         }
342         join();
343 }
344
345
346 void ResourceThread::open_render_engine(EDL *nested_edl,
347         int do_audio,
348         int do_video)
349 {
350         if(render_engine && render_engine_id != nested_edl->id)
351         {
352                 delete render_engine;
353                 render_engine = 0;
354         }
355
356         if(!render_engine)
357         {
358                 TransportCommand command;
359                 if(do_audio)
360                         command.command = NORMAL_FWD;
361                 else
362                         command.command = CURRENT_FRAME;
363                 command.get_edl()->copy_all(nested_edl);
364                 command.change_type = CHANGE_ALL;
365                 command.realtime = 0;
366                 render_engine = new RenderEngine(0,
367                         mwindow->preferences, 0, 0);
368                 render_engine_id = nested_edl->id;
369                 render_engine->set_vcache(mwindow->video_cache);
370                 render_engine->set_acache(mwindow->audio_cache);
371                 render_engine->arm_command(&command);
372         }
373 }
374
375 File *ResourceThread::get_audio_source(Asset *asset)
376 {
377         if( interrupted ) asset = 0;
378
379         if( audio_asset && audio_asset != asset && (!asset ||
380                 strcmp(audio_asset->path, asset->path)) )
381         {
382                 mwindow->audio_cache->check_in(audio_asset);
383                 audio_source = 0;
384                 audio_asset->remove_user();
385                 audio_asset = 0;
386
387         }
388         if( !audio_asset && asset )
389         {
390                 audio_asset = asset;
391                 audio_asset->add_user();
392                 audio_source = mwindow->audio_cache->check_out(asset, mwindow->edl);
393         }
394         return audio_source;
395 }
396
397 File *ResourceThread::get_video_source(Asset *asset)
398 {
399         if( interrupted ) asset = 0;
400
401         if( video_asset && video_asset != asset && (!asset ||
402                 strcmp(video_asset->path, asset->path)) )
403         {
404                 mwindow->video_cache->check_in(video_asset);
405                 video_source = 0;
406                 video_asset->remove_user();
407                 video_asset = 0;
408
409         }
410         if( !video_asset && asset )
411         {
412                 video_asset = asset;
413                 video_asset->add_user();
414                 video_source = mwindow->video_cache->check_out(asset, mwindow->edl);
415         }
416         return video_source;
417 }
418
419 void ResourceThread::do_video(VResourceThreadItem *item)
420 {
421         int source_w = 0;
422         int source_h = 0;
423         int source_id = -1;
424         int source_cmodel = -1;
425
426         if(item->indexable->is_asset)
427         {
428                 Asset *asset = (Asset*)item->indexable;
429                 source_w = asset->width;
430                 source_h = asset->height;
431                 source_id = asset->id;
432                 source_cmodel = BC_RGB888;
433         }
434         else
435         {
436                 EDL *nested_edl = (EDL*)item->indexable;
437                 source_w = nested_edl->session->output_w;
438                 source_h = nested_edl->session->output_h;
439                 source_id = nested_edl->id;
440                 source_cmodel = nested_edl->session->color_model;
441         }
442
443         if(temp_picon &&
444                 (temp_picon->get_w() != source_w ||
445                 temp_picon->get_h() != source_h ||
446                 temp_picon->get_color_model() != source_cmodel))
447         {
448                 delete temp_picon;
449                 temp_picon = 0;
450         }
451
452         if(!temp_picon)
453         {
454                 temp_picon = new VFrame(0,
455                         -1,
456                         source_w,
457                         source_h,
458                         source_cmodel,
459                         -1);
460         }
461
462 // Get temporary to copy cached frame to
463         if(temp_picon2 &&
464                 (temp_picon2->get_w() != item->picon_w ||
465                 temp_picon2->get_h() != item->picon_h))
466         {
467                 delete temp_picon2;
468                 temp_picon2 = 0;
469         }
470
471         if(!temp_picon2)
472         {
473                 temp_picon2 = new VFrame(0,
474                         -1,
475                         item->picon_w,
476                         item->picon_h,
477                         BC_RGB888,
478                         -1);
479         }
480
481
482
483 // Search frame cache again.
484
485         VFrame *picon_frame = 0;
486         int need_conversion = 0;
487         EDL *nested_edl = 0;
488         Asset *asset = 0;
489
490         picon_frame = mwindow->frame_cache->get_frame_ptr(item->position,
491                 item->layer,
492                 item->frame_rate,
493                 BC_RGB888,
494                 item->picon_w,
495                 item->picon_h,
496                 source_id);
497 //printf("search cache %ld,%d,%f,%dx%d,%d = %p\n",
498 //  item->position, item->layer, item->frame_rate,
499 //  item->picon_w, item->picon_h, source_id, picon_frame);
500         if( picon_frame )
501         {
502                 temp_picon2->copy_from(picon_frame);
503 // Unlock the get_frame_ptr command
504                 mwindow->frame_cache->unlock();
505         }
506         else
507         if(!item->indexable->is_asset)
508         {
509                 nested_edl = (EDL*)item->indexable;
510                 open_render_engine(nested_edl, 0, 1);
511
512                 int64_t source_position = (int64_t)(item->position *
513                         nested_edl->session->frame_rate /
514                         item->frame_rate);
515                 if(render_engine->vrender)
516                         render_engine->vrender->process_buffer(
517                                 temp_picon,
518                                 source_position,
519                                 0);
520
521                 need_conversion = 1;
522         }
523         else
524         {
525                 asset = (Asset*)item->indexable;
526                 File *source = get_video_source(asset);
527                 if(!source)
528                         return;
529
530                 source->set_layer(item->layer);
531                 int64_t normalized_position = (int64_t)(item->position *
532                         asset->frame_rate /
533                         item->frame_rate);
534                 source->set_video_position(normalized_position,
535                         0);
536
537                 source->read_frame(temp_picon);
538
539                 need_conversion = 1;
540         }
541
542         if(need_conversion)
543         {
544                 picon_frame = new VFrame(0,
545                         -1,
546                         item->picon_w,
547                         item->picon_h,
548                         BC_RGB888,
549                         -1);
550                 BC_CModels::transfer(picon_frame->get_rows(),
551                         temp_picon->get_rows(),
552                         0,
553                         0,
554                         0,
555                         0,
556                         0,
557                         0,
558                         0,
559                         0,
560                         temp_picon->get_w(),
561                         temp_picon->get_h(),
562                         0,
563                         0,
564                         picon_frame->get_w(),
565                         picon_frame->get_h(),
566                         source_cmodel,
567                         BC_RGB888,
568                         0,
569                         temp_picon->get_bytes_per_line(),
570                         picon_frame->get_bytes_per_line());
571                 temp_picon2->copy_from(picon_frame);
572                 mwindow->frame_cache->put_frame(picon_frame,
573                         item->position,
574                         item->layer,
575                         mwindow->edl->session->frame_rate,
576                         0,
577                         item->indexable);
578         }
579
580 // Allow escape here
581         if(interrupted)
582         {
583                 return;
584         }
585
586
587 // Draw the picon
588         mwindow->gui->lock_window("ResourceThread::do_video");
589
590 // It was interrupted while waiting.
591         if(interrupted)
592         {
593                 mwindow->gui->unlock_window();
594                 return;
595         }
596
597
598
599 // Test for pixmap existence first
600         if(item->operation_count == operation_count)
601         {
602                 ArrayList<ResourcePixmap*> &resource_pixmaps = gui->resource_pixmaps;
603                 int i = resource_pixmaps.total;
604                 while( --i >= 0 && resource_pixmaps[i] != item->pixmap );
605                 if( i >= 0 ) {
606                         item->pixmap->draw_vframe(temp_picon2,
607                                 item->picon_x,
608                                 item->picon_y,
609                                 item->picon_w,
610                                 item->picon_h,
611                                 0,
612                                 0);
613
614                         mwindow->gui->update(0, IGNORE_THREAD, 0, 0, 0, 0, 0);
615                 }
616         }
617
618         mwindow->gui->unlock_window();
619 }
620
621
622 #define BUFFERSIZE 65536
623 void ResourceThread::do_audio(AResourceThreadItem *item)
624 {
625 // Search again
626         WaveCacheItem *wave_item;
627         double high = 0;
628         double low = 0;
629         const int debug = 0;
630         if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
631         if((wave_item = mwindow->wave_cache->get_wave(item->indexable->id,
632                 item->channel, item->start, item->end)))
633         {
634                 high = wave_item->high;
635                 low = wave_item->low;
636                 mwindow->wave_cache->unlock();
637         }
638         else
639         {
640                 int first_sample = 1;
641                 int64_t start = item->start;
642                 int64_t end = item->end;
643                 if(start == end) end = start + 1;
644                 double *buffer_samples = !audio_buffer ? 0 :
645                         audio_buffer->get_data();
646
647                 if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
648                 for(int64_t sample = start; sample < end; sample++)
649                 {
650                         double value;
651 // Get value from previous buffer
652                         if(audio_buffer &&
653                                 item->channel == audio_channel &&
654                                 item->indexable->id == audio_asset_id &&
655                                 sample >= audio_start &&
656                                 sample < audio_start + audio_samples)
657                         {
658                                 ;
659                         }
660                         else
661 // Load new buffer
662                         {
663                                 if(!audio_buffer) {
664                                         audio_buffer = new Samples(BUFFERSIZE);
665                                         buffer_samples = audio_buffer->get_data();
666                                 }
667
668                                 int64_t total_samples = item->indexable->get_audio_samples();
669                                 int fragment = BUFFERSIZE;
670                                 if(fragment + sample > total_samples)
671                                         fragment = total_samples - sample;
672
673                                 if(!item->indexable->is_asset)
674                                 {
675                                         if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
676                                         open_render_engine((EDL*)item->indexable, 1, 0);
677                                         if(debug) printf("ResourceThread::do_audio %d %p\n", __LINE__, render_engine);
678                                         if(render_engine->arender)
679                                         {
680                                                 if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
681                                                 int source_channels = item->indexable->get_audio_channels();
682                                                 if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
683                                                 for(int i = 0; i < MAXCHANNELS; i++)
684                                                 {
685                                                         if(i < source_channels &&
686                                                                 !temp_buffer[i])
687                                                         {
688                                                                 temp_buffer[i] = new Samples(BUFFERSIZE);
689                                                         }
690                                                         else
691                                                         if(i >= source_channels &&
692                                                                 temp_buffer[i])
693                                                         {
694                                                                 delete temp_buffer[i];
695                                                                 temp_buffer[i] = 0;
696                                                         }
697                                                 }
698
699
700                                                 if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
701                                                 render_engine->arender->process_buffer(
702                                                         temp_buffer,
703                                                         fragment,
704                                                         sample);
705                                                 if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
706                                                 memcpy(buffer_samples,
707                                                         temp_buffer[item->channel]->get_data(),
708                                                         fragment * sizeof(double));
709                                         }
710                                         else
711                                         {
712                                                 if(debug) printf("ResourceThread::do_audio %d %d\n", __LINE__, fragment);
713                                                 if(fragment > 0) bzero(buffer_samples, sizeof(double) * fragment);
714                                                 if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
715
716                                         }
717                                 }
718                                 else
719                                 {
720                                         Asset *asset = (Asset*)item->indexable;
721                                         File *source = get_audio_source(asset);
722                                         if(!source)
723                                                 return;
724
725                                         source->set_channel(item->channel);
726                                         source->set_audio_position(sample);
727                                         source->read_samples(audio_buffer, fragment);
728                                 }
729
730                                 audio_asset_id = item->indexable->id;
731                                 audio_channel = item->channel;
732                                 audio_start = sample;
733                                 audio_samples = fragment;
734                         }
735
736
737                         value = buffer_samples[sample - audio_start];
738                         if(first_sample)
739                         {
740                                 high = low = value;
741                                 first_sample = 0;
742                         }
743                         else
744                         {
745                                 if(value > high)
746                                         high = value;
747                                 else
748                                 if(value < low)
749                                         low = value;
750                         }
751                 }
752                 if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
753
754 // If it's a nested EDL, store all the channels
755                 mwindow->wave_cache->put_wave(item->indexable,
756                         item->channel,
757                         item->start,
758                         item->end,
759                         high,
760                         low);
761                 if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
762         }
763         if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
764
765 // Allow escape here
766         if(interrupted)
767                 return;
768
769         if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
770 // Draw the column
771         mwindow->gui->lock_window("ResourceThread::do_audio");
772         if(interrupted)
773         {
774                 mwindow->gui->unlock_window();
775                 return;
776         }
777
778         if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
779         if(item->operation_count == operation_count)
780         {
781
782 // Test for pixmap existence first
783                 ArrayList<ResourcePixmap*> &resource_pixmaps = gui->resource_pixmaps;
784                 int i = resource_pixmaps.total;
785                 while( --i >= 0 && resource_pixmaps[i] != item->pixmap );
786                 if( i >= 0 )
787                 {
788                         if(prev_x == item->x - 1)
789                         {
790                                 high = MAX(high, prev_l);
791                                 low = MIN(low, prev_h);
792                         }
793                         prev_x = item->x;
794                         prev_h = high;
795                         prev_l = low;
796                         if(gui->pane[item->pane_number])
797                                 item->pixmap->draw_wave(
798                                         gui->pane[item->pane_number]->canvas,
799                                         item->x,
800                                         high,
801                                         low);
802                         if(timer->get_difference() > 250 || item->last)
803                         {
804                                 mwindow->gui->update(0, 3, 0, 0, 0, 0, 0);
805                                 timer->update();
806                         }
807                 }
808         }
809         if(debug) printf("ResourceThread::do_audio %d\n", __LINE__);
810
811         mwindow->gui->unlock_window();
812
813 }
814
815
816
817