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