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