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