git.sesse.net Git - kdenlive/blob - src/renderer.cpp

   1 /***************************************************************************
   2                         krender.cpp  -  description
   3                            -------------------
   4   begin                : Fri Nov 22 2002
   5   copyright            : (C) 2002 by Jason Wood
   6   email                : jasonwood@blueyonder.co.uk
   7   copyright            : (C) 2005 Lucio Flavio Correa
   8   email                : lucio.correa@gmail.com
   9   copyright            : (C) Marco Gittler
  10   email                : g.marco@freenet.de
  11   copyright            : (C) 2006 Jean-Baptiste Mardelle
  12   email                : jb@kdenlive.org
  13
  14 ***************************************************************************/
  15
  16 /***************************************************************************
  17  *                                                                         *
  18  *   This program is free software; you can redistribute it and/or modify  *
  19  *   it under the terms of the GNU General Public License as published by  *
  20  *   the Free Software Foundation; either version 2 of the License, or     *
  21  *   (at your option) any later version.                                   *
  22  *                                                                         *
  23  ***************************************************************************/
  24
  25
  26 #include "renderer.h"
  27 #include "kdenlivesettings.h"
  28 #include "kthumb.h"
  29 #include "definitions.h"
  30 #include "slideshowclip.h"
  31 #include "profilesdialog.h"
  32 #include "blackmagic/devices.h"
  33
  34 #include <mlt++/Mlt.h>
  35
  36 #include <KDebug>
  37 #include <KStandardDirs>
  38 #include <KMessageBox>
  39 #include <KLocale>
  40 #include <KTemporaryFile>
  41
  42 #include <QTimer>
  43 #include <QDir>
  44 #include <QString>
  45 #include <QApplication>
  46 #include <QtConcurrentRun>
  47
  48 #include <cstdlib>
  49 #include <cstdarg>
  50
  51 #include <QDebug>
  52
  53
  54 static void kdenlive_callback(void* /*ptr*/, int level, const char* fmt, va_list vl)
  55 {
  56 //     kDebug() << "log level" << level << QString().vsprintf(fmt, vl).simplified();
  57     if (level > MLT_LOG_ERROR) return;
  58     QString error;
  59     QApplication::postEvent(qApp->activeWindow(), new MltErrorEvent(error.vsprintf(fmt, vl).simplified()));
  60     va_end(vl);
  61 }
  62
  63
  64 static void consumer_frame_show(mlt_consumer, Render * self, mlt_frame frame_ptr)
  65 {
  66     // detect if the producer has finished playing. Is there a better way to do it?
  67     Mlt::Frame frame(frame_ptr);
  68     if (!frame.is_valid()) return;
  69     self->emitFrameNumber(mlt_frame_get_position(frame_ptr));
  70     if (self->sendFrameForAnalysis && frame_ptr->convert_image) {
  71         self->emitFrameUpdated(frame);
  72     }
  73     if (self->analyseAudio) {
  74         self->showAudio(frame);
  75     }
  76     if (frame.get_double("_speed") < 0.0 && mlt_frame_get_position(frame_ptr) <= 0) {
  77         self->pause();
  78         self->emitConsumerStopped();
  79     }
  80 }
  81
  82
  83 static void consumer_paused(mlt_consumer, Render * self, mlt_frame /*frame_ptr*/)
  84 {
  85     // detect if the producer has finished playing. Is there a better way to do it?
  86     self->emitConsumerStopped();
  87 }
  88
  89
  90 static void consumer_gl_frame_show(mlt_consumer, Render * self, mlt_frame frame_ptr)
  91 {
  92     // detect if the producer has finished playing. Is there a better way to do it?
  93     Mlt::Frame frame(frame_ptr);
  94     self->showFrame(frame);
  95     if (frame.get_double("_speed") == 0.0) {
  96         self->emitConsumerStopped();
  97     } else if (frame.get_double("_speed") < 0.0 && mlt_frame_get_position(frame_ptr) <= 0) {
  98         self->pause();
  99         self->emitConsumerStopped();
 100     }
 101 }
 102
 103 Render::Render(const QString & rendererName, int winid, QString profile, QWidget *parent) :
 104     AbstractRender(rendererName, parent),
 105     analyseAudio(KdenliveSettings::monitor_audio()),
 106     m_name(rendererName),
 107     m_mltConsumer(NULL),
 108     m_mltProducer(NULL),
 109     m_mltProfile(NULL),
 110     m_framePosition(0),
 111     m_externalConsumer(false),
 112     m_isZoneMode(false),
 113     m_isLoopMode(false),
 114     m_isSplitView(false),
 115     m_blackClip(NULL),
 116     m_winid(winid)
 117 {
 118     if (profile.isEmpty()) profile = KdenliveSettings::current_profile();
 119     buildConsumer(profile);
 120     m_mltProducer = m_blackClip->cut(0, 1);
 121     m_mltConsumer->connect(*m_mltProducer);
 122     m_mltProducer->set_speed(0.0);
 123 }
 124
 125 Render::~Render()
 126 {
 127     closeMlt();
 128     delete m_mltProfile;
 129 }
 130
 131
 132 void Render::closeMlt()
 133 {
 134     //delete m_osdTimer;
 135     m_requestList.clear();
 136     m_infoThread.waitForFinished();
 137     if (m_mltConsumer) delete m_mltConsumer;
 138     if (m_mltProducer) delete m_mltProducer;
 139     /*if (m_mltProducer) {
 140         Mlt::Service service(m_mltProducer->parent().get_service());
 141         service.lock();
 142
 143         if (service.type() == tractor_type) {
 144             Mlt::Tractor tractor(service);
 145             Mlt::Field *field = tractor.field();
 146             mlt_service nextservice = mlt_service_get_producer(service.get_service());
 147             mlt_service nextservicetodisconnect;
 148             mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
 149             QString mlt_type = mlt_properties_get(properties, "mlt_type");
 150             QString resource = mlt_properties_get(properties, "mlt_service");
 151             // Delete all transitions
 152             while (mlt_type == "transition") {
 153                 nextservicetodisconnect = nextservice;
 154                 nextservice = mlt_service_producer(nextservice);
 155                 mlt_field_disconnect_service(field->get_field(), nextservicetodisconnect);
 156                 if (nextservice == NULL) break;
 157                 properties = MLT_SERVICE_PROPERTIES(nextservice);
 158                 mlt_type = mlt_properties_get(properties, "mlt_type");
 159                 resource = mlt_properties_get(properties, "mlt_service");
 160             }
 161
 162             delete field;
 163             field = NULL;
 164         }
 165         service.unlock();
 166     }*/
 167
 168     kDebug() << "// // // CLOSE RENDERER " << m_name;
 169     if (m_blackClip) delete m_blackClip;
 170     //delete m_osdInfo;
 171 }
 172
 173 void Render::slotSwitchFullscreen()
 174 {
 175     if (m_mltConsumer) m_mltConsumer->set("full_screen", 1);
 176 }
 177
 178 void Render::buildConsumer(const QString &profileName)
 179 {
 180     delete m_blackClip;
 181     m_blackClip = NULL;
 182
 183     //TODO: uncomment following line when everything is clean
 184     // uncommented Feb 2011 --Granjow
 185     if (m_mltProfile) delete m_mltProfile;
 186     m_activeProfile = profileName;
 187     char *tmp = qstrdup(m_activeProfile.toUtf8().constData());
 188     setenv("MLT_PROFILE", tmp, 1);
 189     m_mltProfile = new Mlt::Profile(tmp);
 190     m_mltProfile->set_explicit(true);
 191     kDebug()<<"// *********  PROFILE AR: "<<m_mltProfile->dar();
 192     delete[] tmp;
 193
 194     m_blackClip = new Mlt::Producer(*m_mltProfile, "colour", "black");
 195     m_blackClip->set("id", "black");
 196     m_blackClip->set("mlt_type", "producer");
 197
 198     if (KdenliveSettings::external_display() && m_name != "clip") {
 199         // Use blackmagic card for video output
 200         QMap< QString, QString > profileProperties = ProfilesDialog::getSettingsFromFile(profileName);
 201         int device = KdenliveSettings::blackmagic_output_device();
 202         if (device >= 0) {
 203             if (BMInterface::isSupportedProfile(device, profileProperties)) {
 204                 QString decklink = "decklink:" + QString::number(KdenliveSettings::blackmagic_output_device());
 205                 tmp = qstrdup(decklink.toUtf8().constData());
 206                 m_mltConsumer = new Mlt::Consumer(*m_mltProfile, tmp);
 207                 delete[] tmp;
 208                 if (m_mltConsumer->is_valid()) {
 209                     m_externalConsumer = true;
 210                     m_mltConsumer->listen("consumer-frame-show", this, (mlt_listener) consumer_frame_show);
 211                     m_mltConsumer->set("terminate_on_pause", 0);
 212                     m_mltConsumer->set("buffer", 12);
 213                     m_mltConsumer->set("deinterlace_method", "onefield");
 214                     m_mltConsumer->set("real_time", KdenliveSettings::mltthreads());
 215                     mlt_log_set_callback(kdenlive_callback);
 216                 }
 217                 if (m_mltConsumer && m_mltConsumer->is_valid()) return;
 218             } else KMessageBox::informationList(qApp->activeWindow(), i18n("Your project's profile %1 is not compatible with the blackmagic output card. Please see supported profiles below. Switching to normal video display.", m_mltProfile->description()), BMInterface::supportedModes(KdenliveSettings::blackmagic_output_device()));
 219         }
 220     }
 221     m_externalConsumer = false;
 222     QString videoDriver = KdenliveSettings::videodrivername();
 223     if (!videoDriver.isEmpty()) {
 224         if (videoDriver == "x11_noaccel") {
 225             setenv("SDL_VIDEO_YUV_HWACCEL", "0", 1);
 226             videoDriver = "x11";
 227         } else {
 228             unsetenv("SDL_VIDEO_YUV_HWACCEL");
 229         }
 230     }
 231     setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", 1);
 232
 233     //m_mltConsumer->set("fullscreen", 1);
 234     if (m_winid == 0) {
 235         // OpenGL monitor
 236         m_mltConsumer = new Mlt::Consumer(*m_mltProfile, "sdl_audio");
 237         m_mltConsumer->set("preview_off", 1);
 238         m_mltConsumer->set("preview_format", mlt_image_rgb24a);
 239         m_mltConsumer->listen("consumer-frame-show", this, (mlt_listener) consumer_gl_frame_show);
 240     } else {
 241         m_mltConsumer = new Mlt::Consumer(*m_mltProfile, "sdl_preview");
 242         // FIXME: the event object returned by the listen gets leaked...
 243         m_mltConsumer->listen("consumer-frame-show", this, (mlt_listener) consumer_frame_show);
 244         m_mltConsumer->listen("consumer-sdl-paused", this, (mlt_listener) consumer_paused);
 245         m_mltConsumer->set("window_id", m_winid);
 246     }
 247     m_mltConsumer->set("resize", 1);
 248     m_mltConsumer->set("terminate_on_pause", 1);
 249     m_mltConsumer->set("window_background", KdenliveSettings::window_background().name().toUtf8().constData());
 250     m_mltConsumer->set("rescale", "nearest");
 251     mlt_log_set_callback(kdenlive_callback);
 252
 253     QString audioDevice = KdenliveSettings::audiodevicename();
 254     if (!audioDevice.isEmpty())
 255         m_mltConsumer->set("audio_device", audioDevice.toUtf8().constData());
 256
 257     if (!videoDriver.isEmpty())
 258         m_mltConsumer->set("video_driver", videoDriver.toUtf8().constData());
 259
 260     QString audioDriver = KdenliveSettings::audiodrivername();
 261
 262     /*
 263     // Disabled because the "auto" detected driver was sometimes wrong
 264     if (audioDriver.isEmpty())
 265         audioDriver = KdenliveSettings::autoaudiodrivername();
 266     */
 267
 268     if (!audioDriver.isEmpty())
 269         m_mltConsumer->set("audio_driver", audioDriver.toUtf8().constData());
 270
 271     m_mltConsumer->set("progressive", 1);
 272     m_mltConsumer->set("audio_buffer", 1024);
 273     m_mltConsumer->set("frequency", 48000);
 274     m_mltConsumer->set("real_time", KdenliveSettings::mltthreads());
 275 }
 276
 277 Mlt::Producer *Render::invalidProducer(const QString &id)
 278 {
 279     Mlt::Producer *clip;
 280     QString txt = "+" + i18n("Missing clip") + ".txt";
 281     char *tmp = qstrdup(txt.toUtf8().constData());
 282     clip = new Mlt::Producer(*m_mltProfile, tmp);
 283     delete[] tmp;
 284     if (clip == NULL) clip = new Mlt::Producer(*m_mltProfile, "colour", "red");
 285     else {
 286         clip->set("bgcolour", "0xff0000ff");
 287         clip->set("pad", "10");
 288     }
 289     clip->set("id", id.toUtf8().constData());
 290     clip->set("mlt_type", "producer");
 291     return clip;
 292 }
 293
 294 int Render::resetProfile(const QString &profileName, bool dropSceneList)
 295 {
 296     QString scene;
 297     if (!dropSceneList) scene = sceneList();
 298     if (m_mltConsumer) {
 299         if (m_externalConsumer == KdenliveSettings::external_display()) {
 300             if (KdenliveSettings::external_display() && m_activeProfile == profileName) return 1;
 301             QString videoDriver = KdenliveSettings::videodrivername();
 302             QString currentDriver = m_mltConsumer->get("video_driver");
 303             if (getenv("SDL_VIDEO_YUV_HWACCEL") != NULL && currentDriver == "x11") currentDriver = "x11_noaccel";
 304             QString background = KdenliveSettings::window_background().name();
 305             QString currentBackground = m_mltConsumer->get("window_background");
 306             if (m_activeProfile == profileName && currentDriver == videoDriver && background == currentBackground) {
 307                 kDebug() << "reset to same profile, nothing to do";
 308                 return 1;
 309             }
 310         }
 311
 312         if (m_isSplitView) slotSplitView(false);
 313         if (!m_mltConsumer->is_stopped()) m_mltConsumer->stop();
 314         m_mltConsumer->purge();
 315         delete m_mltConsumer;
 316         m_mltConsumer = NULL;
 317     }
 318     int pos = 0;
 319     double current_fps = m_mltProfile->fps();
 320     double current_dar = m_mltProfile->dar();
 321     delete m_blackClip;
 322     m_blackClip = NULL;
 323     m_requestList.clear();
 324     m_infoThread.waitForFinished();
 325
 326     if (m_mltProducer) {
 327         pos = m_mltProducer->position();
 328
 329         Mlt::Service service(m_mltProducer->get_service());
 330         if (service.type() == tractor_type) {
 331             Mlt::Tractor tractor(service);
 332             for (int trackNb = tractor.count() - 1; trackNb >= 0; --trackNb) {
 333                 Mlt::Producer trackProducer(tractor.track(trackNb));
 334                 Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
 335                 trackPlaylist.clear();
 336             }
 337         }
 338
 339         delete m_mltProducer;
 340     }
 341     m_mltProducer = NULL;
 342     buildConsumer(profileName);
 343     double new_fps = m_mltProfile->fps();
 344     double new_dar = m_mltProfile->dar();
 345
 346     if (!dropSceneList) {
 347         // We need to recover our playlist
 348         if (current_fps != new_fps) {
 349             // fps changed, we must update the scenelist positions
 350             scene = updateSceneListFps(current_fps, new_fps, scene);
 351         }
 352         setSceneList(scene, pos);
 353         // producers have changed (different profile), so reset them...
 354         emit refreshDocumentProducers(new_dar != current_dar, current_fps != new_fps);
 355     }
 356     return 1;
 357 }
 358
 359 void Render::seek(GenTime time)
 360 {
 361     if (!m_mltProducer)
 362         return;
 363     m_mltProducer->seek((int)(time.frames(m_fps)));
 364     refresh();
 365 }
 366
 367 void Render::seek(int time)
 368 {
 369     if (!m_mltProducer)
 370         return;
 371     m_mltProducer->seek(time);
 372     refresh();
 373 }
 374
 375 //static
 376 /*QPixmap Render::frameThumbnail(Mlt::Frame *frame, int width, int height, bool border) {
 377     QPixmap pix(width, height);
 378
 379     mlt_image_format format = mlt_image_rgb24a;
 380     uint8_t *thumb = frame->get_image(format, width, height);
 381     QImage image(thumb, width, height, QImage::Format_ARGB32);
 382
 383     if (!image.isNull()) {
 384         pix = pix.fromImage(image);
 385         if (border) {
 386             QPainter painter(&pix);
 387             painter.drawRect(0, 0, width - 1, height - 1);
 388         }
 389     } else pix.fill(Qt::black);
 390     return pix;
 391 }
 392 */
 393 int Render::frameRenderWidth() const
 394 {
 395     return m_mltProfile->width();
 396 }
 397
 398 int Render::renderWidth() const
 399 {
 400     return (int)(m_mltProfile->height() * m_mltProfile->dar() + 0.5);
 401 }
 402
 403 int Render::renderHeight() const
 404 {
 405     return m_mltProfile->height();
 406 }
 407
 408 QImage Render::extractFrame(int frame_position, QString path, int width, int height)
 409 {
 410     if (width == -1) {
 411         width = frameRenderWidth();
 412         height = renderHeight();
 413     } else if (width % 2 == 1) width++;
 414     int dwidth = height * frameRenderWidth() / renderHeight();
 415     if (!path.isEmpty()) {
 416         Mlt::Producer *producer = new Mlt::Producer(*m_mltProfile, path.toUtf8().constData());
 417         if (producer) {
 418             if (producer->is_valid()) {
 419                 QImage img = KThumb::getFrame(producer, frame_position, dwidth, width, height);
 420                 delete producer;
 421                 return img;
 422             }
 423             else delete producer;
 424         }
 425     }
 426
 427     if (!m_mltProducer || !path.isEmpty()) {
 428         QImage pix(width, height, QImage::Format_RGB32);
 429         pix.fill(Qt::black);
 430         return pix;
 431     }
 432     return KThumb::getFrame(m_mltProducer, frame_position, dwidth, width, height);
 433 }
 434
 435 QPixmap Render::getImageThumbnail(KUrl url, int /*width*/, int /*height*/)
 436 {
 437     QImage im;
 438     QPixmap pixmap;
 439     if (url.fileName().startsWith(".all.")) {  //  check for slideshow
 440         QString fileType = url.fileName().right(3);
 441         QStringList more;
 442         QStringList::Iterator it;
 443
 444         QDir dir(url.directory());
 445         QStringList filter;
 446         filter << "*." + fileType;
 447         filter << "*." + fileType.toUpper();
 448         more = dir.entryList(filter, QDir::Files);
 449         im.load(url.directory() + '/' + more.at(0));
 450     } else im.load(url.path());
 451     //pixmap = im.scaled(width, height);
 452     return pixmap;
 453 }
 454
 455 double Render::consumerRatio() const
 456 {
 457     if (!m_mltConsumer) return 1.0;
 458     return (m_mltConsumer->get_double("aspect_ratio_num") / m_mltConsumer->get_double("aspect_ratio_den"));
 459 }
 460
 461
 462 int Render::getLength()
 463 {
 464
 465     if (m_mltProducer) {
 466         // kDebug()<<"//////  LENGTH: "<<mlt_producer_get_playtime(m_mltProducer->get_producer());
 467         return mlt_producer_get_playtime(m_mltProducer->get_producer());
 468     }
 469     return 0;
 470 }
 471
 472 bool Render::isValid(KUrl url)
 473 {
 474     Mlt::Producer producer(*m_mltProfile, url.path().toUtf8().constData());
 475     if (producer.is_blank())
 476         return false;
 477
 478     return true;
 479 }
 480
 481 double Render::dar() const
 482 {
 483     return m_mltProfile->dar();
 484 }
 485
 486 double Render::sar() const
 487 {
 488     return m_mltProfile->sar();
 489 }
 490
 491 void Render::slotSplitView(bool doit)
 492 {
 493     m_isSplitView = doit;
 494     Mlt::Service service(m_mltProducer->parent().get_service());
 495     Mlt::Tractor tractor(service);
 496     if (service.type() != tractor_type || tractor.count() < 2) return;
 497     Mlt::Field *field = tractor.field();
 498     if (doit) {
 499         for (int i = 1, screen = 0; i < tractor.count() && screen < 4; i++) {
 500             Mlt::Producer trackProducer(tractor.track(i));
 501             kDebug() << "// TRACK: " << i << ", HIDE: " << trackProducer.get("hide");
 502             if (QString(trackProducer.get("hide")).toInt() != 1) {
 503                 kDebug() << "// ADIDNG TRACK: " << i;
 504                 Mlt::Transition *transition = new Mlt::Transition(*m_mltProfile, "composite");
 505                 transition->set("mlt_service", "composite");
 506                 transition->set("a_track", 0);
 507                 transition->set("b_track", i);
 508                 transition->set("distort", 1);
 509                 transition->set("internal_added", "200");
 510                 const char *tmp;
 511                 switch (screen) {
 512                 case 0:
 513                     tmp = "0,0:50%x50%";
 514                     break;
 515                 case 1:
 516                     tmp = "50%,0:50%x50%";
 517                     break;
 518                 case 2:
 519                     tmp = "0,50%:50%x50%";
 520                     break;
 521                 case 3:
 522                 default:
 523                     tmp = "50%,50%:50%x50%";
 524                     break;
 525                 }
 526                 transition->set("geometry", tmp);
 527                 transition->set("always_active", "1");
 528                 field->plant_transition(*transition, 0, i);
 529                 //delete[] tmp;
 530                 screen++;
 531             }
 532         }
 533         m_mltConsumer->set("refresh", 1);
 534     } else {
 535         mlt_service serv = m_mltProducer->parent().get_service();
 536         mlt_service nextservice = mlt_service_get_producer(serv);
 537         mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
 538         QString mlt_type = mlt_properties_get(properties, "mlt_type");
 539         QString resource = mlt_properties_get(properties, "mlt_service");
 540
 541         while (mlt_type == "transition") {
 542             QString added = mlt_properties_get(MLT_SERVICE_PROPERTIES(nextservice), "internal_added");
 543             if (added == "200") {
 544                 mlt_field_disconnect_service(field->get_field(), nextservice);
 545             }
 546             nextservice = mlt_service_producer(nextservice);
 547             if (nextservice == NULL) break;
 548             properties = MLT_SERVICE_PROPERTIES(nextservice);
 549             mlt_type = mlt_properties_get(properties, "mlt_type");
 550             resource = mlt_properties_get(properties, "mlt_service");
 551             m_mltConsumer->set("refresh", 1);
 552         }
 553     }
 554 }
 555
 556 void Render::getFileProperties(const QDomElement &xml, const QString &clipId, int imageHeight, bool replaceProducer)
 557 {
 558     requestClipInfo info;
 559     info.xml = xml;
 560     info.clipId = clipId;
 561     info.imageHeight = imageHeight;
 562     info.replaceProducer = replaceProducer;
 563     // Make sure we don't request the info for same clip twice
 564     m_requestList.removeAll(info);
 565     m_requestList.append(info);
 566     if (!m_infoThread.isRunning())
 567         m_infoThread = QtConcurrent::run(this, &Render::processFileProperties);
 568 }
 569
 570 void Render::forceProcessing(const QString &id)
 571 {
 572     m_infoMutex.lock();
 573     for (int i = 0; i < m_requestList.count(); i++) {
 574         requestClipInfo info = m_requestList.at(i);
 575         if (info.clipId == id) {
 576             if (i == 0) break;
 577             else {
 578                 m_requestList.removeAt(i);
 579                 m_requestList.prepend(info);
 580                 break;
 581             }
 582         }
 583     }
 584     m_infoMutex.unlock();
 585 }
 586
 587 int Render::processingItems() const
 588 {
 589     int count = m_requestList.count();
 590     if (m_infoThread.isRunning()) count++;
 591     return count;
 592 }
 593
 594 void Render::processFileProperties()
 595 {
 596     requestClipInfo info;
 597     QLocale locale;
 598     while (!m_requestList.isEmpty()) {
 599         m_infoMutex.lock();
 600         info = m_requestList.takeFirst();
 601         m_infoMutex.unlock();
 602         if (info.replaceProducer) emit blockClipMonitor(info.clipId);
 603         QString path;
 604         bool proxyProducer;
 605         if (info.xml.hasAttribute("proxy") && info.xml.attribute("proxy") != "-") {
 606             path = info.xml.attribute("proxy");
 607             proxyProducer = true;
 608         }
 609         else {
 610             path = info.xml.attribute("resource");
 611             proxyProducer = false;
 612         }
 613         KUrl url(path);
 614         Mlt::Producer *producer = NULL;
 615         CLIPTYPE type = (CLIPTYPE)info.xml.attribute("type").toInt();
 616
 617         if (type == COLOR) {
 618             producer = new Mlt::Producer(*m_mltProfile, 0, ("colour:" + info.xml.attribute("colour")).toUtf8().constData());
 619         } else if (type == TEXT) {
 620             producer = new Mlt::Producer(*m_mltProfile, 0, ("kdenlivetitle:" + info.xml.attribute("resource")).toUtf8().constData());
 621             if (producer && producer->is_valid() && info.xml.hasAttribute("xmldata"))
 622                 producer->set("xmldata", info.xml.attribute("xmldata").toUtf8().constData());
 623         } else if (url.isEmpty()) {
 624             QDomDocument doc;
 625             QDomElement mlt = doc.createElement("mlt");
 626             QDomElement play = doc.createElement("playlist");
 627             doc.appendChild(mlt);
 628             mlt.appendChild(play);
 629             play.appendChild(doc.importNode(info.xml, true));
 630             producer = new Mlt::Producer(*m_mltProfile, "xml-string", doc.toString().toUtf8().constData());
 631         } else {
 632             producer = new Mlt::Producer(*m_mltProfile, path.toUtf8().constData());
 633         }
 634
 635         if (producer == NULL || producer->is_blank() || !producer->is_valid()) {
 636             kDebug() << " / / / / / / / / ERROR / / / / // CANNOT LOAD PRODUCER: "<<path;
 637             if (proxyProducer) {
 638                 // Proxy file is corrupted
 639                 emit removeInvalidProxy(info.clipId, false);
 640             }
 641             else emit removeInvalidClip(info.clipId, info.replaceProducer);
 642             delete producer;
 643             continue;
 644         }
 645
 646         if (proxyProducer && info.xml.hasAttribute("proxy_out")) {
 647             producer->set("length", info.xml.attribute("proxy_out").toInt() + 1);
 648             producer->set("out", info.xml.attribute("proxy_out").toInt());
 649             if (producer->get_out() != info.xml.attribute("proxy_out").toInt()) {
 650                 // Proxy file length is different than original clip length, this will corrupt project so disable this proxy clip
 651                 emit removeInvalidProxy(info.clipId, true);
 652                 delete producer;
 653                 continue;
 654             }
 655         }
 656
 657         if (info.xml.hasAttribute("force_aspect_ratio")) {
 658             double aspect = info.xml.attribute("force_aspect_ratio").toDouble();
 659             if (aspect > 0) producer->set("force_aspect_ratio", aspect);
 660         }
 661
 662         if (info.xml.hasAttribute("force_aspect_num") && info.xml.hasAttribute("force_aspect_den")) {
 663             int width = info.xml.attribute("frame_size").section('x', 0, 0).toInt();
 664             int height = info.xml.attribute("frame_size").section('x', 1, 1).toInt();
 665             int aspectNumerator = info.xml.attribute("force_aspect_num").toInt();
 666             int aspectDenominator = info.xml.attribute("force_aspect_den").toInt();
 667             if (aspectDenominator != 0 && width != 0)
 668                 producer->set("force_aspect_ratio", double(height) * aspectNumerator / aspectDenominator / width);
 669         }
 670
 671         if (info.xml.hasAttribute("force_fps")) {
 672             double fps = info.xml.attribute("force_fps").toDouble();
 673             if (fps > 0) producer->set("force_fps", fps);
 674         }
 675
 676         if (info.xml.hasAttribute("force_progressive")) {
 677             bool ok;
 678             int progressive = info.xml.attribute("force_progressive").toInt(&ok);
 679             if (ok) producer->set("force_progressive", progressive);
 680         }
 681         if (info.xml.hasAttribute("force_tff")) {
 682             bool ok;
 683             int fieldOrder = info.xml.attribute("force_tff").toInt(&ok);
 684             if (ok) producer->set("force_tff", fieldOrder);
 685         }
 686         if (info.xml.hasAttribute("threads")) {
 687             int threads = info.xml.attribute("threads").toInt();
 688             if (threads != 1) producer->set("threads", threads);
 689         }
 690         if (info.xml.hasAttribute("video_index")) {
 691             int vindex = info.xml.attribute("video_index").toInt();
 692             if (vindex != 0) producer->set("video_index", vindex);
 693         }
 694         if (info.xml.hasAttribute("audio_index")) {
 695             int aindex = info.xml.attribute("audio_index").toInt();
 696             if (aindex != 0) producer->set("audio_index", aindex);
 697         }
 698         if (info.xml.hasAttribute("force_colorspace")) {
 699             int colorspace = info.xml.attribute("force_colorspace").toInt();
 700             if (colorspace != 0) producer->set("force_colorspace", colorspace);
 701         }
 702         if (info.xml.hasAttribute("full_luma")) {
 703             int full_luma = info.xml.attribute("full_luma").toInt();
 704             if (full_luma != 0) producer->set("set.force_full_luma", full_luma);
 705         }
 706
 707         int clipOut = 0;
 708         int duration = 0;
 709         if (info.xml.hasAttribute("out")) clipOut = info.xml.attribute("out").toInt();
 710
 711         // setup length here as otherwise default length (currently 15000 frames in MLT) will be taken even if outpoint is larger
 712         if (type == COLOR || type == TEXT || type == IMAGE || type == SLIDESHOW) {
 713             int length;
 714             if (info.xml.hasAttribute("length")) {
 715                 if (clipOut > 0) duration = clipOut + 1;
 716                 length = info.xml.attribute("length").toInt();
 717                 clipOut = length - 1;
 718             }
 719             else length = info.xml.attribute("out").toInt() - info.xml.attribute("in").toInt();
 720             producer->set("length", length);
 721         }
 722
 723         if (clipOut > 0) producer->set_in_and_out(info.xml.attribute("in").toInt(), clipOut);
 724
 725         producer->set("id", info.clipId.toUtf8().constData());
 726
 727         if (info.xml.hasAttribute("templatetext"))
 728             producer->set("templatetext", info.xml.attribute("templatetext").toUtf8().constData());
 729
 730         if ((!info.replaceProducer && info.xml.hasAttribute("file_hash")) || proxyProducer) {
 731             // Clip  already has all properties
 732             emit replyGetFileProperties(info.clipId, producer, stringMap(), stringMap(), info.replaceProducer, true);
 733             continue;
 734         }
 735
 736         int imageWidth = (int)((double) info.imageHeight * m_mltProfile->width() / m_mltProfile->height() + 0.5);
 737         int fullWidth = (int)((double) info.imageHeight * m_mltProfile->dar() + 0.5);
 738         stringMap filePropertyMap;
 739         stringMap metadataPropertyMap;
 740
 741         int frameNumber = info.xml.attribute("thumbnail", "-1").toInt();
 742         if (frameNumber > 0) producer->seek(frameNumber);
 743
 744         duration = duration > 0 ? duration : producer->get_playtime();
 745         filePropertyMap["duration"] = QString::number(duration);
 746         //kDebug() << "///////  PRODUCER: " << url.path() << " IS: " << producer->get_playtime();
 747
 748         if (type == SLIDESHOW) {
 749             int ttl = info.xml.hasAttribute("ttl") ? info.xml.attribute("ttl").toInt() : 0;
 750             if (ttl) producer->set("ttl", ttl);
 751             if (!info.xml.attribute("animation").isEmpty()) {
 752                 Mlt::Filter *filter = new Mlt::Filter(*m_mltProfile, "affine");
 753                 if (filter && filter->is_valid()) {
 754                     int cycle = ttl;
 755                     QString geometry = SlideshowClip::animationToGeometry(info.xml.attribute("animation"), cycle);
 756                     if (!geometry.isEmpty()) {
 757                         if (info.xml.attribute("animation").contains("low-pass")) {
 758                             Mlt::Filter *blur = new Mlt::Filter(*m_mltProfile, "boxblur");
 759                             if (blur && blur->is_valid())
 760                                 producer->attach(*blur);
 761                         }
 762                         filter->set("transition.geometry", geometry.toUtf8().data());
 763                         filter->set("transition.cycle", cycle);
 764                         producer->attach(*filter);
 765                     }
 766                 }
 767             }
 768             if (info.xml.attribute("fade") == "1") {
 769                 // user wants a fade effect to slideshow
 770                 Mlt::Filter *filter = new Mlt::Filter(*m_mltProfile, "luma");
 771                 if (filter && filter->is_valid()) {
 772                     if (ttl) filter->set("cycle", ttl);
 773                     if (info.xml.hasAttribute("luma_duration") && !info.xml.attribute("luma_duration").isEmpty()) filter->set("duration",      info.xml.attribute("luma_duration").toInt());
 774                     if (info.xml.hasAttribute("luma_file") && !info.xml.attribute("luma_file").isEmpty()) {
 775                         filter->set("luma.resource", info.xml.attribute("luma_file").toUtf8().constData());
 776                         if (info.xml.hasAttribute("softness")) {
 777                             int soft = info.xml.attribute("softness").toInt();
 778                             filter->set("luma.softness", (double) soft / 100.0);
 779                         }
 780                     }
 781                     producer->attach(*filter);
 782                 }
 783             }
 784             if (info.xml.attribute("crop") == "1") {
 785                 // user wants to center crop the slides
 786                 Mlt::Filter *filter = new Mlt::Filter(*m_mltProfile, "crop");
 787                 if (filter && filter->is_valid()) {
 788                     filter->set("center", 1);
 789                     producer->attach(*filter);
 790                 }
 791             }
 792         }
 793
 794         if (producer->get_double("meta.media.frame_rate_den") > 0) {
 795             filePropertyMap["fps"] = locale.toString(producer->get_double("meta.media.frame_rate_num") / producer->get_double("meta.media.frame_rate_den"));
 796         } else filePropertyMap["fps"] = producer->get("source_fps");
 797
 798         Mlt::Frame *frame = producer->get_frame();
 799         if (frame && frame->is_valid()) {
 800             filePropertyMap["frame_size"] = QString::number(frame->get_int("width")) + 'x' + QString::number(frame->get_int("height"));
 801             filePropertyMap["frequency"] = QString::number(frame->get_int("frequency"));
 802             filePropertyMap["channels"] = QString::number(frame->get_int("channels"));
 803             filePropertyMap["aspect_ratio"] = frame->get("aspect_ratio");
 804
 805             if (frame->get_int("test_image") == 0) {
 806                 if (url.path().endsWith(".mlt") || url.path().endsWith(".westley") || url.path().endsWith(".kdenlive")) {
 807                     filePropertyMap["type"] = "playlist";
 808                     metadataPropertyMap["comment"] = QString::fromUtf8(producer->get("title"));
 809                 } else if (frame->get_int("test_audio") == 0)
 810                     filePropertyMap["type"] = "av";
 811                 else
 812                     filePropertyMap["type"] = "video";
 813
 814                 int variance;
 815                 QImage img;
 816                 do {
 817                     variance = 100;
 818                     img = KThumb::getFrame(frame, imageWidth, fullWidth, info.imageHeight);
 819                     variance = KThumb::imageVariance(img);
 820                     if (frameNumber == -1 && variance< 6) {
 821                         // Thumbnail is not interesting (for example all black, seek to fetch better thumb
 822                         frameNumber =  duration > 100 ? 100 : duration / 2 ;
 823                         producer->seek(frameNumber);
 824                         delete frame;
 825                         frame = producer->get_frame();
 826                         variance = -1;
 827                     }
 828                 } while (variance == -1);
 829                 if (frameNumber > -1) filePropertyMap["thumbnail"] = frameNumber;
 830                 emit replyGetImage(info.clipId, img);
 831             } else if (frame->get_int("test_audio") == 0) {
 832                 emit replyGetImage(info.clipId, "audio-x-generic", fullWidth, info.imageHeight);
 833                 filePropertyMap["type"] = "audio";
 834             }
 835         }
 836         delete frame;
 837         // Retrieve audio / video codec name
 838
 839         // If there is a
 840         char property[200];
 841         if (producer->get_int("video_index") > -1) {
 842             /*if (context->duration == AV_NOPTS_VALUE) {
 843             kDebug() << " / / / / / / / /ERROR / / / CLIP HAS UNKNOWN DURATION";
 844                 emit removeInvalidClip(clipId);
 845             delete producer;
 846             return;
 847             }*/
 848             // Get the video_index
 849             int default_video = producer->get_int("video_index");
 850             int video_max = 0;
 851             int default_audio = producer->get_int("audio_index");
 852             int audio_max = 0;
 853
 854             // Find maximum stream index values
 855             for (int ix = 0; ix < producer->get_int("meta.media.nb_streams"); ix++) {
 856                 snprintf(property, sizeof(property), "meta.media.%d.stream.type", ix);
 857                 QString type = producer->get(property);
 858                 if (type == "video")
 859                     video_max = ix;
 860                 else if (type == "audio")
 861                     audio_max = ix;
 862             }
 863             filePropertyMap["default_video"] = QString::number(default_video);
 864             filePropertyMap["video_max"] = QString::number(video_max);
 865             filePropertyMap["default_audio"] = QString::number(default_audio);
 866             filePropertyMap["audio_max"] = QString::number(audio_max);
 867
 868             snprintf(property, sizeof(property), "meta.media.%d.codec.long_name", default_video);
 869             if (producer->get(property)) {
 870                 filePropertyMap["videocodec"] = producer->get(property);
 871             } else {
 872                 snprintf(property, sizeof(property), "meta.media.%d.codec.name", default_video);
 873                 if (producer->get(property))
 874                     filePropertyMap["videocodec"] = producer->get(property);
 875             }
 876             QString query;
 877             query = QString("meta.media.%1.codec.pix_fmt").arg(default_video);
 878             filePropertyMap["pix_fmt"] = producer->get(query.toUtf8().constData());
 879             filePropertyMap["colorspace"] = producer->get("meta.media.colorspace");
 880
 881         } else kDebug() << " / / / / /WARNING, VIDEO CONTEXT IS NULL!!!!!!!!!!!!!!";
 882         if (producer->get_int("audio_index") > -1) {
 883             // Get the audio_index
 884             int index = producer->get_int("audio_index");
 885             snprintf(property, sizeof(property), "meta.media.%d.codec.long_name", index);
 886             if (producer->get(property)) {
 887                 filePropertyMap["audiocodec"] = producer->get(property);
 888             } else {
 889                 snprintf(property, sizeof(property), "meta.media.%d.codec.name", index);
 890                 if (producer->get(property))
 891                     filePropertyMap["audiocodec"] = producer->get(property);
 892             }
 893         }
 894
 895         // metadata
 896         Mlt::Properties metadata;
 897         metadata.pass_values(*producer, "meta.attr.");
 898         int count = metadata.count();
 899         for (int i = 0; i < count; i ++) {
 900             QString name = metadata.get_name(i);
 901             QString value = QString::fromUtf8(metadata.get(i));
 902             if (name.endsWith("markup") && !value.isEmpty())
 903                 metadataPropertyMap[ name.section('.', 0, -2)] = value;
 904         }
 905         producer->seek(0);
 906         emit replyGetFileProperties(info.clipId, producer, filePropertyMap, metadataPropertyMap, info.replaceProducer);
 907     }
 908 }
 909
 910
 911 #if 0
 912 /** Create the producer from the MLT XML QDomDocument */
 913 void Render::initSceneList()
 914 {
 915     kDebug() << "--------  INIT SCENE LIST ------_";
 916     QDomDocument doc;
 917     QDomElement mlt = doc.createElement("mlt");
 918     doc.appendChild(mlt);
 919     QDomElement prod = doc.createElement("producer");
 920     prod.setAttribute("resource", "colour");
 921     prod.setAttribute("colour", "red");
 922     prod.setAttribute("id", "black");
 923     prod.setAttribute("in", "0");
 924     prod.setAttribute("out", "0");
 925
 926     QDomElement tractor = doc.createElement("tractor");
 927     QDomElement multitrack = doc.createElement("multitrack");
 928
 929     QDomElement playlist1 = doc.createElement("playlist");
 930     playlist1.appendChild(prod);
 931     multitrack.appendChild(playlist1);
 932     QDomElement playlist2 = doc.createElement("playlist");
 933     multitrack.appendChild(playlist2);
 934     QDomElement playlist3 = doc.createElement("playlist");
 935     multitrack.appendChild(playlist3);
 936     QDomElement playlist4 = doc.createElement("playlist");
 937     multitrack.appendChild(playlist4);
 938     QDomElement playlist5 = doc.createElement("playlist");
 939     multitrack.appendChild(playlist5);
 940     tractor.appendChild(multitrack);
 941     mlt.appendChild(tractor);
 942     // kDebug()<<doc.toString();
 943     /*
 944        QString tmp = QString("<mlt><producer resource=\"colour\" colour=\"red\" id=\"red\" /><tractor><multitrack><playlist></playlist><playlist></playlist><playlist /><playlist /><playlist></playlist></multitrack></tractor></mlt>");*/
 945     setSceneList(doc, 0);
 946 }
 947 #endif
 948
 949 int Render::setProducer(Mlt::Producer *producer, int position)
 950 {
 951     kDebug()<<"//////////\n SET CLIP PRODUCER  \n//////////";
 952     QMutexLocker locker(&m_mutex);
 953     if (m_winid == -1) return -1;
 954     if (m_mltConsumer) {
 955         if (!m_mltConsumer->is_stopped()) {
 956             m_mltConsumer->stop();
 957             m_mltConsumer->purge();
 958         }
 959         m_mltConsumer->set("refresh", 0);
 960     }
 961     else {
 962         return -1;
 963     }
 964
 965     if (m_mltProducer) {
 966         m_mltProducer->set_speed(0);
 967         delete m_mltProducer;
 968         m_mltProducer = NULL;
 969         emit stopped();
 970     }
 971     blockSignals(true);
 972     if (producer && producer->is_valid()) {
 973         m_mltProducer = new Mlt::Producer(producer->get_producer());
 974     } else m_mltProducer = m_blackClip->cut(0, 1);
 975
 976     if (!m_mltProducer || !m_mltProducer->is_valid()) {
 977         kDebug() << " WARNING - - - - -INVALID PLAYLIST: ";
 978         return -1;
 979     }
 980     int volume = KdenliveSettings::volume();
 981     m_mltProducer->set("meta.volume", (double)volume / 100);
 982     m_fps = m_mltProducer->get_fps();
 983     blockSignals(false);
 984     int error = connectPlaylist();
 985     if (producer == NULL) {
 986         return error;
 987     }
 988
 989     if (position != -1) {
 990         m_mltProducer->seek(position);
 991         emit rendererPosition(position);
 992     } else emit rendererPosition((int) m_mltProducer->position());
 993     return error;
 994 }
 995
 996 int Render::setSceneList(QDomDocument list, int position)
 997 {
 998     return setSceneList(list.toString(), position);
 999 }
