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