add bluray dv, misc fixes
[goodguy/history.git] / cinelerra-5.1 / cinelerra / packagerenderer.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 "arender.h"
23 #include "asset.h"
24 #include "auto.h"
25 #include "bctimer.h"
26 #include "brender.h"
27 #include "cache.h"
28 #include "clip.h"
29 #include "cwindow.h"
30 #include "cwindowgui.h"
31 #include "edit.h"
32 #include "edits.h"
33 #include "edl.h"
34 #include "edlsession.h"
35 #include "errorbox.h"
36 #include "file.h"
37 #include "filesystem.h"
38 #include "indexfile.h"
39 #include "language.h"
40 #include "mwindow.h"
41 #include "mwindowgui.h"
42 #include "packagerenderer.h"
43 #include "playabletracks.h"
44 #include "playbackconfig.h"
45 #include "pluginserver.h"
46 #include "preferences.h"
47 #include "render.h"
48 #include "renderengine.h"
49 #include "renderfarmfsserver.h"
50 #include "samples.h"
51 #include "sighandler.h"
52 #include "tracks.h"
53 #include "transportque.h"
54 #include "vedit.h"
55 #include "vframe.h"
56 #include "videodevice.h"
57 #include "vrender.h"
58
59
60
61
62
63
64
65 RenderPackage::RenderPackage()
66 {
67         audio_start = 0;
68         audio_end = 0;
69         video_start = 0;
70         video_end = 0;
71         audio_do = 0;
72         video_do = 0;
73         path[0] = 0;
74         done = 0;
75         use_brender = 0;
76 }
77
78 RenderPackage::~RenderPackage()
79 {
80 }
81
82
83
84
85
86
87
88
89 // Used by RenderFarm and in the future, Render, to do packages.
90 PackageRenderer::PackageRenderer()
91 {
92         command = 0;
93         audio_cache = 0;
94         video_cache = 0;
95         aconfig = 0;
96         vconfig = 0;
97         timer = new Timer;
98         frames_per_second = 0;
99 }
100
101 PackageRenderer::~PackageRenderer()
102 {
103         delete command;
104         delete audio_cache;
105         delete video_cache;
106         delete vconfig;
107         delete aconfig;
108 }
109
110 // PackageRenderer::initialize happens only once for every node when doing rendering session
111 // This is not called for each package!
112
113 int PackageRenderer::initialize(MWindow *mwindow,
114                 EDL *edl,
115                 Preferences *preferences,
116                 Asset *default_asset)
117 {
118         int result = 0;
119
120         this->mwindow = mwindow;
121         this->edl = edl;
122         this->preferences = preferences;
123         this->default_asset = default_asset;
124
125
126 //printf("PackageRenderer::initialize %d\n", preferences->processors);
127         command = new TransportCommand;
128         command->command = NORMAL_FWD;
129         command->get_edl()->copy_all(edl);
130         command->change_type = CHANGE_ALL;
131         command->set_playback_range(edl);
132
133         default_asset->frame_rate = command->get_edl()->session->frame_rate;
134         default_asset->sample_rate = command->get_edl()->session->sample_rate;
135         default_asset->aspect_ratio = (double)command->get_edl()->session->aspect_w /
136                 command->get_edl()->session->aspect_h;
137         result = Render::check_asset(edl, *default_asset);
138
139         audio_cache = new CICache(preferences);
140         video_cache = new CICache(preferences);
141
142         //PlaybackConfig *config = command->get_edl()->session->playback_config;
143         aconfig = new AudioOutConfig();
144         vconfig = new VideoOutConfig;
145
146         return result;
147 }
148
149 void PackageRenderer::create_output()
150 {
151         FileSystem fs;
152         asset = new Asset(*default_asset);
153
154         if(!get_master() && preferences->renderfarm_vfs && preferences->use_renderfarm)
155                 sprintf(asset->path, RENDERFARM_FS_PREFIX "%s", package->path);
156         else
157                 strcpy(asset->path, package->path);
158
159         file = new File;
160
161         file->set_processors(preferences->processors);
162
163 //printf("PackageRenderer::create_output %d\n", __LINE__);
164         result = file->open_file(preferences,
165                                         asset,
166                                         0,
167                                         1);
168 //printf("PackageRenderer::create_output %d %d\n", __LINE__, result);
169
170         if(result && mwindow)
171         {
172 // open failed
173                 char string[BCTEXTLEN];
174                 sprintf(string, _("Couldn't open %s"), asset->path);
175                 ErrorBox error(_(PROGRAM_NAME ": Error"),
176                         mwindow->gui->get_abs_cursor_x(1),
177                         mwindow->gui->get_abs_cursor_y(1));
178                 error.create_objects(string);
179                 error.run_window();
180         }
181         else
182         if(mwindow)
183         {
184                 mwindow->sighandler->push_file(file);
185                 IndexFile::delete_index(preferences, asset);
186         }
187 //printf("PackageRenderer::create_output %d %d\n", __LINE__, result);
188 }
189
190 void PackageRenderer::create_engine()
191 {
192 // Fix audio buffers to 1 second
193         audio_read_length = command->get_edl()->session->sample_rate;
194         command->get_edl()->session->playback_config->aconfig->fragment_size = audio_read_length;
195
196         aconfig->fragment_size = audio_read_length;
197
198
199         render_engine = new RenderEngine(0, preferences, 0, 0);
200         render_engine->set_acache(audio_cache);
201         render_engine->set_vcache(video_cache);
202         render_engine->arm_command(command);
203
204         if(package->use_brender)
205         {
206                 audio_preroll = Units::to_int64((double)preferences->brender_preroll /
207                         default_asset->frame_rate *
208                         default_asset->sample_rate);
209                 video_preroll = preferences->brender_preroll;
210         }
211         else
212         {
213                 audio_preroll = Units::to_int64(preferences->render_preroll *
214                         default_asset->sample_rate);
215                 video_preroll = Units::to_int64(preferences->render_preroll *
216                         default_asset->frame_rate);
217         }
218         audio_position = package->audio_start - audio_preroll;
219         if( audio_position < 0 )
220         {
221                 audio_preroll += audio_position;
222                 audio_position = 0;
223         }
224         video_position = package->video_start - video_preroll;
225         if( video_position < 0 )
226         {
227                 video_preroll += video_position;
228                 video_position = 0;
229         }
230
231
232 //      PRINT_TRACE
233
234 // Create output buffers
235         if(asset->audio_data)
236         {
237                 file->start_audio_thread(audio_read_length,
238                         preferences->processors > 1 ? 2 : 1);
239         }
240
241 //      PRINT_TRACE
242
243         if(asset->video_data)
244         {
245                 compressed_output = new VFrame;
246 // The write length needs to correlate with the processor count because
247 // it is passed to the file handler which usually processes frames simultaneously.
248                 video_write_length = preferences->processors;
249                 video_write_position = 0;
250                 direct_frame_copying = 0;
251
252
253 //printf("PackageRenderer::create_engine %d\n", __LINE__);
254                 file->start_video_thread(video_write_length,
255                         command->get_edl()->session->color_model,
256                         preferences->processors > 1 ? 2 : 1,
257                         0);
258 //printf("PackageRenderer::create_engine %d\n", __LINE__);
259
260
261                 if(mwindow)
262                 {
263                         video_device = new VideoDevice;
264                         video_device->open_output(vconfig,
265                                 command->get_edl()->session->frame_rate,
266                                 command->get_edl()->session->output_w,
267                                 command->get_edl()->session->output_h,
268                                 mwindow->cwindow->gui->canvas,
269                                 0);
270 //                      video_device->start_playback();
271                 }
272         }
273
274
275         playable_tracks = new PlayableTracks(render_engine->get_edl(),
276                 video_position,
277                 PLAY_FORWARD,
278                 TRACK_VIDEO,
279                 1);
280
281 }
282
283
284
285
286 void PackageRenderer::do_audio()
287 {
288 //printf("PackageRenderer::do_audio %d\n", __LINE__);
289 // Do audio data
290         if(asset->audio_data)
291         {
292                 audio_output = file->get_audio_buffer();
293 // Zero unused channels in output vector
294                 for(int i = 0; i < MAX_CHANNELS; i++)
295                 {
296                         audio_output_ptr[i] = (i < asset->channels) ?
297                                 audio_output[i] :
298                                 0;
299                 }
300
301
302
303 // Call render engine
304
305                 result = render_engine->arender->process_buffer(audio_output_ptr,
306                         audio_read_length,
307                         audio_position);
308
309
310
311 // Fix buffers for preroll
312                 int64_t output_length = audio_read_length;
313                 if(audio_preroll > 0)
314                 {
315                         if(audio_preroll >= output_length)
316                                 output_length = 0;
317                         else
318                         {
319                                 output_length -= audio_preroll;
320                                 for(int i = 0; i < MAX_CHANNELS; i++)
321                                 {
322                                         if(audio_output_ptr[i])
323                                         {
324                                                 double *data = audio_output_ptr[i]->get_data();
325                                                 for(int j = 0; j < output_length; j++)
326                                                 {
327                                                         data[j] = data[j + audio_read_length - output_length];
328                                                 }
329                                         }
330                                 }
331                         }
332 //printf("PackageRenderer::do_audio 4\n");
333
334                         audio_preroll -= audio_read_length;
335                 }
336
337 // Must perform writes even if 0 length so get_audio_buffer doesn't block
338                 result |= file->write_audio_buffer(output_length);
339         }
340
341         audio_position += audio_read_length;
342 //printf("PackageRenderer::do_audio %d\n", __LINE__);
343 }
344
345
346 void PackageRenderer::do_video()
347 {
348         const int debug = 0;
349 // Do video data
350         if(asset->video_data)
351         {
352 // get the absolute video position from the audio position
353                 int64_t video_end = video_position + video_read_length;
354
355                 if(video_end > package->video_end)
356                         video_end = package->video_end;
357
358                 while(video_position < video_end && !result)
359                 {
360 // Try to copy the compressed frame directly from the input to output files
361 //printf("PackageRenderer::do_video 2 video_position=%ld\n", video_position);
362                         if(direct_frame_copy(command->get_edl(),
363                                 video_position,
364                                 file,
365                                 result))
366                         {
367 // Direct frame copy failed.
368 // Switch back to background compression
369                                 if(direct_frame_copying)
370                                 {
371
372                                         file->start_video_thread(video_write_length,
373                                                 command->get_edl()->session->color_model,
374                                                 preferences->processors > 1 ? 2 : 1,
375                                                 0);
376 //printf("PackageRenderer::do_video %d %d\n", __LINE__, preferences->processors);
377                                         direct_frame_copying = 0;
378                                 }
379
380 // Try to use the rendering engine to write the frame.
381 // Get a buffer for background writing.
382
383                                 if(video_write_position == 0)
384                                         video_output = file->get_video_buffer();
385
386                                 if(debug) printf("PackageRenderer::do_video %d %p\n", __LINE__, video_output);
387                                 if(debug) printf("PackageRenderer::do_video %d %p\n", __LINE__, video_output[0]);
388
389
390
391
392 // Construct layered output buffer
393                                 video_output_ptr = video_output[0][video_write_position];
394                                 if(debug)
395                                 {
396                                         printf("PackageRenderer::do_video %d %p\n", __LINE__, video_output_ptr);
397                                         printf("PackageRenderer::do_video %d %d\n", __LINE__, result);
398                                         video_output_ptr->dump();
399                                 }
400
401                                 if(!result)
402                                         result = render_engine->vrender->process_buffer(
403                                                 video_output_ptr,
404                                                 video_position,
405                                                 0);
406
407
408                                 if(debug) printf("PackageRenderer::do_video %d %d\n", __LINE__, result);
409
410                                 if(!result &&
411                                         mwindow &&
412                                         video_device->output_visible())
413                                 {
414 // Vector for video device
415                                         VFrame *preview_output;
416
417                                         video_device->new_output_buffer(&preview_output,
418                                                 command->get_edl()->session->color_model);
419
420                                         preview_output->copy_from(video_output_ptr);
421                                         video_device->write_buffer(preview_output,
422                                                 command->get_edl());
423                                 }
424
425                                 if(debug) printf("PackageRenderer::do_video %d %d\n", __LINE__, result);
426
427
428 // Don't write to file
429                                 if(video_preroll && !result)
430                                 {
431                                         video_preroll--;
432 // Keep the write position at 0 until ready to write real frames
433                                         result = file->write_video_buffer(0);
434                                         video_write_position = 0;
435                                 }
436                                 else
437                                 if(!result)
438                                 {
439 // Set background rendering parameters
440 // Allow us to skip sections of the output file by setting the frame number.
441 // Used by background render and render farm.
442 //printf("PackageRenderer::do_video %d %jd\n", __LINE__, video_position);
443                                         video_output_ptr->set_number(video_position);
444                                         video_write_position++;
445
446                                         if(video_write_position >= video_write_length)
447                                         {
448                                                 result = file->write_video_buffer(video_write_position);
449 //printf("PackageRenderer::do_video %d %jd\n", __LINE__, video_position);
450 // Update the brender map after writing the files.
451                                                 if(package->use_brender)
452                                                 {
453 //printf("PackageRenderer::do_video 10\n");
454                                                         for(int i = 0; i < video_write_position && !result; i++)
455                                                         {
456                                                                 result = set_video_map(video_position + 1 - video_write_position + i,
457                                                                         BRender::RENDERED);
458                                                         }
459 //printf("PackageRenderer::do_video 11 %d\n", result);
460                                                 }
461                                                 video_write_position = 0;
462                                         }
463                                 }
464 //printf("PackageRenderer::do_video %d %jd\n", __LINE__, video_position);
465
466
467                         }
468
469                         video_position++;
470                         if(!result && get_result()) result = 1;
471                         if(!result && progress_cancelled()) result = 1;
472                 }
473         }
474         else
475         {
476                 video_position += video_read_length;
477         }
478 }
479
480
481 void PackageRenderer::stop_engine()
482 {
483         delete render_engine;
484         delete playable_tracks;
485 }
486
487
488 void PackageRenderer::stop_output()
489 {
490         int error = 0;
491         if(asset->audio_data)
492         {
493 // stop file I/O
494                 file->stop_audio_thread();
495         }
496
497         if(asset->video_data)
498         {
499                 delete compressed_output;
500                 if(video_write_position)
501                         file->write_video_buffer(video_write_position);
502                 if(package->use_brender)
503                 {
504                         for(int i = 0; i < video_write_position && !error; i++)
505                         {
506                                 error = set_video_map(video_position - video_write_position + i,
507                                         BRender::RENDERED);
508                         }
509                 }
510                 video_write_position = 0;
511                 if(!error) file->stop_video_thread();
512                 if(mwindow)
513                 {
514 //                      video_device->stop_playback();
515                         video_device->close_all();
516                         delete video_device;
517                 }
518         }
519 }
520
521
522 void PackageRenderer::close_output()
523 {
524         if(mwindow)
525                 mwindow->sighandler->pull_file(file);
526         file->close_file();
527         delete file;
528         asset->Garbage::remove_user();
529 }
530
531 // Aborts and returns 1 if an error is encountered.
532 int PackageRenderer::render_package(RenderPackage *package)
533 {
534         int audio_done = 0;
535         int video_done = 0;
536         int samples_rendered = 0;
537         const int debug = 0;
538
539
540         result = 0;
541         this->package = package;
542
543 // printf(
544 // "PackageRenderer::render_package: audio s=%jd l=%jd video s=%jd l=%jd\n",
545 //      package->audio_start,
546 //      package->audio_end - package->audio_start,
547 //      package->video_start,
548 //      package->video_end - package->video_start);
549
550         if(debug) PRINT_TRACE
551
552         if( package->video_do ) default_asset->video_data = 1;
553         if( package->audio_do ) default_asset->audio_data = 1;
554         Render::check_asset(edl, *default_asset);
555
556 // FIXME: The design that we only get EDL once does not give us neccessary flexiblity to do things the way they should be donek
557         default_asset->video_data = package->video_do;
558         default_asset->audio_data = package->audio_do;
559         Render::check_asset(edl, *default_asset);
560
561         create_output();
562         if(debug) PRINT_TRACE
563
564         if(!asset->video_data) video_done = 1;
565         if(!asset->audio_data) audio_done = 1;
566
567 // Create render engine
568         if(!result)
569         {
570 if(debug) PRINT_TRACE
571                 create_engine();
572 if(debug) PRINT_TRACE
573
574
575 // Main loop
576                 timer->update();
577                 total_samples_rendered = 0;
578                 while((!audio_done || !video_done) && !result)
579                 {
580                         int need_audio = 0, need_video = 0;
581
582
583
584
585 // Calculate lengths to process.  Audio fragment is constant.
586                         if(!audio_done)
587                         {
588                                 if(audio_position + audio_read_length >= package->audio_end)
589                                 {
590                                         audio_done = 1;
591                                         audio_read_length = package->audio_end - audio_position;
592                                 }
593
594                                 samples_rendered = audio_read_length;
595                                 need_audio = 1;
596                         }
597
598 //printf("PackageRenderer::render_package 6 %d\n", samples_rendered);
599
600                         if(!video_done)
601                         {
602                                 if(audio_done)
603                                 {
604 //                                      video_read_length = package->video_end - video_position;
605 // // Packetize video length so progress gets updated
606 //                                      video_read_length = (int)MIN(asset->frame_rate, video_read_length);
607 //                                      video_read_length = MAX(video_read_length, 30);
608                                         video_read_length = 1;
609                                 }
610                                 else
611 // Guide video with audio
612                                 {
613                                         video_read_length = Units::to_int64(
614                                                 (double)(audio_position + audio_read_length) /
615                                                 asset->sample_rate *
616                                                 asset->frame_rate) -
617                                                 video_position;
618                                 }
619
620 // Clamp length
621                                 if(video_position + video_read_length >= package->video_end)
622                                 {
623                                         video_done = 1;
624                                         video_read_length = package->video_end - video_position;
625                                 }
626
627 // Calculate samples rendered for progress bar.
628                                 if(audio_done)
629                                         samples_rendered = Units::round((double)video_read_length /
630                                                 asset->frame_rate *
631                                                 asset->sample_rate);
632
633                                 need_video = 1;
634                         }
635                         if(debug) PRINT_TRACE
636
637                         if(debug) printf("PackageRenderer::render_package 1 %d %jd %jd\n",
638                                         result, audio_read_length, video_read_length);
639                         if(need_video && !result) do_video();
640                         if(debug) printf("PackageRenderer::render_package %d %d %d\n",
641                                         __LINE__, result, samples_rendered);
642                         if(need_audio && !result) do_audio();
643
644
645                         if(debug) PRINT_TRACE
646                         if(!result)
647                         {
648 // Calculate frames per second for the renderfarm table.
649                                 total_samples_rendered += samples_rendered;
650                                 if(!video_done && timer->get_difference() > 30000)
651                                 {
652                                         frames_per_second = (double)total_samples_rendered *
653                                                 asset->frame_rate /
654                                                 asset->sample_rate /
655                                                 ((double)timer->get_difference() / 1000);
656                                 }
657                                 set_progress(samples_rendered);
658                         }
659                         if(debug) PRINT_TRACE
660
661
662
663
664
665                         if(!result && progress_cancelled()) result = 1;
666                         if(debug) PRINT_TRACE
667
668 // printf("PackageRenderer::render_package 10 %d %d %d %d\n",
669 // audio_read_length, video_read_length, samples_rendered, result);
670                         if(result)
671                                 set_result(result);
672                         else
673                                 result = get_result();
674                 }
675
676 // Final FPS readout
677                 frames_per_second = (double)(package->video_end - package->video_start) /
678                         ((double)timer->get_difference() / 1000);
679
680
681 //PRINT_TRACE
682                 stop_engine();
683 //PRINT_TRACE
684
685                 stop_output();
686 //PRINT_TRACE
687
688
689         }
690
691
692 //PRINT_TRACE
693
694         close_output();
695
696 //PRINT_TRACE
697
698         set_result(result);
699 //PRINT_TRACE
700
701
702
703         return result;
704 }
705
706
707
708
709
710
711
712
713 // Try to copy the compressed frame directly from the input to output files
714 // Return 1 on failure and 0 on success
715 int PackageRenderer::direct_frame_copy(EDL *edl,
716         int64_t &video_position,
717         File *file,
718         int &error)
719 {
720         Track *playable_track = 0;
721         Edit *playable_edit = 0;
722
723 //printf("Render::direct_frame_copy 1\n");
724         if(direct_copy_possible(edl,
725                 video_position,
726                 playable_track,
727                 playable_edit,
728                 file))
729         {
730 // Switch to direct copying
731                 if(!direct_frame_copying)
732                 {
733                         if(video_write_position)
734                         {
735                                 error |= file->write_video_buffer(video_write_position);
736                                 video_write_position = 0;
737                         }
738                         file->stop_video_thread();
739                         direct_frame_copying = 1;
740                 }
741 //printf("Render::direct_frame_copy 2\n");
742
743                 if(!package->use_brender)
744                         error |= ((VEdit*)playable_edit)->read_frame(compressed_output,
745                                 video_position,
746                                 PLAY_FORWARD,
747                                 video_cache,
748                                 1,
749                                 0,
750                                 0);
751
752
753                 if(!error && video_preroll > 0)
754                 {
755                         video_preroll--;
756                 }
757                 else
758                 if(!error)
759                 {
760                         if(package->use_brender)
761                         {
762 //printf("PackageRenderer::direct_frame_copy 1\n");
763                                 error = set_video_map(video_position, BRender::SCANNED);
764 //printf("PackageRenderer::direct_frame_copy 10 %d\n", error);
765                         }
766                         else
767                         {
768                                 VFrame ***temp_output = new VFrame**[1];
769                                 temp_output[0] = new VFrame*[1];
770                                 temp_output[0][0] = compressed_output;
771                                 error = file->write_frames(temp_output, 1);
772                                 delete [] temp_output[0];
773                                 delete [] temp_output;
774                         }
775                 }
776                 return 0;
777         }
778         else
779                 return 1;
780 }
781
782 int PackageRenderer::direct_copy_possible(EDL *edl,
783                                 int64_t current_position,
784                                 Track* &playable_track,  // The one track which is playable
785                                 Edit* &playable_edit, // The edit which is playing
786                                 File *file)   // Output file
787 {
788         int result = 1;
789         int total_playable_tracks = 0;
790         Track* current_track;
791
792 // Number of playable tracks must equal 1
793         for(current_track = edl->tracks->first;
794                 current_track && result;
795                 current_track = current_track->next)
796         {
797                 if(current_track->data_type == TRACK_VIDEO)
798                 {
799                         if(playable_tracks->is_playable(current_track,
800                                 current_position,
801                                 PLAY_FORWARD,
802                                 1))
803                         {
804                                 playable_track = current_track;
805                                 total_playable_tracks++;
806                         }
807                 }
808         }
809
810 //printf("Render::direct_copy_possible 1 %d\n", result);
811         if(total_playable_tracks != 1) result = 0;
812 //printf("Render::direct_copy_possible 2 %d\n", result);
813
814 // Edit must have a source file
815 // TODO: descend into nested EDL's
816         if(result)
817         {
818 //printf("Render::direct_copy_possible 3 %d\n", result);
819                 playable_edit = playable_track->edits->get_playable_edit(current_position, 1);
820 //printf("Render::direct_copy_possible 4 %d %p\n", result, playable_edit);
821                 if(!playable_edit)
822                         result = 0;
823         }
824
825 // Source file must be able to copy to destination file.
826 // Source file must be same size as project output.
827         if(result)
828         {
829                 if(!file->can_copy_from(playable_edit->asset,
830                         current_position + playable_track->nudge,
831                         edl->session->output_w,
832                         edl->session->output_h))
833                         result = 0;
834         }
835 //printf("Render::direct_copy_possible 6 %d\n", result);
836
837 // Test conditions mutual between vrender.C and this.
838         if(result &&
839                 !playable_track->direct_copy_possible(current_position, PLAY_FORWARD, 1))
840                 result = 0;
841 //printf("Render::direct_copy_possible 7 %d\n", result);
842
843         return result;
844 }
845
846
847
848
849
850
851
852
853
854 int PackageRenderer::get_master()
855 {
856         return 0;
857 }
858
859 // Get result status from server
860 int PackageRenderer::get_result()
861 {
862         return 0;
863 }
864
865 void PackageRenderer::set_result(int value)
866 {
867 }
868
869 void PackageRenderer::set_progress(int64_t value)
870 {
871 }
872
873 int PackageRenderer::set_video_map(int64_t position, int value)
874 {
875         return 0;
876 }
877
878 int PackageRenderer::progress_cancelled()
879 {
880         return 0;
881 }
882
883
884
885
886
887
888
889
890
891