1000
1001 int Render::setSceneList(QString playlist, int position)
1002 {
1003     if (m_winid == -1) return -1;
1004     int error = 0;
1005
1006     //kDebug() << "//////  RENDER, SET SCENE LIST:\n" << playlist <<"\n..........:::.";
1007
1008     // Remove previous profile info
1009     QDomDocument doc;
1010     doc.setContent(playlist);
1011     QDomElement profile = doc.documentElement().firstChildElement("profile");
1012     doc.documentElement().removeChild(profile);
1013     playlist = doc.toString();
1014
1015     if (m_mltConsumer) {
1016         if (!m_mltConsumer->is_stopped()) {
1017             m_mltConsumer->stop();
1018         }
1019         m_mltConsumer->set("refresh", 0);
1020     } else {
1021         kWarning() << "///////  ERROR, TRYING TO USE NULL MLT CONSUMER";
1022         error = -1;
1023     }
1024     m_requestList.clear();
1025     m_infoThread.waitForFinished();
1026
1027     if (m_mltProducer) {
1028         m_mltProducer->set_speed(0);
1029         //if (KdenliveSettings::osdtimecode() && m_osdInfo) m_mltProducer->detach(*m_osdInfo);
1030
1031         /*Mlt::Service service(m_mltProducer->parent().get_service());
1032         service.lock();
1033
1034         if (service.type() == tractor_type) {
1035             Mlt::Tractor tractor(service);
1036             Mlt::Field *field = tractor.field();
1037             mlt_service nextservice = mlt_service_get_producer(service.get_service());
1038             mlt_service nextservicetodisconnect;
1039             mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
1040             QString mlt_type = mlt_properties_get(properties, "mlt_type");
1041             QString resource = mlt_properties_get(properties, "mlt_service");
1042             // Delete all transitions
1043             while (mlt_type == "transition") {
1044                 nextservicetodisconnect = nextservice;
1045                 nextservice = mlt_service_producer(nextservice);
1046                 mlt_field_disconnect_service(field->get_field(), nextservicetodisconnect);
1047                 if (nextservice == NULL) break;
1048                 properties = MLT_SERVICE_PROPERTIES(nextservice);
1049                 mlt_type = mlt_properties_get(properties, "mlt_type");
1050                 resource = mlt_properties_get(properties, "mlt_service");
1051             }
1052
1053
1054             for (int trackNb = tractor.count() - 1; trackNb >= 0; --trackNb) {
1055                 Mlt::Producer trackProducer(tractor.track(trackNb));
1056                 Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
1057                 if (trackPlaylist.type() == playlist_type) trackPlaylist.clear();
1058             }
1059             delete field;
1060         }
1061         service.unlock();*/
1062
1063         qDeleteAll(m_slowmotionProducers.values());
1064         m_slowmotionProducers.clear();
1065
1066         delete m_mltProducer;
1067         m_mltProducer = NULL;
1068         emit stopped();
1069     }
1070
1071     blockSignals(true);
1072     m_locale = QLocale();
1073
1074     m_mltProducer = new Mlt::Producer(*m_mltProfile, "xml-string", playlist.toUtf8().constData());
1075     if (!m_mltProducer || !m_mltProducer->is_valid()) {
1076         kDebug() << " WARNING - - - - -INVALID PLAYLIST: " << playlist.toUtf8().constData();
1077         m_mltProducer = m_blackClip->cut(0, 1);
1078         error = -1;
1079     }
1080     checkMaxThreads();
1081     int volume = KdenliveSettings::volume();
1082     m_mltProducer->set("meta.volume", (double)volume / 100);
1083     m_mltProducer->optimise();
1084
1085     /*if (KdenliveSettings::osdtimecode()) {
1086     // Attach filter for on screen display of timecode
1087     delete m_osdInfo;
1088     QString attr = "attr_check";
1089     mlt_filter filter = mlt_factory_filter( "data_feed", (char*) attr.ascii() );
1090     mlt_properties_set_int( MLT_FILTER_PROPERTIES( filter ), "_loader", 1 );
1091     mlt_producer_attach( m_mltProducer->get_producer(), filter );
1092     mlt_filter_close( filter );
1093
1094       m_osdInfo = new Mlt::Filter("data_show");
1095     m_osdInfo->set("resource", m_osdProfile.toUtf8().constData());
1096     mlt_properties properties = MLT_PRODUCER_PROPERTIES(m_mltProducer->get_producer());
1097     mlt_properties_set_int( properties, "meta.attr.timecode", 1);
1098     mlt_properties_set( properties, "meta.attr.timecode.markup", "#timecode#");
1099     m_osdInfo->set("dynamic", "1");
1100
1101       if (m_mltProducer->attach(*m_osdInfo) == 1) kDebug()<<"////// error attaching filter";
1102     } else {
1103     m_osdInfo->set("dynamic", "0");
1104     }*/
1105
1106     m_fps = m_mltProducer->get_fps();
1107     if (position != 0) {
1108         // Seek to correct place after opening project.
1109         m_mltProducer->seek(position);
1110     }
1111
1112     kDebug() << "// NEW SCENE LIST DURATION SET TO: " << m_mltProducer->get_playtime();
1113     if (error == 0) error = connectPlaylist();
1114     else connectPlaylist();
1115     fillSlowMotionProducers();
1116     blockSignals(false);
1117
1118     return error;
1119     //kDebug()<<"// SETSCN LST, POS: "<<position;
1120     //if (position != 0) emit rendererPosition(position);
1121 }
1122
1123 void Render::checkMaxThreads()
1124 {
1125     // Make sure we don't use too much threads, MLT avformat does not cope with too much threads
1126     // Currently, Kdenlive uses the following avformat threads:
1127     // One thread to get info when adding a clip
1128     // One thread to create the timeline video thumbnails
1129     // One thread to create the audio thumbnails
1130     Mlt::Service service(m_mltProducer->parent().get_service());
1131     if (service.type() != tractor_type) {
1132         kWarning() << "// TRACTOR PROBLEM";
1133         return;
1134     }
1135     Mlt::Tractor tractor(service);
1136     int mltMaxThreads = mlt_service_cache_get_size(service.get_service(), "producer_avformat");
1137     int requestedThreads = tractor.count() + 4;
1138     if (requestedThreads > mltMaxThreads) {
1139         mlt_service_cache_set_size(service.get_service(), "producer_avformat", requestedThreads);
1140         kDebug()<<"// MLT threads updated to: "<<mlt_service_cache_get_size(service.get_service(), "producer_avformat");
1141     }
1142 }
1143
1144 const QString Render::sceneList()
1145 {
1146     QString playlist;
1147     Mlt::Profile profile((mlt_profile) 0);
1148     Mlt::Consumer xmlConsumer(profile, "xml:kdenlive_playlist");
1149     m_mltProducer->optimise();
1150     xmlConsumer.set("terminate_on_pause", 1);
1151     Mlt::Producer prod(m_mltProducer->get_producer());
1152     bool split = m_isSplitView;
1153     if (split) slotSplitView(false);
1154     xmlConsumer.connect(prod);
1155     xmlConsumer.start();
1156     while (!xmlConsumer.is_stopped()) {}
1157     playlist = QString::fromUtf8(xmlConsumer.get("kdenlive_playlist"));
1158     if (split) slotSplitView(true);
1159     return playlist;
1160 }
1161
1162 bool Render::saveSceneList(QString path, QDomElement kdenliveData)
1163 {
1164     QFile file(path);
1165     QDomDocument doc;
1166     doc.setContent(sceneList(), false);
1167     if (!kdenliveData.isNull()) {
1168         // add Kdenlive specific tags
1169         QDomNode mlt = doc.elementsByTagName("mlt").at(0);
1170         mlt.appendChild(doc.importNode(kdenliveData, true));
1171     }
1172     if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
1173         kWarning() << "//////  ERROR writing to file: " << path;
1174         return false;
1175     }
1176     file.write(doc.toString().toUtf8());
1177     if (file.error() != QFile::NoError) {
1178         file.close();
1179         return false;
1180     }
1181     file.close();
1182     return true;
1183 }
1184
1185 void Render::saveZone(KUrl url, QString desc, QPoint zone)
1186 {
1187     Mlt::Consumer xmlConsumer(*m_mltProfile, ("xml:" + url.path()).toUtf8().constData());
1188     m_mltProducer->optimise();
1189     xmlConsumer.set("terminate_on_pause", 1);
1190     if (m_name == "clip") {
1191         Mlt::Producer *prod = m_mltProducer->cut(zone.x(), zone.y());
1192         Mlt::Playlist list;
1193         list.insert_at(0, prod, 0);
1194         delete prod;
1195         list.set("title", desc.toUtf8().constData());
1196         xmlConsumer.connect(list);
1197
1198     } else {
1199         //TODO: not working yet, save zone from timeline
1200         Mlt::Producer *p1 = new Mlt::Producer(m_mltProducer->get_producer());
1201         /* Mlt::Service service(p1->parent().get_service());
1202          if (service.type() != tractor_type) kWarning() << "// TRACTOR PROBLEM";*/
1203
1204         //Mlt::Producer *prod = p1->cut(zone.x(), zone.y());
1205         //prod->set("title", desc.toUtf8().constData());
1206         xmlConsumer.connect(*p1); //list);
1207     }
1208
1209     xmlConsumer.start();
1210 }
1211
1212 double Render::fps() const
1213 {
1214     return m_fps;
1215 }
1216
1217 int Render::connectPlaylist()
1218 {
1219     if (!m_mltConsumer) return -1;
1220     //m_mltConsumer->set("refresh", "0");
1221     m_mltConsumer->connect(*m_mltProducer);
1222     m_mltProducer->set_speed(0);
1223     if (m_mltConsumer->start() == -1) {
1224         // ARGH CONSUMER BROKEN!!!!
1225         KMessageBox::error(qApp->activeWindow(), i18n("Could not create the video preview window.\nThere is something wrong with your Kdenlive install or your driver settings, please fix it."));
1226         delete m_mltConsumer;
1227         m_mltConsumer = NULL;
1228         return -1;
1229     }
1230     emit durationChanged(m_mltProducer->get_playtime());
1231     return 0;
1232     //refresh();
1233 }
1234
1235 void Render::refreshDisplay()
1236 {
1237
1238     if (!m_mltProducer) return;
1239     //m_mltConsumer->set("refresh", 0);
1240
1241     //mlt_properties properties = MLT_PRODUCER_PROPERTIES(m_mltProducer->get_producer());
1242     /*if (KdenliveSettings::osdtimecode()) {
1243         mlt_properties_set_int( properties, "meta.attr.timecode", 1);
1244         mlt_properties_set( properties, "meta.attr.timecode.markup", "#timecode#");
1245         m_osdInfo->set("dynamic", "1");
1246         m_mltProducer->attach(*m_osdInfo);
1247     }
1248     else {
1249         m_mltProducer->detach(*m_osdInfo);
1250         m_osdInfo->set("dynamic", "0");
1251     }*/
1252     refresh();
1253 }
1254
1255 int Render::volume() const
1256 {
1257     if (!m_mltConsumer || !m_mltProducer) return -1;
1258     return ((int) 100 * m_mltProducer->get_double("meta.volume"));
1259 }
1260
1261 void Render::slotSetVolume(int volume)
1262 {
1263     if (!m_mltConsumer || !m_mltProducer) return;
1264     m_mltProducer->set("meta.volume", (double)volume / 100.0);
1265     return;
1266     /*osdTimer->stop();
1267     m_mltConsumer->set("refresh", 0);
1268     // Attach filter for on screen display of timecode
1269     mlt_properties properties = MLT_PRODUCER_PROPERTIES(m_mltProducer->get_producer());
1270     mlt_properties_set_double( properties, "meta.volume", volume );
1271     mlt_properties_set_int( properties, "meta.attr.osdvolume", 1);
1272     mlt_properties_set( properties, "meta.attr.osdvolume.markup", i18n("Volume: ") + QString::number(volume * 100));
1273
1274     if (!KdenliveSettings::osdtimecode()) {
1275     m_mltProducer->detach(*m_osdInfo);
1276     mlt_properties_set_int( properties, "meta.attr.timecode", 0);
1277      if (m_mltProducer->attach(*m_osdInfo) == 1) kDebug()<<"////// error attaching filter";
1278     }*/
1279     refresh();
1280     //m_osdTimer->setSingleShot(2500);
1281 }
1282
1283 void Render::slotOsdTimeout()
1284 {
1285     mlt_properties properties = MLT_PRODUCER_PROPERTIES(m_mltProducer->get_producer());
1286     mlt_properties_set_int(properties, "meta.attr.osdvolume", 0);
1287     mlt_properties_set(properties, "meta.attr.osdvolume.markup", NULL);
1288     //if (!KdenliveSettings::osdtimecode()) m_mltProducer->detach(*m_osdInfo);
1289     refresh();
1290 }
1291
1292 void Render::start()
1293 {
1294     if (m_winid == -1) {
1295         kDebug() << "-----  BROKEN MONITOR: " << m_name << ", RESTART";
1296         return;
1297     }
1298     if (m_mltConsumer && m_mltConsumer->is_stopped()) {
1299         if (m_mltConsumer->start() == -1) {
1300             //KMessageBox::error(qApp->activeWindow(), i18n("Could not create the video preview window.\nThere is something wrong with your Kdenlive install or your driver settings, please fix it."));
1301             kDebug(QtWarningMsg) << "/ / / / CANNOT START MONITOR";
1302         } else {
1303             refresh();
1304         }
1305     }
1306 }
1307
1308 void Render::stop()
1309 {
1310     if (m_mltProducer == NULL) return;
1311     if (m_mltConsumer && !m_mltConsumer->is_stopped()) {
1312         //kDebug() << "/////////////   RENDER STOPPED: " << m_name;
1313         //m_mltConsumer->set("refresh", 0);
1314         m_mltConsumer->stop();
1315         // delete m_mltConsumer;
1316         // m_mltConsumer = NULL;
1317     }
1318
1319     if (m_mltProducer) {
1320         if (m_isZoneMode) resetZoneMode();
1321         m_mltProducer->set_speed(0.0);
1322         //m_mltProducer->set("out", m_mltProducer->get_length() - 1);
1323         //kDebug() << m_mltProducer->get_length();
1324     }
1325 }
1326
1327 void Render::stop(const GenTime & startTime)
1328 {
1329     if (m_mltProducer) {
1330         if (m_isZoneMode) resetZoneMode();
1331         m_mltProducer->set_speed(0.0);
1332         m_mltProducer->seek((int) startTime.frames(m_fps));
1333     }
1334     m_mltConsumer->purge();
1335 }
1336
1337 void Render::pause()
1338 {
1339     if (!m_mltProducer || !m_mltConsumer)
1340         return;
1341     if (m_mltProducer->get_speed() == 0.0) return;
1342     if (m_isZoneMode) resetZoneMode();
1343     m_mltConsumer->set("refresh", 0);
1344     m_mltProducer->set_speed(0.0);
1345     /*
1346     The 2 lines below create a flicker loop
1347     emit rendererPosition(m_framePosition);
1348     m_mltProducer->seek(m_framePosition);*/
1349     m_mltConsumer->purge();
1350 }
1351
1352 void Render::switchPlay(bool play)
1353 {
1354     if (!m_mltProducer || !m_mltConsumer)
1355         return;
1356     if (m_isZoneMode) resetZoneMode();
1357     if (play && m_mltProducer->get_speed() == 0.0) {
1358         if (m_name == "clip" && m_framePosition == (int) m_mltProducer->get_out()) m_mltProducer->seek(0);
1359         m_mltProducer->set_speed(1.0);
1360         m_mltConsumer->set("refresh", 1);
1361         if (m_mltConsumer->is_stopped()) m_mltConsumer->start();
1362     } else if (!play) {
1363         stop();
1364         m_mltConsumer->set("refresh", "0");
1365         m_framePosition++;
1366         m_mltProducer->seek(m_framePosition);
1367         /*m_mltConsumer->set("refresh", 0);
1368         m_mltConsumer->stop();
1369         m_mltConsumer->purge();
1370         m_mltProducer->set_speed(0.0);
1371         //m_framePosition = m_mltProducer->position();
1372         m_mltProducer->seek(m_framePosition);
1373         emit rendererPosition(m_framePosition);*/
1374     }
1375 }
1376
1377 void Render::play(double speed)
1378 {
1379     if (!m_mltProducer)
1380         return;
1381     // if (speed == 0.0) m_mltProducer->set("out", m_mltProducer->get_length() - 1);
1382     m_mltProducer->set_speed(speed);
1383     /*if (speed == 0.0) {
1384     m_mltProducer->seek((int) m_framePosition + 1);
1385         m_mltConsumer->purge();
1386     }*/
1387     refresh();
1388 }
1389
1390 void Render::play(const GenTime & startTime)
1391 {
1392     if (!m_mltProducer || !m_mltConsumer)
1393         return;
1394     m_mltProducer->seek((int)(startTime.frames(m_fps)));
1395     m_mltProducer->set_speed(1.0);
1396     m_mltConsumer->set("refresh", 1);
1397 }
1398
1399 void Render::loopZone(const GenTime & startTime, const GenTime & stopTime)
1400 {
1401     if (!m_mltProducer || !m_mltConsumer)
1402         return;
1403     //m_mltProducer->set("eof", "loop");
1404     m_isLoopMode = true;
1405     m_loopStart = startTime;
1406     playZone(startTime, stopTime);
1407 }
1408
1409 void Render::playZone(const GenTime & startTime, const GenTime & stopTime)
1410 {
1411     if (!m_mltProducer || !m_mltConsumer)
1412         return;
1413     if (!m_isZoneMode) m_originalOut = m_mltProducer->get_playtime() - 1;
1414     m_mltProducer->set("out", (int)(stopTime.frames(m_fps)));
1415     m_mltProducer->seek((int)(startTime.frames(m_fps)));
1416     m_mltProducer->set_speed(1.0);
1417     m_mltConsumer->set("refresh", 1);
1418     m_isZoneMode = true;
1419 }
1420
1421 void Render::resetZoneMode()
1422 {
1423     if (!m_isZoneMode && !m_isLoopMode) return;
1424     m_mltProducer->set("out", m_originalOut);
1425     //m_mltProducer->set("eof", "pause");
1426     m_isZoneMode = false;
1427     m_isLoopMode = false;
1428 }
1429
1430 void Render::seekToFrame(int pos)
1431 {
1432     if (!m_mltProducer)
1433         return;
1434     resetZoneMode();
1435     m_mltProducer->seek(pos);
1436     refresh();
1437 }
1438
1439 void Render::seekToFrameDiff(int diff)
1440 {
1441     if (!m_mltProducer)
1442         return;
1443     resetZoneMode();
1444     m_mltProducer->seek(m_mltProducer->position() + diff);
1445     refresh();
1446 }
1447
1448 void Render::doRefresh()
1449 {
1450     // Use a Timer so that we don't refresh too much
1451     if (m_mltConsumer) {
1452         if (m_mltConsumer->is_stopped()) m_mltConsumer->start();
1453         m_mltConsumer->set("refresh", 1);
1454     }
1455 }
1456
1457 void Render::refresh()
1458 {
1459     if (!m_mltProducer)
1460         return;
1461     if (m_mltConsumer) {
1462         m_mltConsumer->set("refresh", 1);
1463         if (m_mltConsumer->is_stopped()) m_mltConsumer->start();
1464     }
1465 }
1466
1467 void Render::setDropFrames(bool show)
1468 {
1469     if (m_mltConsumer) {
1470         int dropFrames = KdenliveSettings::mltthreads();
1471         if (show == false) dropFrames = -dropFrames;
1472         m_mltConsumer->stop();
1473         if (m_winid == 0)
1474             m_mltConsumer->set("real_time", dropFrames);
1475         else
1476             m_mltConsumer->set("play.real_time", dropFrames);
1477
1478         if (m_mltConsumer->start() == -1) {
1479             kDebug(QtWarningMsg) << "ERROR, Cannot start monitor";
1480         }
1481
1482     }
1483 }
1484
1485 double Render::playSpeed()
1486 {
1487     if (m_mltProducer) return m_mltProducer->get_speed();
1488     return 0.0;
1489 }
1490
1491 GenTime Render::seekPosition() const
1492 {
1493     if (m_mltProducer) return GenTime((int) m_mltProducer->position(), m_fps);
1494     else return GenTime();
1495 }
1496
1497 int Render::seekFramePosition() const
1498 {
1499     if (m_mltProducer) return (int) m_mltProducer->position();
1500     return 0;
1501 }
1502
1503 const QString & Render::rendererName() const
1504 {
1505     return m_name;
1506 }
1507
1508 void Render::emitFrameUpdated(Mlt::Frame& frame)
1509 {
1510     mlt_image_format format = mlt_image_rgb24;
1511     int width = 0;
1512     int height = 0;
1513     const uchar* image = frame.get_image(format, width, height);
1514     QImage qimage(width, height, QImage::Format_RGB888);
1515     memcpy(qimage.bits(), image, width * height * 3);
1516     emit frameUpdated(qimage);
1517 }
1518
1519 void Render::emitFrameNumber(double position)
1520 {
1521     kDebug()<<"+++++++++++++++++++++++++++++++++++++++\n   "<<m_name<<" GOT POSITION: "<<position<<"\n++++++++++++++++++++++++++";
1522     m_framePosition = position;
1523     emit rendererPosition((int) position);
1524 }
1525
1526 void Render::emitConsumerStopped()
1527 {
1528     // This is used to know when the playing stopped
1529     if (m_mltProducer) {
1530         double pos = m_mltProducer->position();
1531         if (m_isLoopMode) play(m_loopStart);
1532         else if (m_isZoneMode) resetZoneMode();
1533         emit rendererStopped((int) pos);
1534     }
1535 }
1536
1537 void Render::exportFileToFirewire(QString /*srcFileName*/, int /*port*/, GenTime /*startTime*/, GenTime /*endTime*/)
1538 {
1539     KMessageBox::sorry(0, i18n("Firewire is not enabled on your system.\n Please install Libiec61883 and recompile Kdenlive"));
1540 }
1541
1542 void Render::exportCurrentFrame(KUrl url, bool /*notify*/)
1543 {
1544     if (!m_mltProducer) {
1545         KMessageBox::sorry(qApp->activeWindow(), i18n("There is no clip, cannot extract frame."));
1546         return;
1547     }
1548
1549     //int height = 1080;//KdenliveSettings::defaultheight();
1550     //int width = 1940; //KdenliveSettings::displaywidth();
1551     //TODO: rewrite
1552     QPixmap pix; // = KThumb::getFrame(m_mltProducer, -1, width, height);
1553     /*
1554        QPixmap pix(width, height);
1555        Mlt::Filter m_convert(*m_mltProfile, "avcolour_space");
1556        m_convert.set("forced", mlt_image_rgb24a);
1557        m_mltProducer->attach(m_convert);
1558        Mlt::Frame * frame = m_mltProducer->get_frame();
1559        m_mltProducer->detach(m_convert);
1560        if (frame) {
1561            pix = frameThumbnail(frame, width, height);
1562            delete frame;
1563        }*/
1564     pix.save(url.path(), "PNG");
1565     //if (notify) QApplication::postEvent(qApp->activeWindow(), new UrlEvent(url, 10003));
1566 }
1567
1568
1569 void Render::showFrame(Mlt::Frame& frame)
1570 {
1571     m_framePosition = qMax(frame.get_int("_position"), 0);
1572     emit rendererPosition((int) m_framePosition);
1573     mlt_image_format format = mlt_image_rgb24a;
1574     int width = 0;
1575     int height = 0;
1576     const uchar* image = frame.get_image(format, width, height);
1577     QImage qimage(width, height, QImage::Format_ARGB32_Premultiplied);
1578     memcpy(qimage.scanLine(0), image, width * height * 4);
1579     emit showImageSignal(qimage);
1580     if (analyseAudio) showAudio(frame);
1581     if (sendFrameForAnalysis && frame.get_frame()->convert_image) {
1582         emit frameUpdated(qimage.rgbSwapped());
1583     }
1584 }
1585
1586 void Render::showAudio(Mlt::Frame& frame)
1587 {
1588     if (!frame.is_valid() || frame.get_int("test_audio") != 0) {
1589         return;
1590     }
1591     mlt_audio_format audio_format = mlt_audio_s16;
1592     int freq = 0;
1593     int num_channels = 0;
1594     int samples = 0;
1595     int16_t* data = (int16_t*)frame.get_audio(audio_format, freq, num_channels, samples);
1596
1597     if (!data) {
1598         return;
1599     }
1600
1601     // Data format: [ c00 c10 c01 c11 c02 c12 c03 c13 ... c0{samples-1} c1{samples-1} for 2 channels.
1602     // So the vector is of size samples*channels.
1603     QVector<int16_t> sampleVector(samples*num_channels);
1604     memcpy(sampleVector.data(), data, samples*num_channels*sizeof(int16_t));
1605
1606     if (samples > 0) {
1607         emit audioSamplesSignal(sampleVector, freq, num_channels, samples);
1608     }
1609 }
1610
1611 /*
1612  * MLT playlist direct manipulation.
1613  */
1614
1615 void Render::mltCheckLength(Mlt::Tractor *tractor)
1616 {
1617     //kDebug()<<"checking track length: "<<track<<"..........";
1618
1619     int trackNb = tractor->count();
1620     int duration = 0;
1621     int trackDuration;
1622     if (trackNb == 1) {
1623         Mlt::Producer trackProducer(tractor->track(0));
1624         duration = trackProducer.get_playtime() - 1;
1625         m_mltProducer->set("out", duration);
1626         emit durationChanged(duration);
1627         return;
1628     }
1629     while (trackNb > 1) {
1630         Mlt::Producer trackProducer(tractor->track(trackNb - 1));
1631         trackDuration = trackProducer.get_playtime() - 1;
1632         // kDebug() << " / / /DURATON FOR TRACK " << trackNb - 1 << " = " << trackDuration;
1633         if (trackDuration > duration) duration = trackDuration;
1634         trackNb--;
1635     }
1636
1637     Mlt::Producer blackTrackProducer(tractor->track(0));
1638
1639     if (blackTrackProducer.get_playtime() - 1 != duration) {
1640         Mlt::Playlist blackTrackPlaylist((mlt_playlist) blackTrackProducer.get_service());
1641         Mlt::Producer *blackclip = blackTrackPlaylist.get_clip(0);
1642         if (blackclip && blackclip->is_blank()) {
1643             delete blackclip;
1644             blackclip = NULL;
1645         }
1646
1647         if (blackclip == NULL || blackTrackPlaylist.count() != 1) {
1648             blackTrackPlaylist.clear();
1649             m_blackClip->set("length", duration + 1);
1650             m_blackClip->set("out", duration);
1651             blackclip = m_blackClip->cut(0, duration);
1652             blackTrackPlaylist.insert_at(0, blackclip, 1);
1653         } else {
1654             if (duration > blackclip->parent().get_length()) {
1655                 blackclip->parent().set("length", duration + 1);
1656                 blackclip->parent().set("out", duration);
1657                 blackclip->set("length", duration + 1);
1658             }
1659             blackTrackPlaylist.resize_clip(0, 0, duration);
1660         }
1661
1662         delete blackclip;
1663         m_mltProducer->set("out", duration);
1664         emit durationChanged(duration);
1665     }
1666 }
1667
1668 Mlt::Producer *Render::checkSlowMotionProducer(Mlt::Producer *prod, QDomElement element)
1669 {
1670     if (element.attribute("speed", "1.0").toDouble() == 1.0 && element.attribute("strobe", "1").toInt() == 1) return prod;
1671     QLocale locale;
1672     // We want a slowmotion producer
1673     double speed = element.attribute("speed", "1.0").toDouble();
1674     int strobe = element.attribute("strobe", "1").toInt();
1675     QString url = QString::fromUtf8(prod->get("resource"));
1676     url.append('?' + locale.toString(speed));
1677     if (strobe > 1) url.append("&strobe=" + QString::number(strobe));
1678     Mlt::Producer *slowprod = m_slowmotionProducers.value(url);
1679     if (!slowprod || slowprod->get_producer() == NULL) {
1680         slowprod = new Mlt::Producer(*m_mltProfile, 0, ("framebuffer:" + url).toUtf8().constData());
1681         if (strobe > 1) slowprod->set("strobe", strobe);
1682         QString id = prod->parent().get("id");
1683         if (id.contains('_')) id = id.section('_', 0, 0);
1684         QString producerid = "slowmotion:" + id + ':' + locale.toString(speed);
1685         if (strobe > 1) producerid.append(':' + QString::number(strobe));
1686         slowprod->set("id", producerid.toUtf8().constData());
1687         m_slowmotionProducers.insert(url, slowprod);
1688     }
1689     return slowprod;
1690 }
1691
1692 int Render::mltInsertClip(ItemInfo info, QDomElement element, Mlt::Producer *prod, bool overwrite, bool push)
1693 {
1694     if (m_mltProducer == NULL) {
1695         kDebug() << "PLAYLIST NOT INITIALISED //////";
1696         return -1;
1697     }
1698     if (prod == NULL) {
1699         kDebug() << "Cannot insert clip without producer //////";
1700         return -1;
1701     }
1702     Mlt::Producer parentProd(m_mltProducer->parent());
1703     if (parentProd.get_producer() == NULL) {
1704         kDebug() << "PLAYLIST BROKEN, CANNOT INSERT CLIP //////";
1705         return -1;
1706     }
1707
1708     Mlt::Service service(parentProd.get_service());
1709     if (service.type() != tractor_type) {
1710         kWarning() << "// TRACTOR PROBLEM";
1711         return -1;
1712     }
1713     Mlt::Tractor tractor(service);
1714     if (info.track > tractor.count() - 1) {
1715         kDebug() << "ERROR TRYING TO INSERT CLIP ON TRACK " << info.track << ", at POS: " << info.startPos.frames(25);
1716         return -1;
1717     }
1718     service.lock();
1719     Mlt::Producer trackProducer(tractor.track(info.track));
1720     int trackDuration = trackProducer.get_playtime() - 1;
1721     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
1722     //kDebug()<<"/// INSERT cLIP: "<<info.cropStart.frames(m_fps)<<", "<<info.startPos.frames(m_fps)<<"-"<<info.endPos.frames(m_fps);
1723     prod = checkSlowMotionProducer(prod, element);
1724     if (prod == NULL || !prod->is_valid()) {
1725         service.unlock();
1726         return -1;
1727     }
1728
1729     int cutPos = (int) info.cropStart.frames(m_fps);
1730     if (cutPos < 0) cutPos = 0;
1731     int insertPos = (int) info.startPos.frames(m_fps);
1732     int cutDuration = (int)(info.endPos - info.startPos).frames(m_fps) - 1;
1733     Mlt::Producer *clip = prod->cut(cutPos, cutDuration + cutPos);
1734     if (overwrite && (insertPos < trackDuration)) {
1735         // Replace zone with blanks
1736         //trackPlaylist.split_at(insertPos, true);
1737         trackPlaylist.remove_region(insertPos, cutDuration + 1);
1738         int clipIndex = trackPlaylist.get_clip_index_at(insertPos);
1739         trackPlaylist.insert_blank(clipIndex, cutDuration);
1740     } else if (push) {
1741         trackPlaylist.split_at(insertPos, true);
1742         int clipIndex = trackPlaylist.get_clip_index_at(insertPos);
1743         trackPlaylist.insert_blank(clipIndex, cutDuration);
1744     }
1745     int newIndex = trackPlaylist.insert_at(insertPos, clip, 1);
1746     delete clip;
1747     /*if (QString(prod->get("transparency")).toInt() == 1)
1748         mltAddClipTransparency(info, info.track - 1, QString(prod->get("id")).toInt());*/
1749
1750     if (info.track != 0 && (newIndex + 1 == trackPlaylist.count())) mltCheckLength(&tractor);
1751     service.unlock();
1752     /*tractor.multitrack()->refresh();
1753     tractor.refresh();*/
1754     return 0;
1755 }
1756
1757
1758 void Render::mltCutClip(int track, GenTime position)
1759 {
1760     Mlt::Service service(m_mltProducer->parent().get_service());
1761     if (service.type() != tractor_type) {
1762         kWarning() << "// TRACTOR PROBLEM";
1763         return;
1764     }
1765
1766     Mlt::Tractor tractor(service);
1767     Mlt::Producer trackProducer(tractor.track(track));
1768     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
1769
1770
1771     /* // Display playlist info
1772     kDebug()<<"////////////  BEFORE";
1773     for (int i = 0; i < trackPlaylist.count(); i++) {
1774     int blankStart = trackPlaylist.clip_start(i);
1775     int blankDuration = trackPlaylist.clip_length(i) - 1;
1776     QString blk;
1777     if (trackPlaylist.is_blank(i)) blk = "(blank)";
1778     kDebug()<<"CLIP "<<i<<": ("<<blankStart<<'x'<<blankStart + blankDuration<<")"<<blk;
1779     }*/
1780
1781     int cutPos = (int) position.frames(m_fps);
1782
1783     int clipIndex = trackPlaylist.get_clip_index_at(cutPos);
1784     if (trackPlaylist.is_blank(clipIndex)) {
1785         kDebug() << "// WARNING, TRYING TO CUT A BLANK";
1786         return;
1787     }
1788     service.lock();
1789     int clipStart = trackPlaylist.clip_start(clipIndex);
1790     trackPlaylist.split(clipIndex, cutPos - clipStart - 1);
1791     service.unlock();
1792
1793     // duplicate effects
1794     Mlt::Producer *original = trackPlaylist.get_clip_at(clipStart);
1795     Mlt::Producer *clip = trackPlaylist.get_clip_at(cutPos);
1796
1797     if (original == NULL || clip == NULL) {
1798         kDebug() << "// ERROR GRABBING CLIP AFTER SPLIT";
1799     }
1800     Mlt::Service clipService(original->get_service());
1801     Mlt::Service dupService(clip->get_service());
1802     delete original;
1803     delete clip;
1804     int ct = 0;
1805     Mlt::Filter *filter = clipService.filter(ct);
1806     while (filter) {
1807         // Only duplicate Kdenlive filters, and skip the fade in effects
1808         if (filter->is_valid() && strcmp(filter->get("kdenlive_id"), "") && strcmp(filter->get("kdenlive_id"), "fadein") && strcmp(filter->get("kdenlive_id"), "fade_from_black")) {
1809             // looks like there is no easy way to duplicate a filter,
1810             // so we will create a new one and duplicate its properties
1811             Mlt::Filter *dup = new Mlt::Filter(*m_mltProfile, filter->get("mlt_service"));
1812             if (dup && dup->is_valid()) {
1813                 Mlt::Properties entries(filter->get_properties());
1814                 for (int i = 0; i < entries.count(); i++) {
1815                     dup->set(entries.get_name(i), entries.get(i));
1816                 }
1817                 dupService.attach(*dup);
1818             }
1819         }
1820         ct++;
1821         filter = clipService.filter(ct);
1822     }
1823
1824     /* // Display playlist info
1825     kDebug()<<"////////////  AFTER";
1826     for (int i = 0; i < trackPlaylist.count(); i++) {
1827     int blankStart = trackPlaylist.clip_start(i);
1828     int blankDuration = trackPlaylist.clip_length(i) - 1;
1829     QString blk;
1830     if (trackPlaylist.is_blank(i)) blk = "(blank)";
1831     kDebug()<<"CLIP "<<i<<": ("<<blankStart<<'x'<<blankStart + blankDuration<<")"<<blk;
1832     }*/
1833
1834 }
1835
1836 void Render::lock()
1837 {
1838     if (!m_mltProducer) return;
1839     Mlt::Service service(m_mltProducer->parent().get_service());
1840     if (service.type() != tractor_type) {
1841         kWarning() << "// TRACTOR PROBLEM";
1842         return;
1843     }
1844     service.lock();
1845 }
1846
1847 void Render::unlock()
1848 {
1849     if (!m_mltProducer) return;
1850     Mlt::Service service(m_mltProducer->parent().get_service());
1851     if (service.type() != tractor_type) {
1852         kWarning() << "// TRACTOR PROBLEM";
1853         return;
1854     }
1855     service.unlock();
1856 }
1857
1858 bool Render::mltUpdateClip(ItemInfo info, QDomElement element, Mlt::Producer *prod)
1859 {
1860     // TODO: optimize
1861     if (prod == NULL) {
1862         kDebug() << "Cannot update clip with null producer //////";
1863         return false;
1864     }
1865
1866     Mlt::Service service(m_mltProducer->parent().get_service());
1867     if (service.type() != tractor_type) {
1868         kWarning() << "// TRACTOR PROBLEM";
1869         return false;
1870     }
1871     Mlt::Tractor tractor(service);
1872     Mlt::Producer trackProducer(tractor.track(tractor.count() - 1 - info.track));
1873     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
1874     int startPos = info.startPos.frames(m_fps);
1875     int clipIndex = trackPlaylist.get_clip_index_at(startPos);
1876     if (trackPlaylist.is_blank(clipIndex)) {
1877         kDebug() << "// WARNING, TRYING TO REMOVE A BLANK: " << startPos;
1878         return false;
1879     }
1880     Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
1881     // keep effects
1882     QList <Mlt::Filter *> filtersList;
1883     Mlt::Service sourceService(clip->get_service());
1884     sourceService.lock();
1885     int ct = 0;
1886     Mlt::Filter *filter = sourceService.filter(ct);
1887     while (filter) {
1888         if (filter->get_int("kdenlive_ix") != 0) {
1889             filtersList.append(filter);
1890         }
1891         ct++;
1892         filter = sourceService.filter(ct);
1893     }
1894
1895     trackPlaylist.replace_with_blank(clipIndex);
1896     delete clip;
1897     prod = checkSlowMotionProducer(prod, element);
1898     if (prod == NULL || !prod->is_valid()) {
1899         return false;
1900     }
1901
1902     Mlt::Producer *clip2 = prod->cut(info.cropStart.frames(m_fps), (info.cropDuration + info.cropStart).frames(m_fps) - 1);
1903     trackPlaylist.insert_at(info.startPos.frames(m_fps), clip2, 1);
1904     Mlt::Service destService(clip2->get_service());
1905     delete clip2;
1906
1907     if (!filtersList.isEmpty()) {
1908         for (int i = 0; i < filtersList.count(); i++)
1909             destService.attach(*(filtersList.at(i)));
1910     }
1911     return true;
1912 }
1913
1914
1915 bool Render::mltRemoveClip(int track, GenTime position)
1916 {
1917     Mlt::Service service(m_mltProducer->parent().get_service());
1918     if (service.type() != tractor_type) {
1919         kWarning() << "// TRACTOR PROBLEM";
1920         return false;
1921     }
1922     //service.lock();
1923     Mlt::Tractor tractor(service);
1924     Mlt::Producer trackProducer(tractor.track(track));
1925     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
1926     int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
1927
1928     if (trackPlaylist.is_blank(clipIndex)) {
1929         kDebug() << "// WARNING, TRYING TO REMOVE A BLANK: " << position.frames(m_fps);
1930         //service.unlock();
1931         return false;
1932     }
1933     Mlt::Producer *clip = trackPlaylist.replace_with_blank(clipIndex);
1934     if (clip) delete clip;
1935     trackPlaylist.consolidate_blanks(0);
1936
1937     /* // Display playlist info
1938     kDebug()<<"////  AFTER";
1939     for (int i = 0; i < trackPlaylist.count(); i++) {
1940     int blankStart = trackPlaylist.clip_start(i);
1941     int blankDuration = trackPlaylist.clip_length(i) - 1;
1942     QString blk;
1943     if (trackPlaylist.is_blank(i)) blk = "(blank)";
1944     kDebug()<<"CLIP "<<i<<": ("<<blankStart<<'x'<<blankStart + blankDuration<<")"<<blk;
1945     }*/
1946     //service.unlock();
1947     if (track != 0 && trackPlaylist.count() <= clipIndex) mltCheckLength(&tractor);
1948     return true;
1949 }
1950
1951 int Render::mltGetSpaceLength(const GenTime &pos, int track, bool fromBlankStart)
1952 {
1953     if (!m_mltProducer) {
1954         kDebug() << "PLAYLIST NOT INITIALISED //////";
1955         return 0;
1956     }
1957     Mlt::Producer parentProd(m_mltProducer->parent());
1958     if (parentProd.get_producer() == NULL) {
1959         kDebug() << "PLAYLIST BROKEN, CANNOT INSERT CLIP //////";
1960         return 0;
1961     }
1962
1963     Mlt::Service service(parentProd.get_service());
1964     Mlt::Tractor tractor(service);
1965     int insertPos = pos.frames(m_fps);
1966
1967     Mlt::Producer trackProducer(tractor.track(track));
1968     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
1969     int clipIndex = trackPlaylist.get_clip_index_at(insertPos);
1970     if (clipIndex == trackPlaylist.count()) {
1971         // We are after the end of the playlist
1972         return -1;
1973     }
1974     if (!trackPlaylist.is_blank(clipIndex)) return 0;
1975     if (fromBlankStart) return trackPlaylist.clip_length(clipIndex);
1976     return trackPlaylist.clip_length(clipIndex) + trackPlaylist.clip_start(clipIndex) - insertPos;
1977 }
1978
1979 int Render::mltTrackDuration(int track)
1980 {
1981     if (!m_mltProducer) {
1982         kDebug() << "PLAYLIST NOT INITIALISED //////";
1983         return -1;
1984     }
1985     Mlt::Producer parentProd(m_mltProducer->parent());
1986     if (parentProd.get_producer() == NULL) {
1987         kDebug() << "PLAYLIST BROKEN, CANNOT INSERT CLIP //////";
1988         return -1;
1989     }
1990
1991     Mlt::Service service(parentProd.get_service());
1992     Mlt::Tractor tractor(service);
1993
1994     Mlt::Producer trackProducer(tractor.track(track));
1995     return trackProducer.get_playtime() - 1;
1996 }
1997
1998 void Render::mltInsertSpace(QMap <int, int> trackClipStartList, QMap <int, int> trackTransitionStartList, int track, const GenTime &duration, const GenTime &timeOffset)
1999 {
2000     if (!m_mltProducer) {
2001         kDebug() << "PLAYLIST NOT INITIALISED //////";
2002         return;
2003     }
2004     Mlt::Producer parentProd(m_mltProducer->parent());
2005     if (parentProd.get_producer() == NULL) {
2006         kDebug() << "PLAYLIST BROKEN, CANNOT INSERT CLIP //////";
2007         return;
2008     }
2009     //kDebug()<<"// CLP STRT LST: "<<trackClipStartList;
2010     //kDebug()<<"// TRA STRT LST: "<<trackTransitionStartList;
2011
2012     Mlt::Service service(parentProd.get_service());
2013     Mlt::Tractor tractor(service);
2014     service.lock();
2015     int diff = duration.frames(m_fps);
2016     int offset = timeOffset.frames(m_fps);
2017     int insertPos;
2018
2019     if (track != -1) {
2020         // insert space in one track only
2021         Mlt::Producer trackProducer(tractor.track(track));
2022         Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2023         insertPos = trackClipStartList.value(track);
2024         if (insertPos != -1) {
2025             insertPos += offset;
2026             int clipIndex = trackPlaylist.get_clip_index_at(insertPos);
2027             if (diff > 0) {
2028                 trackPlaylist.insert_blank(clipIndex, diff - 1);
2029             } else {
2030                 if (!trackPlaylist.is_blank(clipIndex)) clipIndex --;
2031                 if (!trackPlaylist.is_blank(clipIndex)) {
2032                     kDebug() << "//// ERROR TRYING TO DELETE SPACE FROM " << insertPos;
2033                 }
2034                 int position = trackPlaylist.clip_start(clipIndex);
2035                 int blankDuration = trackPlaylist.clip_length(clipIndex);
2036                 if (blankDuration + diff == 0) {
2037                     trackPlaylist.remove(clipIndex);
2038                 } else trackPlaylist.remove_region(position, -diff);
2039             }
2040             trackPlaylist.consolidate_blanks(0);
2041         }
2042         // now move transitions
2043         mlt_service serv = m_mltProducer->parent().get_service();
2044         mlt_service nextservice = mlt_service_get_producer(serv);
2045         mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
2046         QString mlt_type = mlt_properties_get(properties, "mlt_type");
2047         QString resource = mlt_properties_get(properties, "mlt_service");
2048
2049         while (mlt_type == "transition") {
2050             mlt_transition tr = (mlt_transition) nextservice;
2051             int currentTrack = mlt_transition_get_b_track(tr);
2052             int currentIn = (int) mlt_transition_get_in(tr);
2053             int currentOut = (int) mlt_transition_get_out(tr);
2054             insertPos = trackTransitionStartList.value(track);
2055             if (insertPos != -1) {
2056                 insertPos += offset;
2057                 if (track == currentTrack && currentOut > insertPos && resource != "mix") {
2058                     mlt_transition_set_in_and_out(tr, currentIn + diff, currentOut + diff);
2059                 }
2060             }
2061             nextservice = mlt_service_producer(nextservice);
2062             if (nextservice == NULL) break;
2063             properties = MLT_SERVICE_PROPERTIES(nextservice);
2064             mlt_type = mlt_properties_get(properties, "mlt_type");
2065             resource = mlt_properties_get(properties, "mlt_service");
2066         }
2067     } else {
2068         for (int trackNb = tractor.count() - 1; trackNb >= 1; --trackNb) {
2069             Mlt::Producer trackProducer(tractor.track(trackNb));
2070             Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2071
2072             //int clipNb = trackPlaylist.count();
2073             insertPos = trackClipStartList.value(trackNb);
2074             if (insertPos != -1) {
2075                 insertPos += offset;
2076
2077                 /* kDebug()<<"-------------\nTRACK "<<trackNb<<" HAS "<<clipNb<<" CLPIS";
2078                  kDebug() << "INSERT SPACE AT: "<<insertPos<<", DIFF: "<<diff<<", TK: "<<trackNb;
2079                         for (int i = 0; i < clipNb; i++) {
2080                             kDebug()<<"CLIP "<<i<<", START: "<<trackPlaylist.clip_start(i)<<", END: "<<trackPlaylist.clip_start(i) + trackPlaylist.clip_length(i);
2081                      if (trackPlaylist.is_blank(i)) kDebug()<<"++ BLANK ++ ";
2082                      kDebug()<<"-------------";
2083                  }
2084                  kDebug()<<"END-------------";*/
2085
2086
2087                 int clipIndex = trackPlaylist.get_clip_index_at(insertPos);
2088                 if (diff > 0) {
2089                     trackPlaylist.insert_blank(clipIndex, diff - 1);
2090                 } else {
2091                     if (!trackPlaylist.is_blank(clipIndex)) {
2092                         clipIndex --;
2093                     }
2094                     if (!trackPlaylist.is_blank(clipIndex)) {
2095                         kDebug() << "//// ERROR TRYING TO DELETE SPACE FROM " << insertPos;
2096                     }
2097                     int position = trackPlaylist.clip_start(clipIndex);
2098                     int blankDuration = trackPlaylist.clip_length(clipIndex);
2099                     if (diff + blankDuration == 0) {
2100                         trackPlaylist.remove(clipIndex);
2101                     } else trackPlaylist.remove_region(position, - diff);
2102                 }
2103                 trackPlaylist.consolidate_blanks(0);
2104             }
2105         }
2106         // now move transitions
2107         mlt_service serv = m_mltProducer->parent().get_service();
2108         mlt_service nextservice = mlt_service_get_producer(serv);
2109         mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
2110         QString mlt_type = mlt_properties_get(properties, "mlt_type");
2111         QString resource = mlt_properties_get(properties, "mlt_service");
2112
2113         while (mlt_type == "transition") {
2114             mlt_transition tr = (mlt_transition) nextservice;
2115             int currentIn = (int) mlt_transition_get_in(tr);
2116             int currentOut = (int) mlt_transition_get_out(tr);
2117             int currentTrack = mlt_transition_get_b_track(tr);
2118             insertPos = trackTransitionStartList.value(currentTrack);
2119             if (insertPos != -1) {
2120                 insertPos += offset;
2121                 if (currentOut > insertPos && resource != "mix") {
2122                     mlt_transition_set_in_and_out(tr, currentIn + diff, currentOut + diff);
2123                 }
2124             }
2125             nextservice = mlt_service_producer(nextservice);
2126             if (nextservice == NULL) break;
2127             properties = MLT_SERVICE_PROPERTIES(nextservice);
2128             mlt_type = mlt_properties_get(properties, "mlt_type");
2129             resource = mlt_properties_get(properties, "mlt_service");
2130         }
2131     }
2132     service.unlock();
2133     mltCheckLength(&tractor);
2134     m_mltConsumer->set("refresh", 1);
2135 }
2136
2137
2138 void Render::mltPasteEffects(Mlt::Producer *source, Mlt::Producer *dest)
2139 {
2140     if (source == dest) return;
2141     Mlt::Service sourceService(source->get_service());
2142     Mlt::Service destService(dest->get_service());
2143
2144     // move all effects to the correct producer
2145     int ct = 0;
2146     Mlt::Filter *filter = sourceService.filter(ct);
2147     while (filter) {
2148         if (filter->get_int("kdenlive_ix") != 0) {
2149             sourceService.detach(*filter);
2150             destService.attach(*filter);
2151         } else ct++;
2152         filter = sourceService.filter(ct);
2153     }
2154 }
2155
2156 int Render::mltChangeClipSpeed(ItemInfo info, ItemInfo speedIndependantInfo, double speed, double /*oldspeed*/, int strobe, Mlt::Producer *prod)
2157 {
2158     int newLength = 0;
2159     Mlt::Service service(m_mltProducer->parent().get_service());
2160     if (service.type() != tractor_type) {
2161         kWarning() << "// TRACTOR PROBLEM";
2162         return -1;
2163     }
2164
2165     //kDebug() << "Changing clip speed, set in and out: " << info.cropStart.frames(m_fps) << " to " << (info.endPos - info.startPos).frames(m_fps) - 1;
2166     Mlt::Tractor tractor(service);
2167     Mlt::Producer trackProducer(tractor.track(info.track));
2168     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2169     int startPos = info.startPos.frames(m_fps);
2170     int clipIndex = trackPlaylist.get_clip_index_at(startPos);
2171     int clipLength = trackPlaylist.clip_length(clipIndex);
2172
2173     Mlt::Producer *original = trackPlaylist.get_clip(clipIndex);
2174     if (original == NULL) {
2175         return -1;
2176     }
2177     if (!original->is_valid() || original->is_blank()) {
2178         // invalid clip
2179         delete original;
2180         return -1;
2181     }
2182     Mlt::Producer clipparent = original->parent();
2183     if (!clipparent.is_valid() || clipparent.is_blank()) {
2184         // invalid clip
2185         delete original;
2186         return -1;
2187     }
2188
2189     QString serv = clipparent.get("mlt_service");
2190     QString id = clipparent.get("id");
2191     if (speed <= 0 && speed > -1) speed = 1.0;
2192     //kDebug() << "CLIP SERVICE: " << serv;
2193     if ((serv == "avformat" || serv == "avformat-novalidate") && (speed != 1.0 || strobe > 1)) {
2194         service.lock();
2195         QString url = QString::fromUtf8(clipparent.get("resource"));
2196         url.append('?' + m_locale.toString(speed));
2197         if (strobe > 1) url.append("&strobe=" + QString::number(strobe));
2198         Mlt::Producer *slowprod = m_slowmotionProducers.value(url);
2199         if (!slowprod || slowprod->get_producer() == NULL) {
2200             slowprod = new Mlt::Producer(*m_mltProfile, 0, ("framebuffer:" + url).toUtf8().constData());
2201             if (strobe > 1) slowprod->set("strobe", strobe);
2202             QString producerid = "slowmotion:" + id + ':' + m_locale.toString(speed);
2203             if (strobe > 1) producerid.append(':' + QString::number(strobe));
2204             slowprod->set("id", producerid.toUtf8().constData());
2205             // copy producer props
2206             double ar = original->parent().get_double("force_aspect_ratio");
2207             if (ar != 0.0) slowprod->set("force_aspect_ratio", ar);
2208             double fps = original->parent().get_double("force_fps");
2209             if (fps != 0.0) slowprod->set("force_fps", fps);
2210             int threads = original->parent().get_int("threads");
2211             if (threads != 0) slowprod->set("threads", threads);
2212             if (original->parent().get("force_progressive"))
2213                 slowprod->set("force_progressive", original->parent().get_int("force_progressive"));
2214             if (original->parent().get("force_tff"))
2215                 slowprod->set("force_tff", original->parent().get_int("force_tff"));
2216             int ix = original->parent().get_int("video_index");
2217             if (ix != 0) slowprod->set("video_index", ix);
2218             int colorspace = original->parent().get_int("force_colorspace");
2219             if (colorspace != 0) slowprod->set("force_colorspace", colorspace);
2220             int full_luma = original->parent().get_int("set.force_full_luma");
2221             if (full_luma != 0) slowprod->set("set.force_full_luma", full_luma);
2222             m_slowmotionProducers.insert(url, slowprod);
2223         }
2224         Mlt::Producer *clip = trackPlaylist.replace_with_blank(clipIndex);
2225         trackPlaylist.consolidate_blanks(0);
2226
2227         // Check that the blank space is long enough for our new duration
2228         clipIndex = trackPlaylist.get_clip_index_at(startPos);
2229         int blankEnd = trackPlaylist.clip_start(clipIndex) + trackPlaylist.clip_length(clipIndex);
2230         Mlt::Producer *cut;
2231         if (clipIndex + 1 < trackPlaylist.count() && (startPos + clipLength / speed > blankEnd)) {
2232             GenTime maxLength = GenTime(blankEnd, m_fps) - info.startPos;
2233             cut = slowprod->cut((int)(info.cropStart.frames(m_fps) / speed), (int)(info.cropStart.frames(m_fps) / speed + maxLength.frames(m_fps) - 1));
2234         } else cut = slowprod->cut((int)(info.cropStart.frames(m_fps) / speed), (int)((info.cropStart.frames(m_fps) + clipLength) / speed - 1));
2235
2236         // move all effects to the correct producer
2237         mltPasteEffects(clip, cut);
2238         trackPlaylist.insert_at(startPos, cut, 1);
2239         delete cut;
2240         delete clip;
2241         clipIndex = trackPlaylist.get_clip_index_at(startPos);
2242         newLength = trackPlaylist.clip_length(clipIndex);
2243         service.unlock();
2244     } else if (speed == 1.0 && strobe < 2) {
2245         service.lock();
2246
2247         Mlt::Producer *clip = trackPlaylist.replace_with_blank(clipIndex);
2248         trackPlaylist.consolidate_blanks(0);
2249
2250         // Check that the blank space is long enough for our new duration
2251         clipIndex = trackPlaylist.get_clip_index_at(startPos);
2252         int blankEnd = trackPlaylist.clip_start(clipIndex) + trackPlaylist.clip_length(clipIndex);
2253
2254         Mlt::Producer *cut;
2255         int originalStart = (int)(speedIndependantInfo.cropStart.frames(m_fps));
2256         if (clipIndex + 1 < trackPlaylist.count() && (info.startPos + speedIndependantInfo.cropDuration).frames(m_fps) > blankEnd) {
2257             GenTime maxLength = GenTime(blankEnd, m_fps) - info.startPos;
2258             cut = prod->cut(originalStart, (int)(originalStart + maxLength.frames(m_fps) - 1));
2259         } else cut = prod->cut(originalStart, (int)(originalStart + speedIndependantInfo.cropDuration.frames(m_fps)) - 1);
2260
2261         // move all effects to the correct producer
2262         mltPasteEffects(clip, cut);
2263
2264         trackPlaylist.insert_at(startPos, cut, 1);
2265         delete cut;
2266         delete clip;
2267         clipIndex = trackPlaylist.get_clip_index_at(startPos);
2268         newLength = trackPlaylist.clip_length(clipIndex);
2269         service.unlock();
2270
2271     } else if (serv == "framebuffer") {
2272         service.lock();
2273         QString url = QString::fromUtf8(clipparent.get("resource"));
2274         url = url.section('?', 0, 0);
2275         url.append('?' + m_locale.toString(speed));
2276         if (strobe > 1) url.append("&strobe=" + QString::number(strobe));
2277         Mlt::Producer *slowprod = m_slowmotionProducers.value(url);
2278         if (!slowprod || slowprod->get_producer() == NULL) {
2279             slowprod = new Mlt::Producer(*m_mltProfile, 0, ("framebuffer:" + url).toUtf8().constData());
2280             slowprod->set("strobe", strobe);
2281             QString producerid = "slowmotion:" + id.section(':', 1, 1) + ':' + m_locale.toString(speed);
2282             if (strobe > 1) producerid.append(':' + QString::number(strobe));
2283             slowprod->set("id", producerid.toUtf8().constData());
2284             // copy producer props
2285             double ar = original->parent().get_double("force_aspect_ratio");
2286             if (ar != 0.0) slowprod->set("force_aspect_ratio", ar);
2287             double fps = original->parent().get_double("force_fps");
2288             if (fps != 0.0) slowprod->set("force_fps", fps);
2289             if (original->parent().get("force_progressive"))
2290                 slowprod->set("force_progressive", original->parent().get_int("force_progressive"));
2291             if (original->parent().get("force_tff"))
2292                 slowprod->set("force_tff", original->parent().get_int("force_tff"));
2293             int threads = original->parent().get_int("threads");
2294             if (threads != 0) slowprod->set("threads", threads);
2295             int ix = original->parent().get_int("video_index");
2296             if (ix != 0) slowprod->set("video_index", ix);
2297             int colorspace = original->parent().get_int("force_colorspace");
2298             if (colorspace != 0) slowprod->set("force_colorspace", colorspace);
2299             int full_luma = original->parent().get_int("set.force_full_luma");
2300             if (full_luma != 0) slowprod->set("set.force_full_luma", full_luma);
2301             m_slowmotionProducers.insert(url, slowprod);
2302         }
2303         Mlt::Producer *clip = trackPlaylist.replace_with_blank(clipIndex);
2304         trackPlaylist.consolidate_blanks(0);
2305
2306         GenTime duration = speedIndependantInfo.cropDuration / speed;
2307         int originalStart = (int)(speedIndependantInfo.cropStart.frames(m_fps) / speed);
2308
2309         // Check that the blank space is long enough for our new duration
2310         clipIndex = trackPlaylist.get_clip_index_at(startPos);
2311         int blankEnd = trackPlaylist.clip_start(clipIndex) + trackPlaylist.clip_length(clipIndex);
2312
2313         Mlt::Producer *cut;
2314         if (clipIndex + 1 < trackPlaylist.count() && (info.startPos + duration).frames(m_fps) > blankEnd) {
2315             GenTime maxLength = GenTime(blankEnd, m_fps) - info.startPos;
2316             cut = slowprod->cut(originalStart, (int)(originalStart + maxLength.frames(m_fps) - 1));
2317         } else cut = slowprod->cut(originalStart, (int)(originalStart + duration.frames(m_fps)) - 1);
2318
2319         // move all effects to the correct producer
2320         mltPasteEffects(clip, cut);
2321
2322         trackPlaylist.insert_at(startPos, cut, 1);
2323         delete cut;
2324         delete clip;
2325         clipIndex = trackPlaylist.get_clip_index_at(startPos);
2326         newLength = trackPlaylist.clip_length(clipIndex);
2327
2328         service.unlock();
2329     }
2330     delete original;
2331     if (clipIndex + 1 == trackPlaylist.count()) mltCheckLength(&tractor);
2332     return newLength;
2333 }
2334
2335 bool Render::mltRemoveTrackEffect(int track, int index, bool updateIndex)
2336 {
2337     Mlt::Service service(m_mltProducer->parent().get_service());
2338     bool success = false;
2339     Mlt::Tractor tractor(service);
2340     Mlt::Producer trackProducer(tractor.track(track));
2341     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2342     Mlt::Service clipService(trackPlaylist.get_service());
2343
2344     service.lock();
2345     int ct = 0;
2346     Mlt::Filter *filter = clipService.filter(ct);
2347     while (filter) {
2348         if ((index == -1 && strcmp(filter->get("kdenlive_id"), ""))  || filter->get_int("kdenlive_ix") == index) {
2349             if (clipService.detach(*filter) == 0) success = true;
2350         } else if (updateIndex) {
2351             // Adjust the other effects index
2352             if (filter->get_int("kdenlive_ix") > index) filter->set("kdenlive_ix", filter->get_int("kdenlive_ix") - 1);
2353             ct++;
2354         } else ct++;
2355         filter = clipService.filter(ct);
2356     }
2357     service.unlock();
2358     refresh();
2359     return success;
2360 }
2361
2362 bool Render::mltRemoveEffect(int track, GenTime position, int index, bool updateIndex, bool doRefresh)
2363 {
2364     if (position < GenTime()) {
2365         // Remove track effect
2366         return mltRemoveTrackEffect(track, index, updateIndex);
2367     }
2368     Mlt::Service service(m_mltProducer->parent().get_service());
2369     bool success = false;
2370     Mlt::Tractor tractor(service);
2371     Mlt::Producer trackProducer(tractor.track(track));
2372     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2373
2374     int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
2375     Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
2376     if (!clip) {
2377         kDebug() << " / / / CANNOT FIND CLIP TO REMOVE EFFECT";
2378         return false;
2379     }
2380
2381     Mlt::Service clipService(clip->get_service());
2382     int duration = clip->get_playtime();
2383     if (doRefresh) {
2384         // Check if clip is visible in monitor
2385         int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
2386         if (diff < 0 || diff > duration) doRefresh = false;
2387     }
2388     delete clip;
2389
2390     service.lock();
2391     int ct = 0;
2392     Mlt::Filter *filter = clipService.filter(ct);
2393     while (filter) {
2394         if ((index == -1 && strcmp(filter->get("kdenlive_id"), ""))  || filter->get_int("kdenlive_ix") == index) {// && filter->get("kdenlive_id") == id) {
2395             if (clipService.detach(*filter) == 0) success = true;
2396             //kDebug()<<"Deleted filter id:"<<filter->get("kdenlive_id")<<", ix:"<<filter->get("kdenlive_ix")<<", SERVICE:"<<filter->get("mlt_service");
2397         } else if (updateIndex) {
2398             // Adjust the other effects index
2399             if (filter->get_int("kdenlive_ix") > index) filter->set("kdenlive_ix", filter->get_int("kdenlive_ix") - 1);
2400             ct++;
2401         } else ct++;
2402         filter = clipService.filter(ct);
2403     }
2404     service.unlock();
2405     if (doRefresh) refresh();
2406     return success;
2407 }
2408
2409 bool Render::mltAddTrackEffect(int track, EffectsParameterList params)
2410 {
2411     Mlt::Service service(m_mltProducer->parent().get_service());
2412     Mlt::Tractor tractor(service);
2413     Mlt::Producer trackProducer(tractor.track(track));
2414     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2415     Mlt::Service trackService(trackProducer.get_service()); //trackPlaylist
2416     return mltAddEffect(trackService, params, trackProducer.get_playtime() - 1, true);
2417 }
2418
2419
2420 bool Render::mltAddEffect(int track, GenTime position, EffectsParameterList params, bool doRefresh)
2421 {
2422
2423     Mlt::Service service(m_mltProducer->parent().get_service());
2424
2425     Mlt::Tractor tractor(service);
2426     Mlt::Producer trackProducer(tractor.track(track));
2427     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2428
2429     int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
2430     Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
2431     if (!clip) {
2432         return false;
2433     }
2434
2435     Mlt::Service clipService(clip->get_service());
2436     int duration = clip->get_playtime();
2437     if (doRefresh) {
2438         // Check if clip is visible in monitor
2439         int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
2440         if (diff < 0 || diff > duration) doRefresh = false;
2441     }
2442     delete clip;
2443     return mltAddEffect(clipService, params, duration, doRefresh);
2444 }
2445
2446 bool Render::mltAddEffect(Mlt::Service service, EffectsParameterList params, int duration, bool doRefresh)
2447 {
2448     bool updateIndex = false;
2449     const int filter_ix = params.paramValue("kdenlive_ix").toInt();
2450     const QString region =  params.paramValue("region");
2451     int ct = 0;
2452     service.lock();
2453
2454     Mlt::Filter *filter = service.filter(ct);
2455     while (filter) {
2456         if (filter->get_int("kdenlive_ix") == filter_ix) {
2457             // A filter at that position already existed, so we will increase all indexes later
2458             updateIndex = true;
2459             break;
2460         }
2461         ct++;
2462         filter = service.filter(ct);
2463     }
2464
2465     if (params.paramValue("id") == "speed") {
2466         // special case, speed effect is not really inserted, we just update the other effects index (kdenlive_ix)
2467         ct = 0;
2468         filter = service.filter(ct);
2469         while (filter) {
2470             if (filter->get_int("kdenlive_ix") >= filter_ix) {
2471                 if (updateIndex) filter->set("kdenlive_ix", filter->get_int("kdenlive_ix") + 1);
2472             }
2473             ct++;
2474             filter = service.filter(ct);
2475         }
2476         service.unlock();
2477         if (doRefresh) refresh();
2478         return true;
2479     }
2480
2481
2482     // temporarily remove all effects after insert point
2483     QList <Mlt::Filter *> filtersList;
2484     ct = 0;
2485     filter = service.filter(ct);
2486     while (filter) {
2487         if (filter->get_int("kdenlive_ix") >= filter_ix) {
2488             filtersList.append(filter);
2489             service.detach(*filter);
2490         } else ct++;
2491         filter = service.filter(ct);
2492     }
2493
2494     // create filter
2495     QString tag =  params.paramValue("tag");
2496     //kDebug() << " / / INSERTING EFFECT: " << tag << ", REGI: " << region;
2497     char *filterTag = qstrdup(tag.toUtf8().constData());
2498     char *filterId = qstrdup(params.paramValue("id").toUtf8().constData());
2499     QHash<QString, QString>::Iterator it;
2500     QString kfr = params.paramValue("keyframes");
2501
2502     if (!kfr.isEmpty()) {
2503         QStringList keyFrames = kfr.split(';', QString::SkipEmptyParts);
2504         //kDebug() << "// ADDING KEYFRAME EFFECT: " << params.paramValue("keyframes");
2505         char *starttag = qstrdup(params.paramValue("starttag", "start").toUtf8().constData());
2506         char *endtag = qstrdup(params.paramValue("endtag", "end").toUtf8().constData());
2507         //kDebug() << "// ADDING KEYFRAME TAGS: " << starttag << ", " << endtag;
2508         //double max = params.paramValue("max").toDouble();
2509         double min = params.paramValue("min").toDouble();
2510         double factor = params.paramValue("factor", "1").toDouble();
2511         double paramOffset = params.paramValue("offset", "0").toDouble();
2512         params.removeParam("starttag");
2513         params.removeParam("endtag");
2514         params.removeParam("keyframes");
2515         params.removeParam("min");
2516         params.removeParam("max");
2517         params.removeParam("factor");
2518         params.removeParam("offset");
2519         int offset = 0;
2520         // Special case, only one keyframe, means we want a constant value
2521         if (keyFrames.count() == 1) {
2522             Mlt::Filter *filter = new Mlt::Filter(*m_mltProfile, filterTag);
2523             if (filter && filter->is_valid()) {
2524                 filter->set("kdenlive_id", filterId);
2525                 int x1 = keyFrames.at(0).section(':', 0, 0).toInt();
2526                 double y1 = keyFrames.at(0).section(':', 1, 1).toDouble();
2527                 for (int j = 0; j < params.count(); j++) {
2528                     filter->set(params.at(j).name().toUtf8().constData(), params.at(j).value().toUtf8().constData());
2529                 }
2530                 filter->set("in", x1);
2531                 //kDebug() << "// ADDING KEYFRAME vals: " << min<<" / "<<max<<", "<<y1<<", factor: "<<factor;
2532                 filter->set(starttag, m_locale.toString(((min + y1) - paramOffset) / factor).toUtf8().data());
2533                 service.attach(*filter);
2534             }
2535         } else for (int i = 0; i < keyFrames.size() - 1; ++i) {
2536                 Mlt::Filter *filter = new Mlt::Filter(*m_mltProfile, filterTag);
2537                 if (filter && filter->is_valid()) {
2538                     filter->set("kdenlive_id", filterId);
2539                     int x1 = keyFrames.at(i).section(':', 0, 0).toInt() + offset;
2540                     double y1 = keyFrames.at(i).section(':', 1, 1).toDouble();
2541                     int x2 = keyFrames.at(i + 1).section(':', 0, 0).toInt();
2542                     double y2 = keyFrames.at(i + 1).section(':', 1, 1).toDouble();
2543                     if (x2 == -1) x2 = duration;
2544
2545                     for (int j = 0; j < params.count(); j++) {
2546                         filter->set(params.at(j).name().toUtf8().constData(), params.at(j).value().toUtf8().constData());
2547                     }
2548
2549                     filter->set("in", x1);
2550                     filter->set("out", x2);
2551                     //kDebug() << "// ADDING KEYFRAME vals: " << min<<" / "<<max<<", "<<y1<<", factor: "<<factor;
2552                     filter->set(starttag, m_locale.toString(((min + y1) - paramOffset) / factor).toUtf8().data());
2553                     filter->set(endtag, m_locale.toString(((min + y2) - paramOffset) / factor).toUtf8().data());
2554                     service.attach(*filter);
2555                     offset = 1;
2556                 }
2557             }
2558         delete[] starttag;
2559         delete[] endtag;
2560     } else {
2561         Mlt::Filter *filter;
2562         QString prefix;
2563         if (!region.isEmpty()) {
2564             filter = new Mlt::Filter(*m_mltProfile, "region");
2565         } else filter = new Mlt::Filter(*m_mltProfile, filterTag);
2566         if (filter && filter->is_valid()) {
2567             filter->set("kdenlive_id", filterId);
2568             if (!region.isEmpty()) {
2569                 filter->set("resource", region.toUtf8().constData());
2570                 filter->set("kdenlive_ix", params.paramValue("kdenlive_ix").toUtf8().constData());
2571                 filter->set("filter0", filterTag);
2572                 prefix = "filter0.";
2573                 params.removeParam("id");
2574                 params.removeParam("region");
2575                 params.removeParam("kdenlive_ix");
2576             }
2577         } else {
2578             kDebug() << "filter is NULL";
2579             service.unlock();
2580             return false;
2581         }
2582         params.removeParam("kdenlive_id");
2583         if (params.hasParam("_sync_in_out")) {
2584             // This effect must sync in / out with parent clip
2585             params.removeParam("_sync_in_out");
2586             filter->set_in_and_out(service.get_int("in"), service.get_int("out"));
2587         }
2588
2589         for (int j = 0; j < params.count(); j++) {
2590             filter->set((prefix + params.at(j).name()).toUtf8().constData(), params.at(j).value().toUtf8().constData());
2591         }
2592
2593         if (tag == "sox") {
2594             QString effectArgs = params.paramValue("id").section('_', 1);
2595
2596             params.removeParam("id");
2597             params.removeParam("kdenlive_ix");
2598             params.removeParam("tag");
2599             params.removeParam("disable");
2600             params.removeParam("region");
2601
2602             for (int j = 0; j < params.count(); j++) {
2603                 effectArgs.append(' ' + params.at(j).value());
2604             }
2605             //kDebug() << "SOX EFFECTS: " << effectArgs.simplified();
2606             filter->set("effect", effectArgs.simplified().toUtf8().constData());
2607         }
2608
2609         // attach filter to the clip
2610         service.attach(*filter);
2611     }
2612     delete[] filterId;
2613     delete[] filterTag;
2614
2615     // re-add following filters
2616     for (int i = 0; i < filtersList.count(); i++) {
2617         Mlt::Filter *filter = filtersList.at(i);
2618         if (updateIndex)
2619             filter->set("kdenlive_ix", filter->get_int("kdenlive_ix") + 1);
2620         service.attach(*filter);
2621     }
2622     service.unlock();
2623     if (doRefresh) refresh();
2624     return true;
2625 }
2626
2627 bool Render::mltEditTrackEffect(int track, EffectsParameterList params)
2628 {
2629     Mlt::Service service(m_mltProducer->parent().get_service());
2630     Mlt::Tractor tractor(service);
2631     Mlt::Producer trackProducer(tractor.track(track));
2632     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2633     Mlt::Service clipService(trackPlaylist.get_service());
2634     int ct = 0;
2635     QString index = params.paramValue("kdenlive_ix");
2636     QString tag =  params.paramValue("tag");
2637
2638     Mlt::Filter *filter = clipService.filter(ct);
2639     while (filter) {
2640         if (filter->get_int("kdenlive_ix") == index.toInt()) {
2641             break;
2642         }
2643         ct++;
2644         filter = clipService.filter(ct);
2645     }
2646
2647     if (!filter) {
2648         kDebug() << "WARINIG, FILTER FOR EDITING NOT FOUND, ADDING IT! " << index << ", " << tag;
2649         // filter was not found, it was probably a disabled filter, so add it to the correct place...
2650
2651         bool success = false;//mltAddTrackEffect(track, params);
2652         return success;
2653     }
2654     QString prefix;
2655     QString ser = filter->get("mlt_service");
2656     if (ser == "region") prefix = "filter0.";
2657     service.lock();
2658     for (int j = 0; j < params.count(); j++) {
2659         filter->set((prefix + params.at(j).name()).toUtf8().constData(), params.at(j).value().toUtf8().constData());
2660     }
2661     service.unlock();
2662
2663     refresh();
2664     return true;
2665
2666 }
2667
2668 bool Render::mltEditEffect(int track, GenTime position, EffectsParameterList params)
2669 {
2670     int index = params.paramValue("kdenlive_ix").toInt();
2671     QString tag =  params.paramValue("tag");
2672
2673     if (!params.paramValue("keyframes").isEmpty() || /*it.key().startsWith("#") || */tag.startsWith("ladspa") || tag == "sox" || tag == "autotrack_rectangle" || params.hasParam("region")) {
2674         // This is a keyframe effect, to edit it, we remove it and re-add it.
2675         bool success = mltRemoveEffect(track, position, index, false);
2676 //         if (!success) kDebug() << "// ERROR Removing effect : " << index;
2677         if (position < GenTime())
2678             success = mltAddTrackEffect(track, params);
2679         else
2680             success = mltAddEffect(track, position, params);
2681 //         if (!success) kDebug() << "// ERROR Adding effect : " << index;
2682         return success;
2683     }
2684     if (position < GenTime()) {
2685         return mltEditTrackEffect(track, params);
2686     }
2687     // find filter
2688     Mlt::Service service(m_mltProducer->parent().get_service());
2689     Mlt::Tractor tractor(service);
2690     Mlt::Producer trackProducer(tractor.track(track));
2691     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2692
2693     int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
2694     Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
2695     if (!clip) {
2696         kDebug() << "WARINIG, CANNOT FIND CLIP ON track: " << track << ", AT POS: " << position.frames(m_fps);
2697         return false;
2698     }
2699
2700     int duration = clip->get_playtime();
2701     bool doRefresh = true;
2702     // Check if clip is visible in monitor
2703     int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
2704     if (diff < 0 || diff > duration)
2705         doRefresh = false;
2706     int ct = 0;
2707
2708     Mlt::Filter *filter = clip->filter(ct);
2709     while (filter) {
2710         if (filter->get_int("kdenlive_ix") == index) {
2711             break;
2712         }
2713         ct++;
2714         filter = clip->filter(ct);
2715     }
2716
2717     if (!filter) {
2718         kDebug() << "WARINIG, FILTER FOR EDITING NOT FOUND, ADDING IT! " << index << ", " << tag;
2719         // filter was not found, it was probably a disabled filter, so add it to the correct place...
2720
2721         bool success = mltAddEffect(track, position, params);
2722         return success;
2723     }
2724     QString prefix;
2725     QString ser = filter->get("mlt_service");
2726     if (ser == "region") prefix = "filter0.";
2727     if (params.hasParam("_sync_in_out")) {
2728         // This effect must sync in / out with parent clip
2729         params.removeParam("_sync_in_out");
2730         filter->set_in_and_out(clip->get_in(), clip->get_out());
2731     }
2732     service.lock();
2733     for (int j = 0; j < params.count(); j++) {
2734         filter->set((prefix + params.at(j).name()).toUtf8().constData(), params.at(j).value().toUtf8().constData());
2735     }
2736
2737     delete clip;
2738     service.unlock();
2739
2740     if (doRefresh) refresh();
2741     return true;
2742 }
2743
2744 void Render::mltUpdateEffectPosition(int track, GenTime position, int oldPos, int newPos)
2745 {
2746     Mlt::Service service(m_mltProducer->parent().get_service());
2747     Mlt::Tractor tractor(service);
2748     Mlt::Producer trackProducer(tractor.track(track));
2749     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2750
2751     int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
2752     Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
2753     if (!clip) {
2754         kDebug() << "WARINIG, CANNOT FIND CLIP ON track: " << track << ", AT POS: " << position.frames(m_fps);
2755         return;
2756     }
2757
2758     Mlt::Service clipService(clip->get_service());
2759     int duration = clip->get_playtime();
2760     bool doRefresh = true;
2761     // Check if clip is visible in monitor
2762     int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
2763     if (diff < 0 || diff > duration) doRefresh = false;
2764     delete clip;
2765
2766     int ct = 0;
2767     Mlt::Filter *filter = clipService.filter(ct);
2768     while (filter) {
2769         int pos = filter->get_int("kdenlive_ix");
2770         if (pos == oldPos) {
2771             filter->set("kdenlive_ix", newPos);
2772         } else ct++;
2773         filter = clipService.filter(ct);
2774     }
2775     if (doRefresh) refresh();
2776 }
2777
2778 void Render::mltMoveEffect(int track, GenTime position, int oldPos, int newPos)
2779 {
2780     if (position < GenTime()) {
2781         mltMoveTrackEffect(track, oldPos, newPos);
2782         return;
2783     }
2784     Mlt::Service service(m_mltProducer->parent().get_service());
2785     Mlt::Tractor tractor(service);
2786     Mlt::Producer trackProducer(tractor.track(track));
2787     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2788
2789     int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
2790     Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
2791     if (!clip) {
2792         kDebug() << "WARINIG, CANNOT FIND CLIP ON track: " << track << ", AT POS: " << position.frames(m_fps);
2793         return;
2794     }
2795
2796     Mlt::Service clipService(clip->get_service());
2797     int duration = clip->get_playtime();
2798     bool doRefresh = true;
2799     // Check if clip is visible in monitor
2800     int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
2801     if (diff < 0 || diff > duration) doRefresh = false;
2802     delete clip;
2803
2804     int ct = 0;
2805     QList <Mlt::Filter *> filtersList;
2806     Mlt::Filter *filter = clipService.filter(ct);
2807     bool found = false;
2808     if (newPos > oldPos) {
2809         while (filter) {
2810             if (!found && filter->get_int("kdenlive_ix") == oldPos) {
2811                 filter->set("kdenlive_ix", newPos);
2812                 filtersList.append(filter);
2813                 clipService.detach(*filter);
2814                 filter = clipService.filter(ct);
2815                 while (filter && filter->get_int("kdenlive_ix") <= newPos) {
2816                     filter->set("kdenlive_ix", filter->get_int("kdenlive_ix") - 1);
2817                     ct++;
2818                     filter = clipService.filter(ct);
2819                 }
2820                 found = true;
2821             }
2822             if (filter && filter->get_int("kdenlive_ix") > newPos) {
2823                 filtersList.append(filter);
2824                 clipService.detach(*filter);
2825             } else ct++;
2826             filter = clipService.filter(ct);
2827         }
2828     } else {
2829         while (filter) {
2830             if (filter->get_int("kdenlive_ix") == oldPos) {
2831                 filter->set("kdenlive_ix", newPos);
2832                 filtersList.append(filter);
2833                 clipService.detach(*filter);
2834             } else ct++;
2835             filter = clipService.filter(ct);
2836         }
2837
2838         ct = 0;
2839         filter = clipService.filter(ct);
2840         while (filter) {
2841             int pos = filter->get_int("kdenlive_ix");
2842             if (pos >= newPos) {
2843                 if (pos < oldPos) filter->set("kdenlive_ix", pos + 1);
2844                 filtersList.append(filter);
2845                 clipService.detach(*filter);
2846             } else ct++;
2847             filter = clipService.filter(ct);
2848         }
2849     }
2850
2851     for (int i = 0; i < filtersList.count(); i++) {
2852         clipService.attach(*(filtersList.at(i)));
2853     }
2854
2855     if (doRefresh) refresh();
2856 }
2857
2858 void Render::mltMoveTrackEffect(int track, int oldPos, int newPos)
2859 {
2860     Mlt::Service service(m_mltProducer->parent().get_service());
2861     Mlt::Tractor tractor(service);
2862     Mlt::Producer trackProducer(tractor.track(track));
2863     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2864     Mlt::Service clipService(trackPlaylist.get_service());
2865     int ct = 0;
2866     QList <Mlt::Filter *> filtersList;
2867     Mlt::Filter *filter = clipService.filter(ct);
2868     bool found = false;
2869     if (newPos > oldPos) {
2870         while (filter) {
2871             if (!found && filter->get_int("kdenlive_ix") == oldPos) {
2872                 filter->set("kdenlive_ix", newPos);
2873                 filtersList.append(filter);
2874                 clipService.detach(*filter);
2875                 filter = clipService.filter(ct);
2876                 while (filter && filter->get_int("kdenlive_ix") <= newPos) {
2877                     filter->set("kdenlive_ix", filter->get_int("kdenlive_ix") - 1);
2878                     ct++;
2879                     filter = clipService.filter(ct);
2880                 }
2881                 found = true;
2882             }
2883             if (filter && filter->get_int("kdenlive_ix") > newPos) {
2884                 filtersList.append(filter);
2885                 clipService.detach(*filter);
2886             } else ct++;
2887             filter = clipService.filter(ct);
2888         }
2889     } else {
2890         while (filter) {
2891             if (filter->get_int("kdenlive_ix") == oldPos) {
2892                 filter->set("kdenlive_ix", newPos);
2893                 filtersList.append(filter);
2894                 clipService.detach(*filter);
2895             } else ct++;
2896             filter = clipService.filter(ct);
2897         }
2898
2899         ct = 0;
2900         filter = clipService.filter(ct);
2901         while (filter) {
2902             int pos = filter->get_int("kdenlive_ix");
2903             if (pos >= newPos) {
2904                 if (pos < oldPos) filter->set("kdenlive_ix", pos + 1);
2905                 filtersList.append(filter);
2906                 clipService.detach(*filter);
2907             } else ct++;
2908             filter = clipService.filter(ct);
2909         }
2910     }
2911
2912     for (int i = 0; i < filtersList.count(); i++) {
2913         clipService.attach(*(filtersList.at(i)));
2914     }
2915     refresh();
2916 }
2917
2918 bool Render::mltResizeClipEnd(ItemInfo info, GenTime clipDuration)
2919 {
2920     Mlt::Service service(m_mltProducer->parent().get_service());
2921     Mlt::Tractor tractor(service);
2922     Mlt::Producer trackProducer(tractor.track(info.track));
2923     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
2924
2925     /* // Display playlist info
2926     kDebug()<<"////////////  BEFORE RESIZE";
2927     for (int i = 0; i < trackPlaylist.count(); i++) {
2928     int blankStart = trackPlaylist.clip_start(i);
2929     int blankDuration = trackPlaylist.clip_length(i) - 1;
2930     QString blk;
2931     if (trackPlaylist.is_blank(i)) blk = "(blank)";
2932     kDebug()<<"CLIP "<<i<<": ("<<blankStart<<'x'<<blankStart + blankDuration<<")"<<blk;
2933     }*/
2934
2935     if (trackPlaylist.is_blank_at((int) info.startPos.frames(m_fps))) {
2936         kDebug() << "////////  ERROR RSIZING BLANK CLIP!!!!!!!!!!!";
2937         return false;
2938     }
2939     service.lock();
2940     int clipIndex = trackPlaylist.get_clip_index_at((int) info.startPos.frames(m_fps));
2941     //kDebug() << "// SELECTED CLIP START: " << trackPlaylist.clip_start(clipIndex);
2942     Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
2943
2944     int previousStart = clip->get_in();
2945     int newDuration = (int) clipDuration.frames(m_fps) - 1;
2946     int diff = newDuration - (trackPlaylist.clip_length(clipIndex) - 1);
2947
2948     int currentOut = newDuration + previousStart;
2949     if (currentOut > clip->get_length()) {
2950         clip->parent().set("length", currentOut + 1);
2951         clip->parent().set("out", currentOut);
2952         clip->set("length", currentOut + 1);
2953     }
2954
2955     /*if (newDuration > clip->get_out()) {
2956         clip->parent().set_in_and_out(0, newDuration + 1);
2957         clip->set_in_and_out(0, newDuration + 1);
2958     }*/
2959     delete clip;
2960     trackPlaylist.resize_clip(clipIndex, previousStart, newDuration + previousStart);
2961     trackPlaylist.consolidate_blanks(0);
2962     // skip to next clip
2963     clipIndex++;
2964     //kDebug() << "////////  RESIZE CLIP: " << clipIndex << "( pos: " << info.startPos.frames(25) << "), DIFF: " << diff << ", CURRENT DUR: " << previousDuration << ", NEW DUR: " << newDuration << ", IX: " << clipIndex << ", MAX: " << trackPlaylist.count();
2965     if (diff > 0) {
2966         // clip was made longer, trim next blank if there is one.
2967         if (clipIndex < trackPlaylist.count()) {
2968             // If this is not the last clip in playlist
2969             if (trackPlaylist.is_blank(clipIndex)) {
2970                 int blankStart = trackPlaylist.clip_start(clipIndex);
2971                 int blankDuration = trackPlaylist.clip_length(clipIndex);
2972                 if (diff > blankDuration) {
2973                     kDebug() << "// ERROR blank clip is not large enough to get back required space!!!";
2974                 }
2975                 if (diff - blankDuration == 0) {
2976                     trackPlaylist.remove(clipIndex);
2977                 } else trackPlaylist.remove_region(blankStart, diff);
2978             } else {
2979                 kDebug() << "/// RESIZE ERROR, NXT CLIP IS NOT BLK: " << clipIndex;
2980             }
2981         }
2982     } else if (clipIndex != trackPlaylist.count()) trackPlaylist.insert_blank(clipIndex, 0 - diff - 1);
2983     trackPlaylist.consolidate_blanks(0);
2984     service.unlock();
2985
2986     if (info.track != 0 && clipIndex == trackPlaylist.count()) mltCheckLength(&tractor);
2987     /*if (QString(clip->parent().get("transparency")).toInt() == 1) {
2988         //mltResizeTransparency(previousStart, previousStart, previousStart + newDuration, track, QString(clip->parent().get("id")).toInt());
2989         mltDeleteTransparency(info.startPos.frames(m_fps), info.track, QString(clip->parent().get("id")).toInt());
2990         ItemInfo transpinfo;
2991         transpinfo.startPos = info.startPos;
2992         transpinfo.endPos = info.startPos + clipDuration;
2993         transpinfo.track = info.track;
2994         mltAddClipTransparency(transpinfo, info.track - 1, QString(clip->parent().get("id")).toInt());
2995     }*/
2996     m_mltConsumer->set("refresh", 1);
2997     return true;
2998 }
2999
3000 void Render::mltChangeTrackState(int track, bool mute, bool blind)
3001 {
3002     Mlt::Service service(m_mltProducer->parent().get_service());
3003     Mlt::Tractor tractor(service);
3004     Mlt::Producer trackProducer(tractor.track(track));
3005
3006     // Make sure muting will not produce problems with our audio mixing transition,
3007     // because audio mixing is done between each track and the lowest one
3008     bool audioMixingBroken = false;
3009     if (mute && trackProducer.get_int("hide") < 2 ) {
3010             // We mute a track with sound
3011             if (track == getLowestNonMutedAudioTrack(tractor)) audioMixingBroken = true;
3012             kDebug()<<"Muting track: "<<track <<" / "<<getLowestNonMutedAudioTrack(tractor);
3013     }
3014     else if (!mute && trackProducer.get_int("hide") > 1 ) {
3015             // We un-mute a previously muted track
3016             if (track < getLowestNonMutedAudioTrack(tractor)) audioMixingBroken = true;
3017     }
3018
3019     if (mute) {
3020         if (blind) trackProducer.set("hide", 3);
3021         else trackProducer.set("hide", 2);
3022     } else if (blind) {
3023         trackProducer.set("hide", 1);
3024     } else {
3025         trackProducer.set("hide", 0);
3026     }
3027     if (audioMixingBroken) fixAudioMixing(tractor);
3028
3029     tractor.multitrack()->refresh();
3030     tractor.refresh();
3031     refresh();
3032 }
3033
3034 int Render::getLowestNonMutedAudioTrack(Mlt::Tractor tractor)
3035 {
3036     for (int i = 1; i < tractor.count(); i++) {
3037         Mlt::Producer trackProducer(tractor.track(i));
3038         if (trackProducer.get_int("hide") < 2) return i;
3039     }
3040     return tractor.count() - 1;
3041 }
3042
3043 void Render::fixAudioMixing(Mlt::Tractor tractor)
3044 {
3045     // Make sure the audio mixing transitions are applied to the lowest audible (non muted) track
3046     int lowestTrack = getLowestNonMutedAudioTrack(tractor);
3047
3048     mlt_service serv = m_mltProducer->parent().get_service();
3049     Mlt::Field *field = tractor.field();
3050     mlt_service_lock(serv);
3051
3052     mlt_service nextservice = mlt_service_get_producer(serv);
3053     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
3054     QString mlt_type = mlt_properties_get(properties, "mlt_type");
3055     QString resource = mlt_properties_get(properties, "mlt_service");
3056
3057     mlt_service nextservicetodisconnect;
3058      // Delete all audio mixing transitions
3059     while (mlt_type == "transition") {
3060         if (resource == "mix") {
3061             nextservicetodisconnect = nextservice;
3062             nextservice = mlt_service_producer(nextservice);
3063             mlt_field_disconnect_service(field->get_field(), nextservicetodisconnect);
3064         }
3065         else nextservice = mlt_service_producer(nextservice);
3066         if (nextservice == NULL) break;
3067         properties = MLT_SERVICE_PROPERTIES(nextservice);
3068         mlt_type = mlt_properties_get(properties, "mlt_type");
3069         resource = mlt_properties_get(properties, "mlt_service");
3070     }
3071
3072     // Re-add correct audio transitions
3073     for (int i = lowestTrack + 1; i < tractor.count(); i++) {
3074         Mlt::Transition *transition = new Mlt::Transition(*m_mltProfile, "mix");
3075         transition->set("always_active", 1);
3076         transition->set("combine", 1);
3077         transition->set("internal_added", 237);
3078         field->plant_transition(*transition, lowestTrack, i);
3079     }
3080     mlt_service_unlock(serv);
3081 }
3082
3083 bool Render::mltResizeClipCrop(ItemInfo info, GenTime diff)
3084 {
3085     Mlt::Service service(m_mltProducer->parent().get_service());
3086     int frameOffset = (int) diff.frames(m_fps);
3087     Mlt::Tractor tractor(service);
3088     Mlt::Producer trackProducer(tractor.track(info.track));
3089     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
3090     if (trackPlaylist.is_blank_at(info.startPos.frames(m_fps))) {
3091         kDebug() << "////////  ERROR RSIZING BLANK CLIP!!!!!!!!!!!";
3092         return false;
3093     }
3094     service.lock();
3095     int clipIndex = trackPlaylist.get_clip_index_at(info.startPos.frames(m_fps));
3096     Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
3097     if (clip == NULL) {
3098         kDebug() << "////////  ERROR RSIZING NULL CLIP!!!!!!!!!!!";
3099         service.unlock();
3100         return false;
3101     }
3102     int previousStart = clip->get_in();
3103     int previousOut = clip->get_out();
3104     delete clip;
3105     trackPlaylist.resize_clip(clipIndex, previousStart + frameOffset, previousOut + frameOffset);
3106     service.unlock();
3107     m_mltConsumer->set("refresh", 1);
3108     return true;
3109 }
3110
3111 bool Render::mltResizeClipStart(ItemInfo info, GenTime diff)
3112 {
3113     //kDebug() << "////////  RSIZING CLIP from: "<<info.startPos.frames(25)<<" to "<<diff.frames(25);
3114     Mlt::Service service(m_mltProducer->parent().get_service());
3115     int moveFrame = (int) diff.frames(m_fps);
3116     Mlt::Tractor tractor(service);
3117     Mlt::Producer trackProducer(tractor.track(info.track));
3118     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
3119     if (trackPlaylist.is_blank_at(info.startPos.frames(m_fps))) {
3120         kDebug() << "////////  ERROR RSIZING BLANK CLIP!!!!!!!!!!!";
3121         return false;
3122     }
3123     service.lock();
3124     int clipIndex = trackPlaylist.get_clip_index_at(info.startPos.frames(m_fps));
3125     Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
3126     if (clip == NULL || clip->is_blank()) {
3127         kDebug() << "////////  ERROR RSIZING NULL CLIP!!!!!!!!!!!";
3128         service.unlock();
3129         return false;
3130     }
3131     int previousStart = clip->get_in();
3132     int previousOut = clip->get_out();
3133
3134     previousStart += moveFrame;
3135
3136     if (previousStart < 0) {
3137         // this is possible for images and color clips
3138         previousOut -= previousStart;
3139         previousStart = 0;
3140     }
3141
3142     int length = previousOut + 1;
3143     if (length > clip->get_length()) {
3144         clip->parent().set("length", length + 1);
3145         clip->parent().set("out", length);
3146         clip->set("length", length + 1);
3147     }
3148     delete clip;
3149
3150     // kDebug() << "RESIZE, new start: " << previousStart << ", " << previousOut;
3151     trackPlaylist.resize_clip(clipIndex, previousStart, previousOut);
3152     if (moveFrame > 0) {
3153         trackPlaylist.insert_blank(clipIndex, moveFrame - 1);
3154     } else {
3155         //int midpos = info.startPos.frames(m_fps) + moveFrame - 1;
3156         int blankIndex = clipIndex - 1;
3157         int blankLength = trackPlaylist.clip_length(blankIndex);
3158         // kDebug() << " + resizing blank length " <<  blankLength << ", SIZE DIFF: " << moveFrame;
3159         if (! trackPlaylist.is_blank(blankIndex)) {
3160             kDebug() << "WARNING, CLIP TO RESIZE IS NOT BLANK";
3161         }
3162         if (blankLength + moveFrame == 0)
3163             trackPlaylist.remove(blankIndex);
3164         else
3165             trackPlaylist.resize_clip(blankIndex, 0, blankLength + moveFrame - 1);
3166     }
3167     trackPlaylist.consolidate_blanks(0);
3168     /*if (QString(clip->parent().get("transparency")).toInt() == 1) {
3169         //mltResizeTransparency(previousStart, (int) moveEnd.frames(m_fps), (int) (moveEnd + out - in).frames(m_fps), track, QString(clip->parent().get("id")).toInt());
3170         mltDeleteTransparency(info.startPos.frames(m_fps), info.track, QString(clip->parent().get("id")).toInt());
3171         ItemInfo transpinfo;
3172         transpinfo.startPos = info.startPos + diff;
3173         transpinfo.endPos = info.startPos + diff + (info.endPos - info.startPos);
3174         transpinfo.track = info.track;
3175         mltAddClipTransparency(transpinfo, info.track - 1, QString(clip->parent().get("id")).toInt());
3176     }*/
3177     //m_mltConsumer->set("refresh", 1);
3178     service.unlock();
3179     m_mltConsumer->set("refresh", 1);
3180     return true;
3181 }
3182
3183 bool Render::mltMoveClip(int startTrack, int endTrack, GenTime moveStart, GenTime moveEnd, Mlt::Producer *prod, bool overwrite, bool insert)
3184 {
3185     return mltMoveClip(startTrack, endTrack, (int) moveStart.frames(m_fps), (int) moveEnd.frames(m_fps), prod, overwrite, insert);
3186 }
3187
3188
3189 bool Render::mltUpdateClipProducer(int track, int pos, Mlt::Producer *prod)
3190 {
3191     if (prod == NULL || !prod->is_valid()) {
3192         kDebug() << "// Warning, CLIP on track " << track << ", at: " << pos << " is invalid, cannot update it!!!";
3193         return false;
3194     }
3195     //kDebug() << "// TRYING TO UPDATE CLIP at: " << pos << ", TK: " << track;
3196     Mlt::Service service(m_mltProducer->parent().get_service());
3197     if (service.type() != tractor_type) {
3198         kWarning() << "// TRACTOR PROBLEM";
3199         return false;
3200     }
3201     service.lock();
3202     Mlt::Tractor tractor(service);
3203     Mlt::Producer trackProducer(tractor.track(track));
3204     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
3205     int clipIndex = trackPlaylist.get_clip_index_at(pos);
3206     Mlt::Producer *clipProducer = trackPlaylist.replace_with_blank(clipIndex);
3207     if (clipProducer == NULL || clipProducer->is_blank()) {
3208         kDebug() << "// ERROR UPDATING CLIP PROD";
3209         delete clipProducer;
3210         service.unlock();
3211         return false;
3212     }
3213     Mlt::Producer *clip = prod->cut(clipProducer->get_in(), clipProducer->get_out());
3214     if (!clip || !clip->is_valid()) {
3215         if (clip) delete clip;
3216         delete clipProducer;
3217         service.unlock();
3218         return false;
3219     }
3220     // move all effects to the correct producer
3221     mltPasteEffects(clipProducer, clip);
3222     trackPlaylist.insert_at(pos, clip, 1);
3223     delete clip;
3224     delete clipProducer;
3225     service.unlock();
3226     return true;
3227 }
3228
3229 bool Render::mltMoveClip(int startTrack, int endTrack, int moveStart, int moveEnd, Mlt::Producer *prod, bool overwrite, bool /*insert*/)
3230 {
3231     Mlt::Service service(m_mltProducer->parent().get_service());
3232     if (service.type() != tractor_type) {
3233         kWarning() << "// TRACTOR PROBLEM";
3234         return false;
3235     }
3236
3237     Mlt::Tractor tractor(service);
3238     service.lock();
3239     Mlt::Producer trackProducer(tractor.track(startTrack));
3240     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
3241     int clipIndex = trackPlaylist.get_clip_index_at(moveStart);
3242     //kDebug() << "//////  LOOKING FOR CLIP TO MOVE, INDEX: " << clipIndex;
3243     bool checkLength = false;
3244     if (endTrack == startTrack) {
3245         Mlt::Producer *clipProducer = trackPlaylist.replace_with_blank(clipIndex);
3246         if ((!overwrite && !trackPlaylist.is_blank_at(moveEnd)) || !clipProducer || !clipProducer->is_valid() || clipProducer->is_blank()) {
3247             // error, destination is not empty
3248             if (clipProducer) {
3249                 if (!trackPlaylist.is_blank_at(moveEnd) && clipProducer->is_valid()) trackPlaylist.insert_at(moveStart, clipProducer, 1);
3250                 delete clipProducer;
3251             }
3252             //int ix = trackPlaylist.get_clip_index_at(moveEnd);
3253             kDebug() << "// ERROR MOVING CLIP TO : " << moveEnd;
3254             service.unlock();
3255             return false;
3256         } else {
3257             trackPlaylist.consolidate_blanks(0);
3258             if (overwrite) {
3259                 trackPlaylist.remove_region(moveEnd, clipProducer->get_playtime());
3260                 int clipIndex = trackPlaylist.get_clip_index_at(moveEnd);
3261                 trackPlaylist.insert_blank(clipIndex, clipProducer->get_playtime() - 1);
3262             }
3263             int newIndex = trackPlaylist.insert_at(moveEnd, clipProducer, 1);
3264             trackPlaylist.consolidate_blanks(1);
3265             delete clipProducer;
3266             /*if (QString(clipProducer.parent().get("transparency")).toInt() == 1) {
3267             mltMoveTransparency(moveStart, moveEnd, startTrack, endTrack, QString(clipProducer.parent().get("id")).toInt());
3268             }*/
3269             if (newIndex + 1 == trackPlaylist.count()) checkLength = true;
3270         }
3271         //service.unlock();
3272     } else {
3273         Mlt::Producer destTrackProducer(tractor.track(endTrack));
3274         Mlt::Playlist destTrackPlaylist((mlt_playlist) destTrackProducer.get_service());
3275         if (!overwrite && !destTrackPlaylist.is_blank_at(moveEnd)) {
3276             // error, destination is not empty
3277             service.unlock();
3278             return false;
3279         } else {
3280             Mlt::Producer *clipProducer = trackPlaylist.replace_with_blank(clipIndex);
3281             if (!clipProducer || clipProducer->is_blank()) {
3282                 // error, destination is not empty
3283                 //int ix = trackPlaylist.get_clip_index_at(moveEnd);
3284                 if (clipProducer) delete clipProducer;
3285                 kDebug() << "// ERROR MOVING CLIP TO : " << moveEnd;
3286                 service.unlock();
3287                 return false;
3288             }
3289             trackPlaylist.consolidate_blanks(0);
3290             destTrackPlaylist.consolidate_blanks(1);
3291             Mlt::Producer *clip;
3292             // check if we are moving a slowmotion producer
3293             QString serv = clipProducer->parent().get("mlt_service");
3294             QString currentid = clipProducer->parent().get("id");
3295             if (serv == "framebuffer" || currentid.endsWith("_video")) {
3296                 clip = clipProducer;
3297             } else {
3298                 if (prod == NULL) {
3299                     // Special case: prod is null when using placeholder clips.
3300                     // in that case, use the producer existing in playlist. Note that
3301                     // it will bypass the one producer per track logic and might cause
3302                     // Sound cracks if clip is moved so that it overlaps another copy of itself
3303                     clip = clipProducer->cut(clipProducer->get_in(), clipProducer->get_out());
3304                 } else clip = prod->cut(clipProducer->get_in(), clipProducer->get_out());
3305             }
3306
3307             // move all effects to the correct producer
3308             mltPasteEffects(clipProducer, clip);
3309
3310             if (overwrite) {
3311                 destTrackPlaylist.remove_region(moveEnd, clip->get_playtime());
3312                 int clipIndex = destTrackPlaylist.get_clip_index_at(moveEnd);
3313                 destTrackPlaylist.insert_blank(clipIndex, clip->get_playtime() - 1);
3314             }
3315
3316             int newIndex = destTrackPlaylist.insert_at(moveEnd, clip, 1);
3317
3318             if (clip == clipProducer) {
3319                 delete clip;
3320                 clip = NULL;
3321             } else {
3322                 delete clip;
3323                 delete clipProducer;
3324             }
3325             destTrackPlaylist.consolidate_blanks(0);
3326             /*if (QString(clipProducer.parent().get("transparency")).toInt() == 1) {
3327                 kDebug() << "//////// moving clip transparency";
3328                 mltMoveTransparency(moveStart, moveEnd, startTrack, endTrack, QString(clipProducer.parent().get("id")).toInt());
3329             }*/
3330             if (clipIndex > trackPlaylist.count()) checkLength = true;
3331             else if (newIndex + 1 == destTrackPlaylist.count()) checkLength = true;
3332         }
3333     }
3334     service.unlock();
3335     if (checkLength) mltCheckLength(&tractor);
3336     //askForRefresh();
3337     //m_mltConsumer->set("refresh", 1);
3338     return true;
3339 }
3340
3341
3342 QList <int> Render::checkTrackSequence(int track)
3343 {
3344     QList <int> list;
3345     Mlt::Service service(m_mltProducer->parent().get_service());
3346     if (service.type() != tractor_type) {
3347         kWarning() << "// TRACTOR PROBLEM";
3348         return list;
3349     }
3350     Mlt::Tractor tractor(service);
3351     service.lock();
3352     Mlt::Producer trackProducer(tractor.track(track));
3353     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
3354     int clipNb = trackPlaylist.count();
3355     //kDebug() << "// PARSING SCENE TRACK: " << t << ", CLIPS: " << clipNb;
3356     for (int i = 0; i < clipNb; i++) {
3357         Mlt::Producer *c = trackPlaylist.get_clip(i);
3358         int pos = trackPlaylist.clip_start(i);
3359         if (!list.contains(pos)) list.append(pos);
3360         pos += c->get_playtime();
3361         if (!list.contains(pos)) list.append(pos);
3362         delete c;
3363     }
3364     return list;
3365 }
3366
3367 bool Render::mltMoveTransition(QString type, int startTrack, int newTrack, int newTransitionTrack, GenTime oldIn, GenTime oldOut, GenTime newIn, GenTime newOut)
3368 {
3369     int new_in = (int)newIn.frames(m_fps);
3370     int new_out = (int)newOut.frames(m_fps) - 1;
3371     if (new_in >= new_out) return false;
3372     int old_in = (int)oldIn.frames(m_fps);
3373     int old_out = (int)oldOut.frames(m_fps) - 1;
3374
3375     Mlt::Service service(m_mltProducer->parent().get_service());
3376     Mlt::Tractor tractor(service);
3377     Mlt::Field *field = tractor.field();
3378
3379     bool doRefresh = true;
3380     // Check if clip is visible in monitor
3381     int diff = old_out - m_mltProducer->position();
3382     if (diff < 0 || diff > old_out - old_in) doRefresh = false;
3383     if (doRefresh) {
3384         diff = new_out - m_mltProducer->position();
3385         if (diff < 0 || diff > new_out - new_in) doRefresh = false;
3386     }
3387     service.lock();
3388
3389     mlt_service nextservice = mlt_service_get_producer(service.get_service());
3390     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
3391     QString mlt_type = mlt_properties_get(properties, "mlt_type");
3392     QString resource = mlt_properties_get(properties, "mlt_service");
3393     int old_pos = (int)(old_in + old_out) / 2;
3394     bool found = false;
3395
3396     while (mlt_type == "transition") {
3397         Mlt::Transition transition((mlt_transition) nextservice);
3398         int currentTrack = transition.get_b_track();
3399         int currentIn = (int) transition.get_in();
3400         int currentOut = (int) transition.get_out();
3401
3402         if (resource == type && startTrack == currentTrack && currentIn <= old_pos && currentOut >= old_pos) {
3403             found = true;
3404             if (newTrack - startTrack != 0) {
3405                 Mlt::Properties trans_props(transition.get_properties());
3406                 Mlt::Transition new_transition(*m_mltProfile, transition.get("mlt_service"));
3407                 Mlt::Properties new_trans_props(new_transition.get_properties());
3408                 new_trans_props.inherit(trans_props);
3409                 new_transition.set_in_and_out(new_in, new_out);
3410                 field->disconnect_service(transition);
3411                 mltPlantTransition(field, new_transition, newTransitionTrack, newTrack);
3412                 //field->plant_transition(new_transition, newTransitionTrack, newTrack);
3413             } else transition.set_in_and_out(new_in, new_out);
3414             break;
3415         }
3416         nextservice = mlt_service_producer(nextservice);
3417         if (nextservice == NULL) break;
3418         properties = MLT_SERVICE_PROPERTIES(nextservice);
3419         mlt_type = mlt_properties_get(properties, "mlt_type");
3420         resource = mlt_properties_get(properties, "mlt_service");
3421     }
3422     service.unlock();
3423     if (doRefresh) refresh();
3424     //if (m_isBlocked == 0) m_mltConsumer->set("refresh", 1);
3425     return found;
3426 }
3427
3428
3429 void Render::mltPlantTransition(Mlt::Field *field, Mlt::Transition &tr, int a_track, int b_track)
3430 {
3431     mlt_service nextservice = mlt_service_get_producer(field->get_service());
3432     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
3433     QString mlt_type = mlt_properties_get(properties, "mlt_type");
3434     QString resource = mlt_properties_get(properties, "mlt_service");
3435     QList <Mlt::Transition *> trList;
3436
3437     while (mlt_type == "transition") {
3438         Mlt::Transition transition((mlt_transition) nextservice);
3439         int aTrack = transition.get_a_track();
3440         int bTrack = transition.get_b_track();
3441         if (resource != "mix" && (aTrack < a_track || (aTrack == a_track && bTrack > b_track))) {
3442             Mlt::Properties trans_props(transition.get_properties());
3443             Mlt::Transition *cp = new Mlt::Transition(*m_mltProfile, transition.get("mlt_service"));
3444             Mlt::Properties new_trans_props(cp->get_properties());
3445             new_trans_props.inherit(trans_props);
3446             trList.append(cp);
3447             field->disconnect_service(transition);
3448         }
3449         //else kDebug() << "// FOUND TRANS OK, "<<resource<< ", A_: " << aTrack << ", B_ "<<bTrack;
3450
3451         nextservice = mlt_service_producer(nextservice);
3452         if (nextservice == NULL) break;
3453         properties = MLT_SERVICE_PROPERTIES(nextservice);
3454         mlt_type = mlt_properties_get(properties, "mlt_type");
3455         resource = mlt_properties_get(properties, "mlt_service");
3456     }
3457     field->plant_transition(tr, a_track, b_track);
3458
3459     // re-add upper transitions
3460     for (int i = trList.count() - 1; i >= 0; i--) {
3461         //kDebug()<< "REPLANT ON TK: "<<trList.at(i)->get_a_track()<<", "<<trList.at(i)->get_b_track();
3462         field->plant_transition(*trList.at(i), trList.at(i)->get_a_track(), trList.at(i)->get_b_track());
3463     }
3464 }
3465
3466 void Render::mltUpdateTransition(QString oldTag, QString tag, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml, bool force)
3467 {
3468     if (oldTag == tag && !force) mltUpdateTransitionParams(tag, a_track, b_track, in, out, xml);
3469     else {
3470         //kDebug()<<"// DELETING TRANS: "<<a_track<<"-"<<b_track;
3471         mltDeleteTransition(oldTag, a_track, b_track, in, out, xml, false);
3472         mltAddTransition(tag, a_track, b_track, in, out, xml, false);
3473     }
3474
3475     if (m_mltProducer->position() >= in.frames(m_fps) && m_mltProducer->position() <= out.frames(m_fps)) refresh();
3476 }
3477
3478 void Render::mltUpdateTransitionParams(QString type, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml)
3479 {
3480     mlt_service serv = m_mltProducer->parent().get_service();
3481     mlt_service_lock(serv);
3482
3483     mlt_service nextservice = mlt_service_get_producer(serv);
3484     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
3485     QString mlt_type = mlt_properties_get(properties, "mlt_type");
3486     QString resource = mlt_properties_get(properties, "mlt_service");
3487     int in_pos = (int) in.frames(m_fps);
3488     int out_pos = (int) out.frames(m_fps) - 1;
3489
3490     while (mlt_type == "transition") {
3491         mlt_transition tr = (mlt_transition) nextservice;
3492         int currentTrack = mlt_transition_get_b_track(tr);
3493         int currentBTrack = mlt_transition_get_a_track(tr);
3494         int currentIn = (int) mlt_transition_get_in(tr);
3495         int currentOut = (int) mlt_transition_get_out(tr);
3496
3497         // kDebug()<<"Looking for transition : " << currentIn <<'x'<<currentOut<< ", OLD oNE: "<<in_pos<<'x'<<out_pos;
3498         if (resource == type && b_track == currentTrack && currentIn == in_pos && currentOut == out_pos) {
3499             QMap<QString, QString> map = mltGetTransitionParamsFromXml(xml);
3500             QMap<QString, QString>::Iterator it;
3501             QString key;
3502             mlt_properties transproperties = MLT_TRANSITION_PROPERTIES(tr);
3503
3504             QString currentId = mlt_properties_get(transproperties, "kdenlive_id");
3505             if (currentId != xml.attribute("id")) {
3506                 // The transition ID is not the same, so reset all properties
3507                 mlt_properties_set(transproperties, "kdenlive_id", xml.attribute("id").toUtf8().constData());
3508                 // Cleanup previous properties
3509                 QStringList permanentProps;
3510                 permanentProps << "factory" << "kdenlive_id" << "mlt_service" << "mlt_type" << "in";
3511                 permanentProps << "out" << "a_track" << "b_track";
3512                 for (int i = 0; i < mlt_properties_count(transproperties); i++) {
3513                     QString propName = mlt_properties_get_name(transproperties, i);
3514                     if (!propName.startsWith('_') && ! permanentProps.contains(propName)) {
3515                         mlt_properties_set(transproperties, propName.toUtf8().constData(), "");
3516                     }
3517                 }
3518             }
3519
3520             mlt_properties_set_int(transproperties, "force_track", xml.attribute("force_track").toInt());
3521             mlt_properties_set_int(transproperties, "automatic", xml.attribute("automatic", "0").toInt());
3522
3523             if (currentBTrack != a_track) {
3524                 mlt_properties_set_int(transproperties, "a_track", a_track);
3525             }
3526             for (it = map.begin(); it != map.end(); ++it) {
3527                 key = it.key();
3528                 mlt_properties_set(transproperties, key.toUtf8().constData(), it.value().toUtf8().constData());
3529                 //kDebug() << " ------  UPDATING TRANS PARAM: " << key.toUtf8().constData() << ": " << it.value().toUtf8().constData();
3530                 //filter->set("kdenlive_id", id);
3531             }
3532             break;
3533         }
3534         nextservice = mlt_service_producer(nextservice);
3535         if (nextservice == NULL) break;
3536         properties = MLT_SERVICE_PROPERTIES(nextservice);
3537         mlt_type = mlt_properties_get(properties, "mlt_type");
3538         resource = mlt_properties_get(properties, "mlt_service");
3539     }
3540     mlt_service_unlock(serv);
3541     //askForRefresh();
3542     //if (m_isBlocked == 0) m_mltConsumer->set("refresh", 1);
3543 }
3544
3545 void Render::mltDeleteTransition(QString tag, int /*a_track*/, int b_track, GenTime in, GenTime out, QDomElement /*xml*/, bool /*do_refresh*/)
3546 {
3547     mlt_service serv = m_mltProducer->parent().get_service();
3548     mlt_service_lock(serv);
3549
3550     Mlt::Service service(serv);
3551     Mlt::Tractor tractor(service);
3552     Mlt::Field *field = tractor.field();
3553
3554     //if (do_refresh) m_mltConsumer->set("refresh", 0);
3555
3556     mlt_service nextservice = mlt_service_get_producer(serv);
3557     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
3558     QString mlt_type = mlt_properties_get(properties, "mlt_type");
3559     QString resource = mlt_properties_get(properties, "mlt_service");
3560
3561     const int old_pos = (int)((in + out).frames(m_fps) / 2);
3562     //kDebug() << " del trans pos: " << in.frames(25) << "-" << out.frames(25);
3563
3564     while (mlt_type == "transition") {
3565         mlt_transition tr = (mlt_transition) nextservice;
3566         int currentTrack = mlt_transition_get_b_track(tr);
3567         int currentIn = (int) mlt_transition_get_in(tr);
3568         int currentOut = (int) mlt_transition_get_out(tr);
3569         //kDebug() << "// FOUND EXISTING TRANS, IN: " << currentIn << ", OUT: " << currentOut << ", TRACK: " << currentTrack;
3570
3571         if (resource == tag && b_track == currentTrack && currentIn <= old_pos && currentOut >= old_pos) {
3572             mlt_field_disconnect_service(field->get_field(), nextservice);
3573             break;
3574         }
3575         nextservice = mlt_service_producer(nextservice);
3576         if (nextservice == NULL) break;
3577         properties = MLT_SERVICE_PROPERTIES(nextservice);
3578         mlt_type = mlt_properties_get(properties, "mlt_type");
3579         resource = mlt_properties_get(properties, "mlt_service");
3580     }
3581     mlt_service_unlock(serv);
3582     //askForRefresh();
3583     //if (m_isBlocked == 0) m_mltConsumer->set("refresh", 1);
3584 }
3585
3586 QMap<QString, QString> Render::mltGetTransitionParamsFromXml(QDomElement xml)
3587 {
3588     QDomNodeList attribs = xml.elementsByTagName("parameter");
3589     QMap<QString, QString> map;
3590     for (int i = 0; i < attribs.count(); i++) {
3591         QDomElement e = attribs.item(i).toElement();
3592         QString name = e.attribute("name");
3593         //kDebug()<<"-- TRANSITION PARAM: "<<name<<" = "<< e.attribute("name")<<" / " << e.attribute("value");
3594         map[name] = e.attribute("default");
3595         if (!e.attribute("value").isEmpty()) {
3596             map[name] = e.attribute("value");
3597         }
3598         if (e.attribute("type") != "addedgeometry" && (e.attribute("factor", "1") != "1" || e.attribute("offset", "0") != "0")) {
3599             map[name] = m_locale.toString((map.value(name).toDouble() - e.attribute("offset", "0").toDouble()) / e.attribute("factor", "1").toDouble());
3600             //map[name]=map[name].replace(".",","); //FIXME how to solve locale conversion of . ,
3601         }
3602
3603         if (e.attribute("namedesc").contains(';')) {
3604             QString format = e.attribute("format");
3605             QStringList separators = format.split("%d", QString::SkipEmptyParts);
3606             QStringList values = e.attribute("value").split(QRegExp("[,:;x]"));
3607             QString neu;
3608             QTextStream txtNeu(&neu);
3609             if (values.size() > 0)
3610                 txtNeu << (int)values[0].toDouble();
3611             int i = 0;
3612             for (i = 0; i < separators.size() && i + 1 < values.size(); i++) {
3613                 txtNeu << separators[i];
3614                 txtNeu << (int)(values[i+1].toDouble());
3615             }
3616             if (i < separators.size())
3617                 txtNeu << separators[i];
3618             map[e.attribute("name")] = neu;
3619         }
3620
3621     }
3622     return map;
3623 }
3624
3625 void Render::mltAddClipTransparency(ItemInfo info, int transitiontrack, int id)
3626 {
3627     kDebug() << "/////////  ADDING CLIP TRANSPARENCY AT: " << info.startPos.frames(25);
3628     Mlt::Service service(m_mltProducer->parent().get_service());
3629     Mlt::Tractor tractor(service);
3630     Mlt::Field *field = tractor.field();
3631
3632     Mlt::Transition *transition = new Mlt::Transition(*m_mltProfile, "composite");
3633     transition->set_in_and_out((int) info.startPos.frames(m_fps), (int) info.endPos.frames(m_fps) - 1);
3634     transition->set("transparency", id);
3635     transition->set("fill", 1);
3636     transition->set("internal_added", 237);
3637     field->plant_transition(*transition, transitiontrack, info.track);
3638     refresh();
3639 }
3640
3641 void Render::mltDeleteTransparency(int pos, int track, int id)
3642 {
3643     Mlt::Service service(m_mltProducer->parent().get_service());
3644     Mlt::Tractor tractor(service);
3645     Mlt::Field *field = tractor.field();
3646
3647     //if (do_refresh) m_mltConsumer->set("refresh", 0);
3648     mlt_service serv = m_mltProducer->parent().get_service();
3649
3650     mlt_service nextservice = mlt_service_get_producer(serv);
3651     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
3652     QString mlt_type = mlt_properties_get(properties, "mlt_type");
3653     QString resource = mlt_properties_get(properties, "mlt_service");
3654
3655     while (mlt_type == "transition") {
3656         mlt_transition tr = (mlt_transition) nextservice;
3657         int currentTrack = mlt_transition_get_b_track(tr);
3658         int currentIn = (int) mlt_transition_get_in(tr);
3659         int currentOut = (int) mlt_transition_get_out(tr);
3660         int transitionId = QString(mlt_properties_get(properties, "transparency")).toInt();
3661         kDebug() << "// FOUND EXISTING TRANS, IN: " << currentIn << ", OUT: " << currentOut << ", TRACK: " << currentTrack;
3662
3663         if (resource == "composite" && track == currentTrack && currentIn == pos && transitionId == id) {
3664             //kDebug() << " / / / / /DELETE TRANS DOOOMNE";
3665             mlt_field_disconnect_service(field->get_field(), nextservice);
3666             break;
3667         }
3668         nextservice = mlt_service_producer(nextservice);
3669         if (nextservice == NULL) break;
3670         properties = MLT_SERVICE_PROPERTIES(nextservice);
3671         mlt_type = mlt_properties_get(properties, "mlt_type");
3672         resource = mlt_properties_get(properties, "mlt_service");
3673     }
3674     //if (do_refresh) m_mltConsumer->set("refresh", 1);
3675 }
3676
3677 void Render::mltResizeTransparency(int oldStart, int newStart, int newEnd, int track, int id)
3678 {
3679     Mlt::Service service(m_mltProducer->parent().get_service());
3680     Mlt::Tractor tractor(service);
3681
3682     service.lock();
3683     m_mltConsumer->set("refresh", 0);
3684
3685     mlt_service serv = m_mltProducer->parent().get_service();
3686     mlt_service nextservice = mlt_service_get_producer(serv);
3687     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
3688     QString mlt_type = mlt_properties_get(properties, "mlt_type");
3689     QString resource = mlt_properties_get(properties, "mlt_service");
3690     kDebug() << "// resize transpar from: " << oldStart << ", TO: " << newStart << 'x' << newEnd << ", " << track << ", " << id;
3691     while (mlt_type == "transition") {
3692         mlt_transition tr = (mlt_transition) nextservice;
3693         int currentTrack = mlt_transition_get_b_track(tr);
3694         int currentIn = (int) mlt_transition_get_in(tr);
3695         //mlt_properties props = MLT_TRANSITION_PROPERTIES(tr);
3696         int transitionId = QString(mlt_properties_get(properties, "transparency")).toInt();
3697         kDebug() << "// resize transpar current in: " << currentIn << ", Track: " << currentTrack << ", id: " << id << 'x' << transitionId ;
3698         if (resource == "composite" && track == currentTrack && currentIn == oldStart && transitionId == id) {
3699             kDebug() << " / / / / /RESIZE TRANS TO: " << newStart << 'x' << newEnd;
3700             mlt_transition_set_in_and_out(tr, newStart, newEnd);
3701             break;
3702         }
3703         nextservice = mlt_service_producer(nextservice);
3704         if (nextservice == NULL) break;
3705         properties = MLT_SERVICE_PROPERTIES(nextservice);
3706         mlt_type = mlt_properties_get(properties, "mlt_type");
3707         resource = mlt_properties_get(properties, "mlt_service");
3708     }
3709     service.unlock();
3710     m_mltConsumer->set("refresh", 1);
3711
3712 }
3713
3714 void Render::mltMoveTransparency(int startTime, int endTime, int startTrack, int endTrack, int id)
3715 {
3716     Mlt::Service service(m_mltProducer->parent().get_service());
3717     Mlt::Tractor tractor(service);
3718
3719     service.lock();
3720     m_mltConsumer->set("refresh", 0);
3721
3722     mlt_service serv = m_mltProducer->parent().get_service();
3723     mlt_service nextservice = mlt_service_get_producer(serv);
3724     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
3725     QString mlt_type = mlt_properties_get(properties, "mlt_type");
3726     QString resource = mlt_properties_get(properties, "mlt_service");
3727
3728     while (mlt_type == "transition") {
3729         mlt_transition tr = (mlt_transition) nextservice;
3730         int currentTrack = mlt_transition_get_b_track(tr);
3731         int currentaTrack = mlt_transition_get_a_track(tr);
3732         int currentIn = (int) mlt_transition_get_in(tr);
3733         int currentOut = (int) mlt_transition_get_out(tr);
3734         //mlt_properties properties = MLT_TRANSITION_PROPERTIES(tr);
3735         int transitionId = QString(mlt_properties_get(properties, "transparency")).toInt();
3736         //kDebug()<<" + TRANSITION "<<id<<" == "<<transitionId<<", START TMIE: "<<currentIn<<", LOOK FR: "<<startTime<<", TRACK: "<<currentTrack<<'x'<<startTrack;
3737         if (resource == "composite" && transitionId == id && startTime == currentIn && startTrack == currentTrack) {
3738             kDebug() << "//////MOVING";
3739             mlt_transition_set_in_and_out(tr, endTime, endTime + currentOut - currentIn);
3740             if (endTrack != startTrack) {
3741                 mlt_properties properties = MLT_TRANSITION_PROPERTIES(tr);
3742                 mlt_properties_set_int(properties, "a_track", currentaTrack + endTrack - currentTrack);
3743                 mlt_properties_set_int(properties, "b_track", endTrack);
3744             }
3745             break;
3746         }
3747         nextservice = mlt_service_producer(nextservice);
3748         if (nextservice == NULL) break;
3749         properties = MLT_SERVICE_PROPERTIES(nextservice);
3750         mlt_type = mlt_properties_get(properties, "mlt_type");
3751         resource = mlt_properties_get(properties, "mlt_service");
3752     }
3753     service.unlock();
3754     m_mltConsumer->set("refresh", 1);
3755 }
3756
3757
3758 bool Render::mltAddTransition(QString tag, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml, bool do_refresh)
3759 {
3760     if (in >= out) return false;
3761     QMap<QString, QString> args = mltGetTransitionParamsFromXml(xml);
3762     Mlt::Service service(m_mltProducer->parent().get_service());
3763
3764     Mlt::Tractor tractor(service);
3765     Mlt::Field *field = tractor.field();
3766
3767     Mlt::Transition *transition = new Mlt::Transition(*m_mltProfile, tag.toUtf8().constData());
3768     if (out != GenTime())
3769         transition->set_in_and_out((int) in.frames(m_fps), (int) out.frames(m_fps) - 1);
3770
3771     if (do_refresh && (m_mltProducer->position() < in.frames(m_fps) || m_mltProducer->position() > out.frames(m_fps))) do_refresh = false;
3772     QMap<QString, QString>::Iterator it;
3773     QString key;
3774     if (xml.attribute("automatic") == "1") transition->set("automatic", 1);
3775     //kDebug() << " ------  ADDING TRANSITION PARAMs: " << args.count();
3776     if (xml.hasAttribute("id"))
3777         transition->set("kdenlive_id", xml.attribute("id").toUtf8().constData());
3778     if (xml.hasAttribute("force_track"))
3779         transition->set("force_track", xml.attribute("force_track").toInt());
3780
3781     for (it = args.begin(); it != args.end(); ++it) {
3782         key = it.key();
3783         if (!it.value().isEmpty())
3784             transition->set(key.toUtf8().constData(), it.value().toUtf8().constData());
3785         //kDebug() << " ------  ADDING TRANS PARAM: " << key << ": " << it.value();
3786     }
3787     // attach transition
3788     service.lock();
3789     mltPlantTransition(field, *transition, a_track, b_track);
3790     // field->plant_transition(*transition, a_track, b_track);
3791     service.unlock();
3792     if (do_refresh) refresh();
3793     return true;
3794 }
3795
3796 void Render::mltSavePlaylist()
3797 {
3798     kWarning() << "// UPDATING PLAYLIST TO DISK++++++++++++++++";
3799     Mlt::Consumer fileConsumer(*m_mltProfile, "xml");
3800     fileConsumer.set("resource", "/tmp/playlist.mlt");
3801
3802     Mlt::Service service(m_mltProducer->get_service());
3803
3804     fileConsumer.connect(service);
3805     fileConsumer.start();
3806 }
3807
3808 const QList <Mlt::Producer *> Render::producersList()
3809 {
3810     QList <Mlt::Producer *> prods;
3811     if (m_mltProducer == NULL) return prods;
3812     Mlt::Service service(m_mltProducer->parent().get_service());
3813     if (service.type() != tractor_type) return prods;
3814     Mlt::Tractor tractor(service);
3815     QStringList ids;
3816
3817     int trackNb = tractor.count();
3818     for (int t = 1; t < trackNb; t++) {
3819         Mlt::Producer *tt = tractor.track(t);
3820         Mlt::Producer trackProducer(tt);
3821         delete tt;
3822         Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
3823         int clipNb = trackPlaylist.count();
3824         for (int i = 0; i < clipNb; i++) {
3825             Mlt::Producer *c = trackPlaylist.get_clip(i);
3826             if (c == NULL) continue;
3827             QString prodId = c->parent().get("id");
3828             if (!c->is_blank() && !ids.contains(prodId) && !prodId.startsWith("slowmotion") && !prodId.isEmpty()) {
3829                 Mlt::Producer *nprod = new Mlt::Producer(c->get_parent());
3830                 if (nprod) {
3831                     ids.append(prodId);
3832                     prods.append(nprod);
3833                 }
3834             }
3835             delete c;
3836         }
3837     }
3838     return prods;
3839 }
3840
3841 void Render::fillSlowMotionProducers()
3842 {
3843     if (m_mltProducer == NULL) return;
3844     Mlt::Service service(m_mltProducer->parent().get_service());
3845     if (service.type() != tractor_type) return;
3846
3847     Mlt::Tractor tractor(service);
3848
3849     int trackNb = tractor.count();
3850     for (int t = 1; t < trackNb; t++) {
3851         Mlt::Producer *tt = tractor.track(t);
3852         Mlt::Producer trackProducer(tt);
3853         delete tt;
3854         Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
3855         int clipNb = trackPlaylist.count();
3856         for (int i = 0; i < clipNb; i++) {
3857             Mlt::Producer *c = trackPlaylist.get_clip(i);
3858             Mlt::Producer *nprod = new Mlt::Producer(c->get_parent());
3859             if (nprod) {
3860                 QString id = nprod->parent().get("id");
3861                 if (id.startsWith("slowmotion:") && !nprod->is_blank()) {
3862                     // this is a slowmotion producer, add it to the list
3863                     QString url = QString::fromUtf8(nprod->get("resource"));
3864                     int strobe = nprod->get_int("strobe");
3865                     if (strobe > 1) url.append("&strobe=" + QString::number(strobe));
3866                     if (!m_slowmotionProducers.contains(url)) {
3867                         m_slowmotionProducers.insert(url, nprod);
3868                     }
3869                 } else delete nprod;
3870             }
3871             delete c;
3872         }
3873     }
3874 }
3875
3876 void Render::mltInsertTrack(int ix, bool videoTrack)
3877 {
3878     blockSignals(true);
3879
3880     Mlt::Service service(m_mltProducer->parent().get_service());
3881     service.lock();
3882     if (service.type() != tractor_type) {
3883         kWarning() << "// TRACTOR PROBLEM";
3884         return;
3885     }
3886
3887     Mlt::Tractor tractor(service);
3888
3889     Mlt::Playlist playlist;
3890     int ct = tractor.count();
3891     if (ix > ct) {
3892         kDebug() << "// ERROR, TRYING TO insert TRACK " << ix << ", max: " << ct;
3893         ix = ct;
3894     }
3895
3896     int pos = ix;
3897     if (pos < ct) {
3898         Mlt::Producer *prodToMove = new Mlt::Producer(tractor.track(pos));
3899         tractor.set_track(playlist, pos);
3900         Mlt::Producer newProd(tractor.track(pos));
3901         if (!videoTrack) newProd.set("hide", 1);
3902         pos++;
3903         for (; pos <= ct; pos++) {
3904             Mlt::Producer *prodToMove2 = new Mlt::Producer(tractor.track(pos));
3905             tractor.set_track(*prodToMove, pos);
3906             prodToMove = prodToMove2;
3907         }
3908     } else {
3909         tractor.set_track(playlist, ix);
3910         Mlt::Producer newProd(tractor.track(ix));
3911         if (!videoTrack) newProd.set("hide", 1);
3912     }
3913     checkMaxThreads();
3914
3915     // Move transitions
3916     mlt_service serv = m_mltProducer->parent().get_service();
3917     mlt_service nextservice = mlt_service_get_producer(serv);
3918     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
3919     QString mlt_type = mlt_properties_get(properties, "mlt_type");
3920     QString resource = mlt_properties_get(properties, "mlt_service");
3921
3922     while (mlt_type == "transition") {
3923         if (resource != "mix") {
3924             mlt_transition tr = (mlt_transition) nextservice;
3925             int currentTrack = mlt_transition_get_b_track(tr);
3926             int currentaTrack = mlt_transition_get_a_track(tr);
3927             mlt_properties properties = MLT_TRANSITION_PROPERTIES(tr);
3928
3929             if (currentTrack >= ix) {
3930                 mlt_properties_set_int(properties, "b_track", currentTrack + 1);
3931                 mlt_properties_set_int(properties, "a_track", currentaTrack + 1);
3932             }
3933         }
3934         nextservice = mlt_service_producer(nextservice);
3935         if (nextservice == NULL) break;
3936         properties = MLT_SERVICE_PROPERTIES(nextservice);
3937         mlt_type = mlt_properties_get(properties, "mlt_type");
3938         resource = mlt_properties_get(properties, "mlt_service");
3939     }
3940
3941     // Add audio mix transition to last track
3942     Mlt::Field *field = tractor.field();
3943     Mlt::Transition *transition = new Mlt::Transition(*m_mltProfile, "mix");
3944     transition->set("a_track", 1);
3945     transition->set("b_track", ct);
3946     transition->set("always_active", 1);
3947     transition->set("internal_added", 237);
3948     transition->set("combine", 1);
3949     field->plant_transition(*transition, 1, ct);
3950     //mlt_service_unlock(m_mltConsumer->get_service());
3951     service.unlock();
3952     //tractor.multitrack()->refresh();
3953     //tractor.refresh();
3954     blockSignals(false);
3955 }
3956
3957
3958 void Render::mltDeleteTrack(int ix)
3959 {
3960     QDomDocument doc;
3961     doc.setContent(sceneList(), false);
3962     int tracksCount = doc.elementsByTagName("track").count() - 1;
3963     QDomNode track = doc.elementsByTagName("track").at(ix);
3964     QDomNode tractor = doc.elementsByTagName("tractor").at(0);
3965     QDomNodeList transitions = doc.elementsByTagName("transition");
3966     for (int i = 0; i < transitions.count(); i++) {
3967         QDomElement e = transitions.at(i).toElement();
3968         QDomNodeList props = e.elementsByTagName("property");
3969         QMap <QString, QString> mappedProps;
3970         for (int j = 0; j < props.count(); j++) {
3971             QDomElement f = props.at(j).toElement();
3972             mappedProps.insert(f.attribute("name"), f.firstChild().nodeValue());
3973         }
3974         if (mappedProps.value("mlt_service") == "mix" && mappedProps.value("b_track").toInt() == tracksCount) {
3975             tractor.removeChild(transitions.at(i));
3976             i--;
3977         } else if (mappedProps.value("mlt_service") != "mix" && (mappedProps.value("b_track").toInt() >= ix || mappedProps.value("a_track").toInt() >= ix)) {
3978             // Transition needs to be moved
3979             int a_track = mappedProps.value("a_track").toInt();
3980             int b_track = mappedProps.value("b_track").toInt();
3981             if (a_track > 0 && a_track >= ix) a_track --;
3982             if (b_track == ix) {
3983                 // transition was on the deleted track, so remove it
3984                 tractor.removeChild(transitions.at(i));
3985                 i--;
3986                 continue;
3987             }
3988             if (b_track > 0 && b_track > ix) b_track --;
3989             for (int j = 0; j < props.count(); j++) {
3990                 QDomElement f = props.at(j).toElement();
3991                 if (f.attribute("name") == "a_track") f.firstChild().setNodeValue(QString::number(a_track));
3992                 else if (f.attribute("name") == "b_track") f.firstChild().setNodeValue(QString::number(b_track));
3993             }
3994
3995         }
3996     }
3997     tractor.removeChild(track);
3998     //kDebug() << "/////////// RESULT SCENE: \n" << doc.toString();
3999     setSceneList(doc.toString(), m_framePosition);
4000     emit refreshDocumentProducers(false, false);
4001 }
4002
4003
4004 void Render::updatePreviewSettings()
4005 {
4006     kDebug() << "////// RESTARTING CONSUMER";
4007     if (!m_mltConsumer || !m_mltProducer) return;
4008     if (m_mltProducer->get_playtime() == 0) return;
4009     Mlt::Service service(m_mltProducer->parent().get_service());
4010     if (service.type() != tractor_type) return;
4011
4012     //m_mltConsumer->set("refresh", 0);
4013     if (!m_mltConsumer->is_stopped()) m_mltConsumer->stop();
4014     m_mltConsumer->purge();
4015     QString scene = sceneList();
4016     int pos = 0;
4017     if (m_mltProducer) {
4018         pos = m_mltProducer->position();
4019     }
4020
4021     setSceneList(scene, pos);
4022 }
4023
4024
4025 QString Render::updateSceneListFps(double current_fps, double new_fps, QString scene)
4026 {
4027     // Update all frame positions to the new fps value
4028     //WARNING: there are probably some effects or other that hold a frame value
4029     // as parameter and will also need to be updated here!
4030     QDomDocument doc;
4031     doc.setContent(scene);
4032
4033     double factor = new_fps / current_fps;
4034     QDomNodeList producers = doc.elementsByTagName("producer");
4035     for (int i = 0; i < producers.count(); i++) {
4036         QDomElement prod = producers.at(i).toElement();
4037         prod.removeAttribute("in");
4038         prod.removeAttribute("out");
4039
4040         QDomNodeList props = prod.childNodes();
4041         for (int j = 0; j < props.count(); j++) {
4042             QDomElement param =  props.at(j).toElement();
4043             QString paramName = param.attribute("name");
4044             if (paramName.startsWith("meta.") || paramName == "length") {
4045                 prod.removeChild(props.at(j));
4046                 j--;
4047             }
4048         }
4049     }
4050
4051     QDomNodeList entries = doc.elementsByTagName("entry");
4052     for (int i = 0; i < entries.count(); i++) {
4053         QDomElement entry = entries.at(i).toElement();
4054         int in = entry.attribute("in").toInt();
4055         int out = entry.attribute("out").toInt();
4056         in = factor * in + 0.5;
4057         out = factor * out + 0.5;
4058         entry.setAttribute("in", in);
4059         entry.setAttribute("out", out);
4060     }
4061
4062     QDomNodeList blanks = doc.elementsByTagName("blank");
4063     for (int i = 0; i < blanks.count(); i++) {
4064         QDomElement blank = blanks.at(i).toElement();
4065         int length = blank.attribute("length").toInt();
4066         length = factor * length + 0.5;
4067         blank.setAttribute("length", QString::number(length));
4068     }
4069
4070     QDomNodeList filters = doc.elementsByTagName("filter");
4071     for (int i = 0; i < filters.count(); i++) {
4072         QDomElement filter = filters.at(i).toElement();
4073         int in = filter.attribute("in").toInt();
4074         int out = filter.attribute("out").toInt();
4075         in = factor * in + 0.5;
4076         out = factor * out + 0.5;
4077         filter.setAttribute("in", in);
4078         filter.setAttribute("out", out);
4079     }
4080
4081     QDomNodeList transitions = doc.elementsByTagName("transition");
4082     for (int i = 0; i < transitions.count(); i++) {
4083         QDomElement transition = transitions.at(i).toElement();
4084         int in = transition.attribute("in").toInt();
4085         int out = transition.attribute("out").toInt();
4086         in = factor * in + 0.5;
4087         out = factor * out + 0.5;
4088         transition.setAttribute("in", in);
4089         transition.setAttribute("out", out);
4090         QDomNodeList props = transition.childNodes();
4091         for (int j = 0; j < props.count(); j++) {
4092             QDomElement param =  props.at(j).toElement();
4093             QString paramName = param.attribute("name");
4094             if (paramName == "geometry") {
4095                 QString geom = param.firstChild().nodeValue();
4096                 QStringList keys = geom.split(';');
4097                 QStringList newKeys;
4098                 for (int k = 0; k < keys.size(); ++k) {
4099                     if (keys.at(k).contains('=')) {
4100                         int pos = keys.at(k).section('=', 0, 0).toInt();
4101                         pos = factor * pos + 0.5;
4102                         newKeys.append(QString::number(pos) + '=' + keys.at(k).section('=', 1));
4103                     } else newKeys.append(keys.at(k));
4104                 }
4105                 param.firstChild().setNodeValue(newKeys.join(";"));
4106             }
4107         }
4108     }
4109     QDomElement tractor = doc.elementsByTagName("tractor").at(0).toElement();
4110     int out = tractor.attribute("out").toInt();
4111     out = factor * out + 0.5;
4112     tractor.setAttribute("out", out);
4113     emit durationChanged(out);
4114
4115     //kDebug() << "///////////////////////////// " << out << " \n" << doc.toString() << "\n-------------------------";
4116     return doc.toString();
4117 }
4118
4119
4120 void Render::sendFrameUpdate()
4121 {
4122     if (m_mltProducer) {
4123         Mlt::Frame * frame = m_mltProducer->get_frame();
4124         emitFrameUpdated(*frame);
4125         delete frame;
4126     }
4127 }
4128
4129 Mlt::Producer* Render::getProducer()
4130 {
4131     return m_mltProducer;
4132 }
4133
4134
4135 #include "renderer.moc"
4136