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