cinelerra-5.1/cinelerra/amodule.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2009-2013 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 "aattachmentpoint.h"
  23 #include "aedit.h"
  24 #include "amodule.h"
  25 #include "aplugin.h"
  26 #include "arender.h"
  27 #include "asset.h"
  28 #include "atrack.h"
  29 #include "automation.h"
  30 #include "bcsignals.h"
  31 #include "cache.h"
  32 #include "clip.h"
  33 #include "edits.h"
  34 #include "edl.h"
  35 #include "edlsession.h"
  36 #include "file.h"
  37 #include "filexml.h"
  38 #include "floatautos.h"
  39 #include "language.h"
  40 #include "module.h"
  41 #include "patch.h"
  42 #include "plugin.h"
  43 #include "pluginarray.h"
  44 #include "preferences.h"
  45 #include "renderengine.h"
  46 #include "mainsession.h"
  47 #include "samples.h"
  48 #include "sharedlocation.h"
  49 #include "theme.h"
  50 #include "transition.h"
  51 #include "transportque.h"
  52 #include <string.h>
  53
  54
  55
  56
  57
  58
  59
  60
  61 AModuleResample::AModuleResample(AModule *module)
  62  : Resample()
  63 {
  64         this->module = module;
  65         bzero(nested_output, sizeof(Samples*) * MAX_CHANNELS);
  66         nested_allocation = 0;
  67 }
  68
  69 AModuleResample::~AModuleResample()
  70 {
  71         for(int i = 0; i < MAX_CHANNELS; i++)
  72                 delete nested_output[i];
  73 }
  74
  75 int AModuleResample::read_samples(Samples *buffer,
  76                 int64_t start, int64_t len, int direction)
  77 {
  78         return module->read_samples(buffer, start, len, direction);
  79 }
  80
  81 AModule::AModule(RenderEngine *renderengine,
  82         CommonRender *commonrender,
  83         PluginArray *plugin_array,
  84         Track *track)
  85  : Module(renderengine, commonrender, plugin_array, track)
  86 {
  87         data_type = TRACK_AUDIO;
  88         channel = 0;
  89         transition_temp = 0;
  90         speed_temp = 0;
  91         bzero(nested_output, sizeof(Samples*) * MAX_CHANNELS);
  92         meter_history = new MeterHistory();
  93         nested_allocation = 0;
  94         resample = 0;
  95         asset = 0;
  96         file = 0;
  97 }
  98
  99
 100
 101
 102 AModule::~AModule()
 103 {
 104         delete transition_temp;
 105         delete speed_temp;
 106         delete meter_history;
 107         for(int i = 0; i < MAX_CHANNELS; i++)
 108                 delete nested_output[i];
 109         delete resample;
 110 }
 111
 112 int AModule::read_samples(Samples *buffer, int64_t start, int64_t len, int direction)
 113 {
 114         if( len < 0 ) return 1;
 115         double *buffer_data = buffer->get_data();
 116 // if start < 0, zero fill prefix.  if error, zero fill buffer
 117         int64_t zeros = len;
 118         int result = 0;
 119         if( asset ) {
 120 // Files only read going forward.
 121                 if( direction == PLAY_REVERSE ) start -= len;
 122                 int64_t sz = start >= 0 ? len : len + start;
 123                 if( start < 0 ) start = 0;
 124                 if( sz > 0 ) {
 125                         file->set_audio_position(start);
 126                         file->set_channel(channel);
 127                         result = file->read_samples(buffer, sz);
 128                         if( !result && (zeros-=sz) > 0 ) {
 129                                 double *top_data = buffer_data + zeros;
 130                                 memmove(top_data, buffer_data, sz*sizeof(*buffer_data));
 131                         }
 132                 }
 133                 if( !result && direction == PLAY_REVERSE )
 134                         Resample::reverse_buffer(buffer_data, len);
 135         }
 136         else if( nested_edl ) {
 137                 if( nested_allocation < len ) {
 138                         nested_allocation = len;
 139                         for( int i=0; i<nested_edl->session->audio_channels; ++i ) {
 140                                 delete nested_output[i];
 141                                 nested_output[i] = new Samples(nested_allocation);
 142                         }
 143                 }
 144                 result = nested_renderengine->arender->
 145                         process_buffer(nested_output, len, start);
 146                 if( !result ) {
 147                         double *sample_data = nested_output[channel]->get_data();
 148                         int buffer_size = len * sizeof(*buffer_data);
 149                         memcpy(buffer_data, sample_data, buffer_size);
 150                         zeros = 0;
 151                 }
 152         }
 153         if( zeros > 0 )
 154                 memset(buffer_data, 0, zeros*sizeof(*buffer_data));
 155         return result;
 156 }
 157
 158 AttachmentPoint* AModule::new_attachment(Plugin *plugin)
 159 {
 160         return new AAttachmentPoint(renderengine, plugin);
 161 }
 162
 163
 164 void AModule::create_objects()
 165 {
 166         Module::create_objects();
 167 // Not needed in pluginarray
 168         if( commonrender ) {
 169                 meter_history->init(1, ((ARender*)commonrender)->total_peaks);
 170                 meter_history->reset_channel(0);
 171         }
 172 }
 173
 174 int AModule::get_buffer_size()
 175 {
 176         if(renderengine)
 177                 return renderengine->fragment_len;
 178         else
 179                 return plugin_array->get_bufsize();
 180 }
 181
 182
 183 CICache* AModule::get_cache()
 184 {
 185         if(renderengine)
 186                 return renderengine->get_acache();
 187         else
 188                 return cache;
 189 }
 190
 191
 192 int AModule::import_samples(AEdit *edit,
 193         int64_t start_project, int64_t edit_startproject, int64_t edit_startsource,
 194         int direction, int sample_rate, Samples *buffer, int64_t fragment_len)
 195 {
 196         int result = 0;
 197         if( fragment_len <= 0 )
 198                 result = 1;
 199         if( nested_edl && edit->channel >= nested_edl->session->audio_channels )
 200                 result = 1;
 201         double *buffer_data = buffer->get_data();
 202 // buffer fragment adjusted for speed curve
 203         Samples *speed_buffer = buffer;
 204         double *speed_data = speed_buffer->get_data();
 205         int64_t speed_fragment_len = fragment_len;
 206         int dir = direction == PLAY_FORWARD ? 1 : -1;
 207 // normal speed source boundaries in EDL samplerate
 208         int64_t start_source = start_project - edit_startproject + edit_startsource;
 209         double end_source = start_source + dir*speed_fragment_len;
 210         double start_position = start_source;
 211 //      double end_position = end_source;
 212 // normal speed playback boundaries
 213         double min_source = bmin(start_source, end_source);
 214         double max_source = bmax(start_source, end_source);
 215
 216         this->channel = edit->channel;
 217         int have_speed = track->has_speed();
 218
 219 // apply speed curve to source position so the timeline agrees with the playback
 220         if( !result && have_speed ) {
 221 // get speed adjusted start position from start of edit.
 222                 FloatAuto *previous = 0, *next = 0;
 223                 FloatAutos *speed_autos = (FloatAutos*)track->automation->autos[AUTOMATION_SPEED];
 224                 double source_position = edit_startsource +
 225                         speed_autos->automation_integral(edit_startproject,
 226                                 start_project-edit_startproject, PLAY_FORWARD);
 227                 min_source = source_position;
 228                 max_source = source_position;
 229 // calculate boundaries of input fragment required for speed curve
 230                 int64_t pos = start_project;
 231                 start_position = source_position;
 232                 for( int64_t i=fragment_len; --i>=0; pos+=dir ) {
 233                         double speed = speed_autos->get_value(pos, direction, previous, next);
 234                         source_position += dir*speed;
 235                         if( source_position > max_source ) max_source = source_position;
 236                         if( source_position < min_source ) min_source = source_position;
 237                 }
 238 //              end_position = source_position;
 239                 speed_fragment_len = (int64_t)(max_source - min_source);
 240                 start_source = direction == PLAY_FORWARD ? min_source : max_source;
 241                 if( speed_fragment_len > 0 ) {
 242 // swap in the temp buffer
 243                         if( speed_temp && speed_temp->get_allocated() < speed_fragment_len ) {
 244                                 delete speed_temp;  speed_temp = 0;
 245                         }
 246                         if( !speed_temp )
 247                                 speed_temp = new Samples(speed_fragment_len);
 248                         speed_buffer = speed_temp;
 249                         speed_data = speed_buffer->get_data();
 250                 }
 251         }
 252
 253         int edit_sample_rate = 0;
 254         if( speed_fragment_len <= 0 )
 255                 result = 1;
 256
 257         if( !result && edit->asset ) {
 258                 nested_edl = 0;
 259                 if( nested_renderengine ) {
 260                         delete nested_renderengine;  nested_renderengine = 0;
 261                 }
 262 // Source is an asset
 263                 asset = edit->asset;
 264                 edit_sample_rate = asset->sample_rate;
 265                 get_cache()->age();
 266                 file = get_cache()->check_out(asset, get_edl());
 267                 if( !file ) {
 268                         printf(_("AModule::import_samples Couldn't open %s.\n"), asset->path);
 269                         result = 1;
 270                 }
 271         }
 272         else if( !result && edit->nested_edl ) {
 273                 asset = 0;
 274 // Source is a nested EDL
 275                 if( !nested_edl || nested_edl->id != edit->nested_edl->id ) {
 276                         nested_edl = edit->nested_edl;
 277                         delete nested_renderengine;
 278                         nested_renderengine = 0;
 279                 }
 280                 edit_sample_rate = nested_edl->session->sample_rate;
 281                 int command = direction == PLAY_REVERSE ?
 282                         NORMAL_REWIND : NORMAL_FWD;
 283                 if( !nested_command ) {
 284                         nested_command = new TransportCommand;
 285                         nested_command->command = command;
 286                         nested_command->get_edl()->copy_all(nested_edl);
 287                         nested_command->change_type = CHANGE_ALL;
 288                         nested_command->realtime = renderengine->command->realtime;
 289                 }
 290                 if( !nested_renderengine ) {
 291                         nested_renderengine = new RenderEngine(0, get_preferences(), 0, 1);
 292                         nested_renderengine->set_acache(get_cache());
 293                         nested_renderengine->arm_command(nested_command);
 294                 }
 295                 nested_renderengine->command->command = command;
 296                 result = 0;
 297         }
 298         if( edit_sample_rate <= 0 )
 299                 result = 1;
 300
 301         if( !result ) {
 302 // speed_buffer is (have_speed ? speed_temp : buffer)
 303                 if( sample_rate != edit_sample_rate ) {
 304                         if( !resample )
 305                                 resample = new AModuleResample(this);
 306                         result = resample->resample(speed_buffer,
 307                                 speed_fragment_len, edit_sample_rate,
 308                                 sample_rate, start_source, direction);
 309                 }
 310                 else {
 311                         result = read_samples(speed_buffer,
 312                                 start_source, speed_fragment_len, direction);
 313                 }
 314         }
 315         if( asset && file ) {
 316                 file = 0;
 317                 get_cache()->check_in(asset);
 318         }
 319 // Stretch it to fit the speed curve
 320 // Need overlapping buffers to get the interpolation to work, but this
 321 // screws up sequential effects.
 322         if( !result && have_speed ) {
 323                 FloatAuto *previous = 0, *next = 0;
 324                 FloatAutos *speed_autos = (FloatAutos*)track->automation->autos[AUTOMATION_SPEED];
 325                 int len1 = speed_fragment_len-1;
 326                 double speed_position = start_position;
 327                 double pos = start_project;
 328 // speed                gnuplot> plot "/tmp/x.dat" using($1) with lines
 329 // speed_position       gnuplot> plot "/tmp/x.dat" using($2) with lines
 330 //FILE *fp = 0;
 331 //if( !channel ) { fp = fopen("/tmp/x.dat", "a"); fprintf(fp," %f %f\n",0.,0.); }
 332                 for( int64_t i=0; i<fragment_len; ++i,pos+=dir ) {
 333                         int64_t speed_pos = speed_position;
 334                         double speed = speed_autos->get_value(pos,
 335                                 direction, previous, next);
 336 //if(fp) fprintf(fp," %f %f\n", speed, speed_position);
 337                         double next_position = speed_position + dir*speed;
 338                         int64_t next_pos = next_position;
 339                         int total = abs(next_pos - speed_pos);
 340                         int k = speed_pos - min_source;
 341                         if( dir < 0 ) k = len1 - k; // if buffer reversed
 342                         double sample = speed_data[bclip(k, 0,len1)];
 343                         if( total > 1 ) {
 344                                 int d = next_pos >= speed_pos ? 1 : -1;
 345                                 for( int j=total; --j>0; ) {
 346                                         k += d;
 347                                         sample += speed_data[bclip(k, 0,len1)];
 348                                 }
 349                                 sample /= total;
 350                         }
 351 #if 0
 352                         else if( total < 1 ) {
 353                                 int d = next_pos >= speed_pos ? 1 : -1;
 354                                 k += d;
 355                                 double next_sample = speed_data[bclip(k, 0,len1)];
 356                                 double v = speed_position - speed_pos;
 357                                 sample = (1.-v) * sample + v * next_sample;
 358                         }
 359 #endif
 360                         buffer_data[i] = sample;
 361                         speed_position = next_position;
 362                 }
 363 //if(fp) fclose(fp);
 364         }
 365
 366         if( result )
 367                 bzero(buffer_data, fragment_len*sizeof(*buffer_data));
 368         return result;
 369 }
 370
 371
 372 int AModule::render(Samples *buffer,
 373         int64_t input_len,
 374         int64_t start_position,
 375         int direction,
 376         int sample_rate,
 377         int use_nudge)
 378 {
 379         int64_t edl_rate = get_edl()->session->sample_rate;
 380         const int debug = 0;
 381
 382 if(debug) printf("AModule::render %d\n", __LINE__);
 383
 384         if(use_nudge)
 385                 start_position += track->nudge *
 386                         sample_rate /
 387                         edl_rate;
 388         AEdit *playable_edit;
 389         int64_t end_position;
 390         if(direction == PLAY_FORWARD)
 391                 end_position = start_position + input_len;
 392         else
 393                 end_position = start_position - input_len;
 394         int buffer_offset = 0;
 395         int result = 0;
 396
 397
 398 // // Flip range around so the source is always read forward.
 399 //      if(direction == PLAY_REVERSE)
 400 //      {
 401 //              start_project -= input_len;
 402 //              end_position -= input_len;
 403 //      }
 404
 405
 406 // Clear buffer
 407         bzero(buffer->get_data(), input_len * sizeof(double));
 408
 409 // The EDL is normalized to the requested sample rate because
 410 // the requested rate may be the project sample rate and a sample rate
 411 // might as well be directly from the source rate to the requested rate.
 412 // Get first edit containing the range
 413         if(direction == PLAY_FORWARD)
 414                 playable_edit = (AEdit*)track->edits->first;
 415         else
 416                 playable_edit = (AEdit*)track->edits->last;
 417 if(debug) printf("AModule::render %d\n", __LINE__);
 418
 419         while(playable_edit)
 420         {
 421                 int64_t edit_start = playable_edit->startproject;
 422                 int64_t edit_end = playable_edit->startproject + playable_edit->length;
 423
 424 // Normalize to requested rate
 425                 edit_start = edit_start * sample_rate / edl_rate;
 426                 edit_end = edit_end * sample_rate / edl_rate;
 427
 428                 if(direction == PLAY_FORWARD)
 429                 {
 430                         if(start_position < edit_end && end_position > edit_start)
 431                         {
 432                                 break;
 433                         }
 434                         playable_edit = (AEdit*)playable_edit->next;
 435                 }
 436                 else
 437                 {
 438                         if(end_position < edit_end && start_position > edit_start)
 439                         {
 440                                 break;
 441                         }
 442                         playable_edit = (AEdit*)playable_edit->previous;
 443                 }
 444         }
 445
 446
 447 if(debug) printf("AModule::render %d\n", __LINE__);
 448
 449
 450
 451
 452
 453 // Fill output one fragment at a time
 454         while(start_position != end_position)
 455         {
 456                 int64_t fragment_len = input_len;
 457
 458 if(debug) printf("AModule::render %d %jd %jd\n", __LINE__, start_position, end_position);
 459 // Clamp fragment to end of input
 460                 if(direction == PLAY_FORWARD &&
 461                         start_position + fragment_len > end_position)
 462                         fragment_len = end_position - start_position;
 463                 else
 464                 if(direction == PLAY_REVERSE &&
 465                         start_position - fragment_len < end_position)
 466                         fragment_len = start_position - end_position;
 467 if(debug) printf("AModule::render %d %jd\n", __LINE__, fragment_len);
 468
 469 // Normalize position here since update_transition is a boolean operation.
 470                 update_transition(start_position *
 471                                 edl_rate /
 472                                 sample_rate,
 473                         PLAY_FORWARD);
 474
 475                 if(playable_edit)
 476                 {
 477                         AEdit *previous_edit = (AEdit*)playable_edit->previous;
 478
 479 // Normalize EDL positions to requested rate
 480                         int64_t edit_startproject = playable_edit->startproject;
 481                         int64_t edit_endproject = playable_edit->startproject + playable_edit->length;
 482                         int64_t edit_startsource = playable_edit->startsource;
 483 if(debug) printf("AModule::render %d %jd\n", __LINE__, fragment_len);
 484
 485                         edit_startproject = edit_startproject * sample_rate / edl_rate;
 486                         edit_endproject = edit_endproject * sample_rate / edl_rate;
 487                         edit_startsource = edit_startsource * sample_rate / edl_rate;
 488 if(debug) printf("AModule::render %d %jd\n", __LINE__, fragment_len);
 489
 490
 491
 492 // Clamp fragment to end of edit
 493                         if(direction == PLAY_FORWARD &&
 494                                 start_position + fragment_len > edit_endproject)
 495                                 fragment_len = edit_endproject - start_position;
 496                         else
 497                         if(direction == PLAY_REVERSE &&
 498                                 start_position - fragment_len < edit_startproject)
 499                                 fragment_len = start_position - edit_startproject;
 500 if(debug) printf("AModule::render %d %jd\n", __LINE__, fragment_len);
 501
 502 // Clamp to end of transition
 503                         int64_t transition_len = 0;
 504
 505                         if(transition &&
 506                                 previous_edit)
 507                         {
 508                                 transition_len = transition->length *
 509                                         sample_rate /
 510                                         edl_rate;
 511                                 if(direction == PLAY_FORWARD &&
 512                                         start_position < edit_startproject + transition_len &&
 513                                         start_position + fragment_len > edit_startproject + transition_len)
 514                                         fragment_len = edit_startproject + transition_len - start_position;
 515                                 else
 516                                 if(direction == PLAY_REVERSE &&
 517                                         start_position > edit_startproject + transition_len &&
 518                                         start_position - fragment_len < edit_startproject + transition_len)
 519                                         fragment_len = start_position - edit_startproject - transition_len;
 520                         }
 521 if(debug) printf("AModule::render %d buffer_offset=%d fragment_len=%jd\n",
 522 __LINE__,
 523 buffer_offset,
 524 fragment_len);
 525
 526                         Samples output(buffer);
 527                         output.set_offset(output.get_offset() + buffer_offset);
 528                         if(import_samples(playable_edit,
 529                                 start_position,
 530                                 edit_startproject,
 531                                 edit_startsource,
 532                                 direction,
 533                                 sample_rate,
 534                                 &output,
 535                                 fragment_len)) result = 1;
 536
 537 if(debug) printf("AModule::render %d\n", __LINE__);
 538
 539
 540 // Read transition into temp and render
 541                         if(transition && previous_edit)
 542                         {
 543                                 int64_t previous_startproject = previous_edit->startproject *
 544                                         sample_rate /
 545                                         edl_rate;
 546                                 int64_t previous_startsource = previous_edit->startsource *
 547                                         sample_rate /
 548                                         edl_rate;
 549
 550 // Allocate transition temp size
 551                                 int transition_fragment_len = fragment_len;
 552                                 if(direction == PLAY_FORWARD &&
 553                                         fragment_len + start_position > edit_startproject + transition_len)
 554                                         fragment_len = edit_startproject + transition_len - start_position;
 555
 556
 557 // Read into temp buffers
 558 // Temp + master or temp + temp ? temp + master
 559                                 if(transition_temp &&
 560                                         transition_temp->get_allocated() < fragment_len)
 561                                 {
 562                                         delete transition_temp;
 563                                         transition_temp = 0;
 564                                 }
 565
 566                                 if(!transition_temp)
 567                                 {
 568                                         transition_temp = new Samples(fragment_len);
 569                                 }
 570
 571 if(debug) printf("AModule::render %d %jd\n", __LINE__, fragment_len);
 572
 573                                 if(transition_fragment_len > 0)
 574                                 {
 575 // Previous_edit is always the outgoing segment, regardless of direction
 576                                         import_samples(previous_edit,
 577                                                 start_position,
 578                                                 previous_startproject,
 579                                                 previous_startsource,
 580                                                 direction,
 581                                                 sample_rate,
 582                                                 transition_temp,
 583                                                 transition_fragment_len);
 584                                         int64_t current_position;
 585
 586 // Reverse buffers here so transitions always render forward.
 587                                         if(direction == PLAY_REVERSE)
 588                                         {
 589                                                 Resample::reverse_buffer(output.get_data(), transition_fragment_len);
 590                                                 Resample::reverse_buffer(transition_temp->get_data(), transition_fragment_len);
 591                                                 current_position = start_position -
 592                                                         transition_fragment_len -
 593                                                         edit_startproject;
 594                                         }
 595                                         else
 596                                         {
 597                                                 current_position = start_position - edit_startproject;
 598                                         }
 599
 600                                         transition_server->process_transition(
 601                                                 transition_temp,
 602                                                 &output,
 603                                                 current_position,
 604                                                 transition_fragment_len,
 605                                                 transition->length);
 606
 607 // Reverse output buffer here so transitions always render forward.
 608                                         if(direction == PLAY_REVERSE)
 609                                                 Resample::reverse_buffer(output.get_data(),
 610                                                         transition_fragment_len);
 611                                 }
 612                         }
 613 if(debug) printf("AModule::render %d start_position=%jd end_position=%jd fragment_len=%jd\n",
 614  __LINE__, start_position, end_position, fragment_len);
 615
 616                         if(direction == PLAY_REVERSE)
 617                         {
 618                                 if(playable_edit && start_position - fragment_len <= edit_startproject)
 619                                         playable_edit = (AEdit*)playable_edit->previous;
 620                         }
 621                         else
 622                         {
 623                                 if(playable_edit && start_position + fragment_len >= edit_endproject)
 624                                         playable_edit = (AEdit*)playable_edit->next;
 625                         }
 626                 }
 627
 628                 if(fragment_len > 0)
 629                 {
 630                         buffer_offset += fragment_len;
 631                         if(direction == PLAY_FORWARD)
 632                                 start_position += fragment_len;
 633                         else
 634                                 start_position -= fragment_len;
 635                 }
 636         }
 637
 638 if(debug) printf("AModule::render %d\n", __LINE__);
 639
 640         return result;
 641 }
 642
 643
 644
 645
 646
 647
 648
 649
 650