cinelerra/resourcepixmap.C

   1 #include "aedit.h"
   2 #include "asset.h"
   3 #include "asset.inc"
   4 #include "cache.h"
   5 #include "clip.h"
   6 #include "colormodels.h"
   7 #include "datatype.h"
   8 #include "edit.h"
   9 #include "edits.h"
  10 #include "edl.h"
  11 #include "edlsession.h"
  12 #include "file.h"
  13 #include "filesystem.h"
  14 #include "framecache.h"
  15 #include "indexfile.h"
  16 #include "language.h"
  17 #include "localsession.h"
  18 #include "mwindow.h"
  19 #include "resourcepixmap.h"
  20 #include "theme.h"
  21 #include "track.h"
  22 #include "trackcanvas.h"
  23 #include "vedit.h"
  24 #include "vframe.h"
  25
  26
  27 ResourcePixmap::ResourcePixmap(MWindow *mwindow,
  28         TrackCanvas *canvas,
  29         Edit *edit,
  30         int w,
  31         int h)
  32  : BC_Pixmap(canvas, w, h)
  33 {
  34         reset();
  35
  36         this->mwindow = mwindow;
  37         this->canvas = canvas;
  38         startsource = edit->startsource;
  39         data_type = edit->track->data_type;
  40         source_framerate = edit->asset->frame_rate;
  41         project_framerate = edit->edl->session->frame_rate;
  42         source_samplerate = edit->asset->sample_rate;
  43         project_samplerate = edit->edl->session->sample_rate;
  44         edit_id = edit->id;
  45 }
  46
  47 ResourcePixmap::~ResourcePixmap()
  48 {
  49 }
  50
  51
  52 void ResourcePixmap::reset()
  53 {
  54         edit_x = 0;
  55         pixmap_x = 0;
  56         pixmap_w = 0;
  57         pixmap_h = 0;
  58         zoom_sample = 0;
  59         zoom_track = 0;
  60         zoom_y = 0;
  61         visible = 1;
  62 }
  63
  64 void ResourcePixmap::resize(int w, int h)
  65 {
  66         int new_w = (w > get_w()) ? w : get_w();
  67         int new_h = (h > get_h()) ? h : get_h();
  68
  69         BC_Pixmap::resize(new_w, new_h);
  70 }
  71
  72
  73 void ResourcePixmap::draw_data(Edit *edit,
  74         int64_t edit_x,
  75         int64_t edit_w,
  76         int64_t pixmap_x,
  77         int64_t pixmap_w,
  78         int64_t pixmap_h,
  79         int force,
  80         int indexes_only)
  81 {
  82 // Get new areas to fill in relative to pixmap
  83 // Area to redraw relative to pixmap
  84         int refresh_x = 0;
  85         int refresh_w = 0;
  86
  87
  88
  89         int y = 0;
  90         if(mwindow->edl->session->show_titles) y += mwindow->theme->title_bg_data->get_h();
  91         Track *track = edit->edits->track;
  92
  93
  94 // If index can't be drawn, don't do anything.
  95         int need_redraw = 0;
  96         int64_t index_zoom = 0;
  97         if(indexes_only)
  98         {
  99                 IndexFile indexfile(mwindow);
 100                 if(!indexfile.open_index(edit->asset))
 101                 {
 102                         index_zoom = edit->asset->index_zoom;
 103                         indexfile.close_index();
 104                 }
 105
 106                 if(index_zoom)
 107                 {
 108                         if(data_type == TRACK_AUDIO)
 109                         {
 110                                 double asset_over_session = (double)edit->asset->sample_rate /
 111                                         mwindow->edl->session->sample_rate;
 112                                         asset_over_session;
 113                                 if(index_zoom <= mwindow->edl->local_session->zoom_sample *
 114                                         asset_over_session)
 115                                         need_redraw = 1;
 116                         }
 117                 }
 118
 119                 if(!need_redraw)
 120                         return;
 121         }
 122
 123
 124 // Redraw everything
 125         if(edit->startsource != this->startsource ||
 126                 (data_type == TRACK_AUDIO &&
 127                         edit->asset->sample_rate != source_samplerate) ||
 128                 (data_type == TRACK_VIDEO &&
 129                         !EQUIV(edit->asset->frame_rate, source_framerate)) ||
 130                 mwindow->edl->session->sample_rate != project_samplerate ||
 131                 mwindow->edl->session->frame_rate != project_framerate ||
 132                 mwindow->edl->local_session->zoom_sample != zoom_sample ||
 133                 mwindow->edl->local_session->zoom_track != zoom_track ||
 134                 this->pixmap_h != pixmap_h ||
 135                 (data_type == TRACK_AUDIO &&
 136                         mwindow->edl->local_session->zoom_y != zoom_y) ||
 137                 force ||
 138                 need_redraw)
 139         {
 140 // Shouldn't draw at all if zoomed in below index zoom.
 141                 refresh_x = 0;
 142                 refresh_w = pixmap_w;
 143         }
 144         else
 145         {
 146 // Start translated right
 147                 if(pixmap_w == this->pixmap_w && edit_x < this->edit_x && edit_w != pixmap_w)
 148                 {
 149                         refresh_w = this->edit_x - edit_x;
 150                         refresh_x = this->pixmap_w - refresh_w;
 151
 152 // Moved completely off the pixmap
 153                         if(refresh_w > this->pixmap_w)
 154                         {
 155                                 refresh_w = this->pixmap_w;
 156                                 refresh_x = 0;
 157                         }
 158                         else
 159                         {
 160                                 copy_area(refresh_w,
 161                                         y,
 162                                         refresh_x,
 163                                         mwindow->edl->local_session->zoom_track,
 164                                         0,
 165                                         y);
 166                         }
 167                 }
 168                 else
 169 // Start translated left
 170                 if(pixmap_w == this->pixmap_w && edit_x > this->edit_x && edit_w != pixmap_w)
 171                 {
 172                         refresh_x = 0;
 173                         refresh_w = edit_x - this->edit_x;
 174
 175 // Moved completely off the pixmap
 176                         if(refresh_w > this->pixmap_w)
 177                         {
 178                                 refresh_w = this->pixmap_w;
 179                         }
 180                         else
 181                         {
 182                                 copy_area(0,
 183                                         y,
 184                                         this->pixmap_w - refresh_w,
 185                                         mwindow->edl->local_session->zoom_track,
 186                                         refresh_w,
 187                                         y);
 188                         }
 189                 }
 190                 else
 191 // Start translated right and pixmap came off of right side
 192                 if(pixmap_w < this->pixmap_w && edit_x < this->edit_x &&
 193                         this->edit_x + edit_w > this->pixmap_x + this->pixmap_w)
 194                 {
 195                         refresh_w = (this->edit_x + edit_w) - (this->pixmap_x + this->pixmap_w);
 196                         refresh_x = pixmap_w - refresh_w;
 197
 198                         if(refresh_w >= pixmap_w)
 199                         {
 200                                 refresh_x = 0;
 201                                 refresh_w = pixmap_w;
 202                         }
 203                         else
 204                         {
 205                                 copy_area(this->edit_x - edit_x,
 206                                         y,
 207                                         pixmap_w - refresh_w,
 208                                         mwindow->edl->local_session->zoom_track,
 209                                         0,
 210                                         y);
 211                         }
 212                 }
 213                 else
 214 // Start translated right and reduced in size on the right.
 215                 if(pixmap_w < this->pixmap_w && edit_x < this->edit_x)
 216                 {
 217                         refresh_x = 0;
 218                         refresh_w = 0;
 219
 220                         copy_area(this->pixmap_w - pixmap_w,
 221                                 y,
 222                                 pixmap_w,
 223                                 mwindow->edl->local_session->zoom_track,
 224                                 0,
 225                                 y);
 226                 }
 227                 else
 228 // Start translated left and pixmap came off left side
 229                 if(edit_x >= 0 && this->edit_x < 0)
 230                 {
 231                         refresh_x = 0;
 232                         refresh_w = -this->edit_x;
 233
 234                         if(refresh_w > pixmap_w)
 235                         {
 236                                 refresh_w = pixmap_w;
 237                         }
 238                         else
 239                         {
 240                                 copy_area(0,
 241                                                 y,
 242                                                 this->pixmap_w,
 243                                                 mwindow->edl->local_session->zoom_track,
 244                                                 refresh_w,
 245                                                 y);
 246                         }
 247                 }
 248                 else
 249 // Start translated left and reduced in size on the right
 250                 if(pixmap_w < this->pixmap_w && edit_x > this->edit_x)
 251                 {
 252                         refresh_x = 0;
 253                         refresh_w = 0;
 254                 }
 255                 else
 256 // Start translated right and left went into left side.
 257                 if(pixmap_w > this->pixmap_w && edit_x < 0 && this->edit_x > 0)
 258                 {
 259                         refresh_w = pixmap_w - (edit_x + this->pixmap_w);
 260                         refresh_x = pixmap_w - refresh_w;
 261
 262 // Moved completely off new pixmap
 263                         if(refresh_w > pixmap_w)
 264                         {
 265                                 refresh_w = pixmap_w;
 266                                 refresh_x = 0;
 267                         }
 268                         else
 269                         {
 270                                 copy_area(-edit_x,
 271                                         y,
 272                                         refresh_x,
 273                                         mwindow->edl->local_session->zoom_track,
 274                                         0,
 275                                         y);
 276                         }
 277                 }
 278                 else
 279 // Start translated right and increased in size on the right
 280                 if(pixmap_w > this->pixmap_w && edit_x <= this->edit_x)
 281                 {
 282                         refresh_w = pixmap_w - this->pixmap_w;
 283                         refresh_x = pixmap_w - refresh_w;
 284                 }
 285                 else
 286 // Start translated left and increased in size on the right
 287                 if(pixmap_w > this->pixmap_w && edit_x > this->edit_x)
 288                 {
 289                         refresh_x = 0;
 290                         refresh_w = edit_x - this->edit_x;
 291
 292 // Moved completely off new pixmap
 293                         if(refresh_w > this->pixmap_w)
 294                         {
 295                                 refresh_w = pixmap_w;
 296                                 refresh_x = 0;
 297                         }
 298 // Shift and insert
 299                         else
 300                         {
 301                                 copy_area(0,
 302                                         y,
 303                                         this->pixmap_w,
 304                                         mwindow->edl->local_session->zoom_track,
 305                                         refresh_w,
 306                                         y);
 307                         }
 308                 }
 309         }
 310
 311 // Update pixmap settings
 312         this->edit_id = edit->id;
 313         this->startsource = edit->startsource;
 314         this->source_framerate = edit->asset->frame_rate;
 315         this->source_samplerate = edit->asset->sample_rate;
 316         this->project_framerate = edit->edl->session->frame_rate;
 317         this->project_samplerate = edit->edl->session->sample_rate;
 318         this->edit_x = edit_x;
 319         this->pixmap_x = pixmap_x;
 320         this->pixmap_w = pixmap_w;
 321         this->pixmap_h = pixmap_h;
 322         this->zoom_sample = mwindow->edl->local_session->zoom_sample;
 323         this->zoom_track = mwindow->edl->local_session->zoom_track;
 324         this->zoom_y = mwindow->edl->local_session->zoom_y;
 325
 326
 327
 328 // Draw in new background
 329         if(refresh_w > 0)
 330                 mwindow->theme->draw_resource_bg(canvas,
 331                         this,
 332                         edit_x,
 333                         edit_w,
 334                         pixmap_x,
 335                         refresh_x,
 336                         y,
 337                         refresh_x + refresh_w,
 338                         mwindow->edl->local_session->zoom_track + y);
 339 //printf("ResourcePixmap::draw_data 70\n");
 340
 341
 342 // Draw media
 343         if(track->draw)
 344         {
 345                 switch(track->data_type)
 346                 {
 347                         case TRACK_AUDIO:
 348                                 draw_audio_resource(edit, refresh_x, refresh_w);
 349                                 break;
 350
 351                         case TRACK_VIDEO:
 352                                 draw_video_resource(edit,
 353                                         edit_x,
 354                                         edit_w,
 355                                         pixmap_x,
 356                                         pixmap_w,
 357                                         refresh_x,
 358                                         refresh_w);
 359                                 break;
 360                 }
 361         }
 362
 363 // Draw title
 364         if(mwindow->edl->session->show_titles)
 365                 draw_title(edit, edit_x, edit_w, pixmap_x, pixmap_w);
 366 }
 367
 368 void ResourcePixmap::draw_title(Edit *edit,
 369         int64_t edit_x,
 370         int64_t edit_w,
 371         int64_t pixmap_x,
 372         int64_t pixmap_w)
 373 {
 374 // coords relative to pixmap
 375         int64_t total_x = edit_x - pixmap_x, total_w = edit_w;
 376         int64_t x = total_x, w = total_w;
 377         int left_margin = 10;
 378
 379         if(x < 0)
 380         {
 381                 w -= -x;
 382                 x = 0;
 383         }
 384         if(w > pixmap_w) w -= w - pixmap_w;
 385
 386         canvas->draw_3segmenth(x,
 387                 0,
 388                 w,
 389                 total_x,
 390                 total_w,
 391                 mwindow->theme->title_bg_data,
 392                 this);
 393
 394         if(total_x > -BC_INFINITY)
 395         {
 396                 char title[BCTEXTLEN], channel[BCTEXTLEN];
 397                 FileSystem fs;
 398
 399                 if(edit->user_title[0])
 400                         strcpy(title, edit->user_title);
 401                 else
 402                 {
 403                         fs.extract_name(title, edit->asset->path);
 404
 405                         sprintf(channel, " #%d", edit->channel + 1);
 406                         strcat(title, channel);
 407                 }
 408
 409                 canvas->set_color(mwindow->theme->title_color);
 410                 canvas->set_font(mwindow->theme->title_font);
 411 //printf("ResourcePixmap::draw_title 1 %d\n", total_x + 10);
 412
 413 // Justify the text on the left boundary of the edit if it is visible.
 414 // Otherwise justify it on the left side of the screen.
 415                 int text_x = total_x + left_margin;
 416                 text_x = MAX(left_margin, text_x);
 417                 canvas->draw_text(text_x,
 418                         canvas->get_text_ascent(MEDIUMFONT_3D) + 2,
 419                         title,
 420                         strlen(title),
 421                         this);
 422         }
 423 }
 424
 425
 426 // Need to draw one more x
 427 void ResourcePixmap::draw_audio_resource(Edit *edit, int x, int w)
 428 {
 429         if(w <= 0) return;
 430         double asset_over_session = (double)edit->asset->sample_rate /
 431                 mwindow->edl->session->sample_rate;
 432
 433 // Develop strategy for drawing
 434         switch(edit->asset->index_status)
 435         {
 436                 case INDEX_NOTTESTED:
 437                         return;
 438                         break;
 439 // Disabled.  Always draw from index.
 440                 case INDEX_TOOSMALL:
 441                         draw_audio_source(edit, x, w);
 442                         break;
 443                 case INDEX_BUILDING:
 444                 case INDEX_READY:
 445                 {
 446                         IndexFile indexfile(mwindow);
 447                         if(!indexfile.open_index(edit->asset))
 448                         {
 449                                 if(edit->asset->index_zoom >
 450                                                 mwindow->edl->local_session->zoom_sample *
 451                                                 asset_over_session)
 452                                 {
 453                                         draw_audio_source(edit, x, w);
 454                                 }
 455                                 else
 456                                         indexfile.draw_index(this, edit, x, w);
 457                                 indexfile.close_index();
 458                         }
 459                         break;
 460                 }
 461         }
 462 }
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481 void ResourcePixmap::draw_audio_source(Edit *edit, int x, int w)
 482 {
 483         File *source = mwindow->audio_cache->check_out(edit->asset);
 484
 485         if(!source)
 486         {
 487                 printf(_("ResourcePixmap::draw_audio_source: failed to check out %s for drawing.\n"), edit->asset->path);
 488                 return;
 489         }
 490
 491         w++;
 492         int source_start = (pixmap_x - edit_x + x) * mwindow->edl->local_session->zoom_sample + edit->startsource;
 493         int source_len = w * mwindow->edl->local_session->zoom_sample;
 494         int center_pixel = mwindow->edl->local_session->zoom_track / 2;
 495         if(mwindow->edl->session->show_titles) center_pixel += mwindow->theme->title_bg_data->get_h();
 496         double asset_over_session = (double)edit->asset->sample_rate /
 497                 mwindow->edl->session->sample_rate;
 498
 499 // Single sample zoom
 500         if(mwindow->edl->local_session->zoom_sample == 1)
 501         {
 502                 double oldsample, newsample;
 503                 int total_source_samples = (int)((double)(source_len + 1) *
 504                         asset_over_session);
 505                 double *buffer = new double[total_source_samples];
 506
 507                 source->set_audio_position((int)((double)source_start *
 508                                 asset_over_session),
 509                         edit->asset->sample_rate);
 510                 source->set_channel(edit->channel);
 511                 canvas->set_color(mwindow->theme->audio_color);
 512
 513                 if(!source->read_samples(buffer,
 514                         total_source_samples,
 515                         edit->asset->sample_rate))
 516                 {
 517                         oldsample = newsample = *buffer;
 518                         for(int x1 = x, x2 = x + w, i = 0;
 519                                 x1 < x2;
 520                                 x1++, i++)
 521                         {
 522                                 oldsample = newsample;
 523                                 newsample = buffer[(int)(i * asset_over_session)];
 524                                 canvas->draw_line(x1 - 1,
 525                                         (int)(center_pixel - oldsample * mwindow->edl->local_session->zoom_y / 2),
 526                                         x1,
 527                                         (int)(center_pixel - newsample * mwindow->edl->local_session->zoom_y / 2),
 528                                         this);
 529                         }
 530                 }
 531
 532                 delete [] buffer;
 533                 canvas->test_timer();
 534         }
 535         else
 536 // Multiple sample zoom
 537         {
 538                 int fragmentsize;
 539                 int buffersize = fragmentsize = 65536;
 540                 double *buffer = new double[buffersize + 1];
 541                 double highsample, lowsample;
 542                 float sample_of_pixel = 0;
 543                 int total_source_samples = (int)(source_len *
 544                         asset_over_session);
 545                 double asset_samples_per_pixel =
 546                         mwindow->edl->local_session->zoom_sample *
 547                         asset_over_session;
 548                 int first_pixel = 1;
 549                 int prev_y1 = -1;
 550                 int prev_y2 = -1;
 551                 int y1;
 552                 int y2;
 553                 double x_double = x;
 554
 555                 source->set_audio_position((int)(source_start * asset_over_session),
 556                         edit->asset->sample_rate);
 557                 source->set_channel(edit->channel);
 558                 canvas->set_color(mwindow->theme->audio_color);
 559
 560                 for(int source_sample = 0;
 561                         source_sample < total_source_samples;
 562                         source_sample += buffersize)
 563                 {
 564                         fragmentsize = buffersize;
 565                         if(total_source_samples - source_sample < buffersize)
 566                                 fragmentsize = total_source_samples - source_sample;
 567
 568                         if(source_sample == 0)
 569                         {
 570                                 highsample = buffer[0];
 571                                 lowsample = buffer[0];
 572                         }
 573
 574                         if(!source->read_samples(buffer,
 575                                 fragmentsize,
 576                                 edit->asset->sample_rate))
 577                         {
 578
 579
 580 // Draw samples for this buffer
 581                                 for(int bufferposition = 0;
 582                                         bufferposition < fragmentsize;
 583                                         bufferposition++)
 584                                 {
 585 // Replicate
 586                                         if(asset_samples_per_pixel < 1)
 587                                         {
 588                                                 int x1 = (int)x_double;
 589                                                 x_double += (double)1 / asset_samples_per_pixel;
 590                                                 int x2 = (int)x_double;
 591
 592                                                 y1 = (int)(center_pixel -
 593                                                                 buffer[bufferposition] *
 594                                                                 mwindow->edl->local_session->zoom_y /
 595                                                                 2);
 596                                                 if(first_pixel)
 597                                                 {
 598                                                         canvas->draw_line(x1,
 599                                                                 y1,
 600                                                                 x2,
 601                                                                 y1,
 602                                                                 this);
 603                                                         first_pixel = 0;
 604                                                 }
 605                                                 else
 606                                                         canvas->draw_line(x1,
 607                                                                 prev_y1,
 608                                                                 x2,
 609                                                                 y1,
 610                                                                 this);
 611                                                 prev_y1 = y1;
 612                                         }
 613                                         else
 614                                         if(asset_samples_per_pixel >= 1 &&
 615                                                 sample_of_pixel >= asset_samples_per_pixel)
 616                                         {
 617 // Draw column and reset
 618                                                 y1 = (int)(center_pixel -
 619                                                         highsample *
 620                                                         mwindow->edl->local_session->zoom_y /
 621                                                         2);
 622                                                 y2 = (int)(center_pixel -
 623                                                         lowsample *
 624                                                         mwindow->edl->local_session->zoom_y /
 625                                                         2);
 626
 627                                                 int current_y1;
 628                                                 int current_y2;
 629                                                 if(first_pixel)
 630                                                 {
 631                                                         canvas->draw_line(x,
 632                                                                 y1,
 633                                                                 x,
 634                                                                 y2,
 635                                                                 this);
 636                                                         first_pixel = 0;
 637                                                 }
 638                                                 else
 639                                                         canvas->draw_line(x,
 640                                                                 MIN(y1, prev_y2),
 641                                                                 x,
 642                                                                 MAX(y2, prev_y1),
 643                                                                 this);
 644                                                 sample_of_pixel -= asset_samples_per_pixel;
 645                                                 x++;
 646                                                 lowsample = highsample = buffer[bufferposition];
 647                                                 prev_y1 = y1;
 648                                                 prev_y2 = y2;
 649                                         }
 650
 651                                         if(sample_of_pixel >= 1)
 652                                         {
 653 // update lowsample and highsample
 654                                                 if(buffer[bufferposition] < lowsample)
 655                                                         lowsample = buffer[bufferposition];
 656                                                 else
 657                                                 if(buffer[bufferposition] > highsample)
 658                                                         highsample = buffer[bufferposition];
 659                                         }
 660
 661
 662                                         sample_of_pixel++;
 663                                 }
 664
 665
 666
 667
 668
 669                         }
 670
 671
 672                         canvas->test_timer();
 673                 }
 674                 delete [] buffer;
 675         }
 676
 677         mwindow->audio_cache->check_in(edit->asset);
 678 }
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699 void ResourcePixmap::draw_video_resource(Edit *edit,
 700         int64_t edit_x,
 701         int64_t edit_w,
 702         int64_t pixmap_x,
 703         int64_t pixmap_w,
 704         int refresh_x,
 705         int refresh_w)
 706 {
 707 //printf("ResourcePixmap::draw_video_resource 1\n");
 708 // pixels spanned by a picon
 709         int64_t picon_w = Units::round(edit->picon_w());
 710         int64_t picon_h = edit->picon_h();
 711
 712 //printf("ResourcePixmap::draw_video_resource 1\n");
 713 // Don't draw video if picon is bigger than edit
 714         if(picon_w > edit_w) return;
 715
 716 //printf("ResourcePixmap::draw_video_resource 1\n");
 717 // pixels spanned by a frame
 718         double frame_w = edit->frame_w();
 719
 720 //printf("ResourcePixmap::draw_video_resource 1\n");
 721 // Frames spanned by a picon
 722         double frames_per_picon = edit->frames_per_picon();
 723
 724 //printf("ResourcePixmap::draw_video_resource 1\n");
 725 // Current pixel relative to pixmap
 726         int x = 0;
 727         int y = 0;
 728         if(mwindow->edl->session->show_titles)
 729                 y += mwindow->theme->title_bg_data->get_h();
 730 // Frame in project touched by current pixel
 731         int64_t project_frame;
 732
 733 // Get first frame touched by x and fix x to start of frame
 734         if(frames_per_picon > 1)
 735         {
 736                 int picon = Units::to_int64((double)(refresh_x + pixmap_x - edit_x) / picon_w);
 737                 x = picon_w * picon + edit_x - pixmap_x;
 738                 project_frame = Units::to_int64((double)picon * frames_per_picon);
 739         }
 740         else
 741         {
 742                 project_frame = Units::to_int64((double)(refresh_x + pixmap_x - edit_x) /
 743                         frame_w);
 744                 x = Units::round((double)project_frame * frame_w + edit_x - pixmap_x);
 745         }
 746
 747 //printf("ResourcePixmap::draw_video_resource 1 %s\n", edit->asset->path);
 748         File *source = mwindow->video_cache->check_out(edit->asset);
 749         if(!source) return;
 750
 751
 752 //printf("ResourcePixmap::draw_video_resource 2 project_frame=%d frame_w=%f refresh_x=%d refresh_w=%d x=%d\n",
 753 //project_frame, frame_w, refresh_x, refresh_w, x);
 754         while(x < refresh_x + refresh_w)
 755         {
 756                 int64_t source_frame = project_frame + edit->startsource;
 757                 source->set_layer(edit->channel);
 758                 source->set_video_position(source_frame,
 759                         mwindow->edl->session->frame_rate);
 760
 761 // Try displaying from source cache
 762                 FrameCache *frame_cache = source->get_frame_cache();
 763                 VFrame *picon_frame = 0;
 764                 int use_cache = 0;
 765
 766 //frame_cache->dump();
 767                 if((picon_frame = frame_cache->get_frame_ptr(source_frame,
 768                         mwindow->edl->session->frame_rate,
 769                         BC_RGB888,
 770                         picon_w,
 771                         picon_h)) != 0)
 772                 {
 773                         use_cache = 1;
 774                 }
 775                 else
 776 // Display from file and put in cache
 777                 {
 778                         if(canvas->temp_picon &&
 779                                 (canvas->temp_picon->get_w() != edit->asset->width ||
 780                                 canvas->temp_picon->get_h() != edit->asset->height))
 781                         {
 782                                 delete canvas->temp_picon;
 783                                 canvas->temp_picon = 0;
 784                         }
 785
 786                         if(!canvas->temp_picon)
 787                         {
 788                                 canvas->temp_picon = new VFrame(0,
 789                                         edit->asset->width,
 790                                         edit->asset->height,
 791                                         BC_RGB888);
 792                         }
 793
 794                         source->read_frame(canvas->temp_picon);
 795                         picon_frame = new VFrame(0, picon_w, picon_h, BC_RGB888);
 796                         frame_cache->put_frame(picon_frame,
 797                                 source_frame,
 798                                 mwindow->edl->session->frame_rate,
 799                                 0);
 800                         cmodel_transfer(picon_frame->get_rows(),
 801                                 canvas->temp_picon->get_rows(),
 802                                 0,
 803                                 0,
 804                                 0,
 805                                 0,
 806                                 0,
 807                                 0,
 808                                 0,
 809                                 0,
 810                                 canvas->temp_picon->get_w(),
 811                                 canvas->temp_picon->get_h(),
 812                                 0,
 813                                 0,
 814                                 picon_frame->get_w(),
 815                                 picon_frame->get_h(),
 816                                 BC_RGB888,
 817                                 BC_RGB888,
 818                                 0,
 819                                 canvas->temp_picon->get_bytes_per_line(),
 820                                 picon_frame->get_bytes_per_line());
 821                 }
 822
 823                 draw_vframe(picon_frame,
 824                         x,
 825                         y,
 826                         picon_w,
 827                         picon_h,
 828                         0,
 829                         0);
 830
 831                 if(use_cache)
 832                         frame_cache->unlock();
 833
 834                 if(frames_per_picon > 1)
 835                 {
 836                         x += Units::round(picon_w);
 837                         project_frame = Units::to_int64(frames_per_picon * (int64_t)((double)(x + pixmap_x - edit_x) / picon_w));
 838                 }
 839                 else
 840                 {
 841                         x += Units::round(frame_w);
 842                         project_frame = (int64_t)((double)(x + pixmap_x - edit_x) / frame_w);
 843                 }
 844
 845
 846                 canvas->test_timer();
 847         }
 848
 849         if(source)
 850         {
 851                 mwindow->video_cache->check_in(edit->asset);
 852         }
 853 }
 854
 855
 856 void ResourcePixmap::dump()
 857 {
 858         printf("ResourcePixmap %p\n", this);
 859         printf(" edit %x edit_x %d pixmap_x %d pixmap_w %d visible %d\n", edit_id, edit_x, pixmap_x, pixmap_w, visible);
 860 }
 861
 862
 863