#include <QTimer>
#include <QDir>
+#include <QString>
#include <QApplication>
-#include <stdlib.h>
+#include <cstdlib>
+#include <cstdarg>
if (level > MLT_LOG_ERROR) return;
QString error;
QApplication::postEvent(qApp->activeWindow() , new MltErrorEvent(error.vsprintf(fmt, vl).simplified()));
+ va_end(vl);
}
#ifdef Q_WS_MAC
self->showFrame(frame);
#endif
+
+ self->emitFrameNumber(mlt_frame_get_position(frame_ptr));
+ if (frame_ptr->convert_image)
+ self->emitFrameUpdated(frame);
if (frame.get_double("_speed") == 0.0) {
self->emitConsumerStopped();
- } else {
- self->emitFrameNumber(mlt_frame_get_position(frame_ptr));
+ } else if (frame.get_double("_speed") < 0.0 && mlt_frame_get_position(frame_ptr) <= 0) {
+ self->pause();
+ self->emitConsumerStopped();
}
}
+
Render::Render(const QString & rendererName, int winid, int /* extid */, QString profile, QWidget *parent) :
QObject(parent),
m_isBlocked(0),
resource = mlt_properties_get(properties, "mlt_service");
}
- int trackNb = tractor.count();
- while (trackNb > 0) {
- Mlt::Producer trackProducer(tractor.track(trackNb - 1));
+ for (int trackNb = tractor.count() - 1; trackNb >= 0; --trackNb) {
+ Mlt::Producer trackProducer(tractor.track(trackNb));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
if (trackPlaylist.type() == playlist_type) trackPlaylist.clear();
- trackNb--;
}
}
mlt_service_unlock(service.get_service());
//delete m_osdInfo;
}
+void Render::slotSwitchFullscreen()
+{
+ if (m_mltConsumer) m_mltConsumer->set("full_screen", 1);
+}
void Render::buildConsumer(const QString profileName)
{
}
setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", 1);
+ //m_mltConsumer->set("fullscreen", 1);
#ifdef Q_WS_MAC
m_mltConsumer = new Mlt::Consumer(*m_mltProfile , "sdl_audio");
m_mltConsumer->set("preview_off", 1);
delete[] tmp;
}
+ int volume = KdenliveSettings::volume();
+ m_mltConsumer->set("volume", (float)volume / 100);
m_mltConsumer->set("progressive", 1);
m_mltConsumer->set("audio_buffer", 1024);
m_blackClip = new Mlt::Producer(*m_mltProfile , "colour", "black");
m_blackClip->set("id", "black");
+ m_blackClip->set("mlt_type", "producer");
}
+Mlt::Producer *Render::invalidProducer(const QString &id)
+{
+ Mlt::Producer *clip = new Mlt::Producer(*m_mltProfile , "colour", "red");
+ char *tmp = decodedString(id);
+ clip->set("id", tmp);
+ delete[] tmp;
+ clip->set("mlt_type", "producer");
+ return clip;
+}
+
int Render::resetProfile(const QString profileName)
{
- if (!m_mltConsumer) return 0;
- if (m_activeProfile == profileName) {
- kDebug() << "reset to same profile, nothing to do";
- return 1;
+ if (m_mltConsumer) {
+ QString videoDriver = KdenliveSettings::videodrivername();
+ QString currentDriver = m_mltConsumer->get("video_driver");
+ if (getenv("SDL_VIDEO_YUV_HWACCEL") != NULL && currentDriver == "x11") currentDriver = "x11_noaccel";
+ QString background = KdenliveSettings::window_background().name();
+ QString currentBackground = m_mltConsumer->get("window_background");
+ int volume = KdenliveSettings::volume();
+ int currentVolume = (int)(QString(m_mltConsumer->get("volume")).toDouble() * 100.0);
+ if (m_activeProfile == profileName && currentDriver == videoDriver && volume == currentVolume && background == currentBackground) {
+ kDebug() << "reset to same profile, nothing to do";
+ return 1;
+ }
+
+ if (m_isSplitView) slotSplitView(false);
+ if (!m_mltConsumer->is_stopped()) m_mltConsumer->stop();
+ m_mltConsumer->purge();
+ delete m_mltConsumer;
+ m_mltConsumer = NULL;
}
- kDebug() << "// RESETTING PROFILE FROM: " << m_activeProfile << " TO: " << profileName; //KdenliveSettings::current_profile();
- if (m_isSplitView) slotSplitView(false);
- if (!m_mltConsumer->is_stopped()) m_mltConsumer->stop();
- m_mltConsumer->purge();
- delete m_mltConsumer;
- m_mltConsumer = NULL;
QString scene = sceneList();
int pos = 0;
double current_fps = m_mltProfile->fps();
Mlt::Service service(m_mltProducer->get_service());
if (service.type() == tractor_type) {
Mlt::Tractor tractor(service);
- int trackNb = tractor.count();
- while (trackNb > 0) {
- Mlt::Producer trackProducer(tractor.track(trackNb - 1));
+ for (int trackNb = tractor.count() - 1; trackNb >= 0; --trackNb) {
+ Mlt::Producer trackProducer(tractor.track(trackNb));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
trackPlaylist.clear();
- trackNb--;
}
}
return 1;
}
-/** Wraps the VEML command of the same name; Seeks the renderer clip to the given time. */
void Render::seek(GenTime time)
{
if (!m_mltProducer)
*/
int Render::renderWidth() const
{
- return (int)(m_mltProfile->height() * m_mltProfile->dar());
+ return (int)(m_mltProfile->height() * m_mltProfile->dar() + 0.5);
}
int Render::renderHeight() const
if (service.type() != tractor_type || tractor.count() < 2) return;
Mlt::Field *field = tractor.field();
if (doit) {
- int screen = 0;
- for (int i = 1; i < tractor.count() && screen < 4; i++) {
+ for (int i = 1, screen = 0; i < tractor.count() && screen < 4; i++) {
Mlt::Producer trackProducer(tractor.track(i));
kDebug() << "// TRACK: " << i << ", HIDE: " << trackProducer.get("hide");
if (QString(trackProducer.get("hide")).toInt() != 1) {
}
}
-void Render::getFileProperties(const QDomElement xml, const QString &clipId, bool replaceProducer)
+void Render::getFileProperties(const QDomElement xml, const QString &clipId, int imageHeight, bool replaceProducer)
{
KUrl url = KUrl(xml.attribute("resource", QString()));
Mlt::Producer *producer = NULL;
char *tmp = decodedString("kdenlivetitle:" + xml.attribute("resource"));
producer = new Mlt::Producer(*m_mltProfile, 0, tmp);
delete[] tmp;
- if (xml.hasAttribute("xmldata")) {
- char *tmp = decodedString(xml.attribute("xmldata"));
+ if (producer && xml.hasAttribute("xmldata")) {
+ tmp = decodedString(xml.attribute("xmldata"));
producer->set("xmldata", tmp);
delete[] tmp;
}
double aspect = xml.attribute("force_aspect_ratio").toDouble();
if (aspect > 0) producer->set("force_aspect_ratio", aspect);
}
+
+ if (xml.hasAttribute("force_fps")) {
+ double fps = xml.attribute("force_fps").toDouble();
+ if (fps > 0) producer->set("force_fps", fps);
+ }
+
+ if (xml.hasAttribute("force_progressive")) {
+ bool ok;
+ int progressive = xml.attribute("force_progressive").toInt(&ok);
+ if (ok) producer->set("force_progressive", progressive);
+ }
if (xml.hasAttribute("threads")) {
int threads = xml.attribute("threads").toInt();
if (threads != 1) producer->set("threads", threads);
if (aindex != 0) producer->set("audio_index", aindex);
}
+ // setup length here as otherwise default length (currently 15000 frames in MLT) will be taken although outpoint is larger
+ if (xml.attribute("type").toInt() == COLOR || xml.attribute("type").toInt() == TEXT
+ || xml.attribute("type").toInt() == IMAGE || xml.attribute("type").toInt() == SLIDESHOW)
+ producer->set("length", xml.attribute("out").toInt() - xml.attribute("in").toInt() + 1);
+
if (xml.hasAttribute("out")) producer->set_in_and_out(xml.attribute("in").toInt(), xml.attribute("out").toInt());
char *tmp = decodedString(clipId);
return;
}
- int height = 50;
- int width = (int)(height * m_mltProfile->dar());
+ int width = (int)(imageHeight * m_mltProfile->dar() + 0.5);
QMap < QString, QString > filePropertyMap;
QMap < QString, QString > metadataPropertyMap;
clipService.attach(*filter);
}
}
+ if (xml.attribute("crop") == "1") {
+ // user wants to center crop the slides
+ Mlt::Filter *filter = new Mlt::Filter(*m_mltProfile, "crop");
+ if (filter && filter->is_valid()) {
+ filter->set("center", 1);
+ producer->attach(*filter);
+ }
+ }
}
mlt_image_format format = mlt_image_rgb24a;
int frame_width = width;
- int frame_height = height;
- QPixmap pix(width, height);
+ int frame_height = imageHeight;
uint8_t *data = frame->get_image(format, frame_width, frame_height, 0);
QImage image((uchar *)data, frame_width, frame_height, QImage::Format_ARGB32);
+ QPixmap pix;
if (!image.isNull()) {
- pix = QPixmap::fromImage(image.rgbSwapped());
+ if (frame_width > (2 * width)) {
+ // there was a scaling problem, do it manually
+ QImage scaled = image.scaled(width, imageHeight);
+ pix = QPixmap::fromImage(scaled.rgbSwapped());
+ } else pix = QPixmap::fromImage(image.rgbSwapped());
} else
pix.fill(Qt::black);
emit replyGetImage(clipId, pix);
} else if (frame->get_int("test_audio") == 0) {
- QPixmap pixmap = KIcon("audio-x-generic").pixmap(QSize(width, height));
+ QPixmap pixmap = KIcon("audio-x-generic").pixmap(QSize(width, imageHeight));
emit replyGetImage(clipId, pixmap);
filePropertyMap["type"] = "audio";
}
}
-
+ delete frame;
// Retrieve audio / video codec name
// If there is a
if (name.endsWith("markup") && !value.isEmpty())
metadataPropertyMap[ name.section('.', 0, -2)] = value;
}
-
- emit replyGetFileProperties(clipId, producer, filePropertyMap, metadataPropertyMap, replaceProducer);
+ producer->seek(0);
kDebug() << "REquested fuile info for: " << url.path();
- delete frame;
+ emit replyGetFileProperties(clipId, producer, filePropertyMap, metadataPropertyMap, replaceProducer);
// FIXME: should delete this to avoid a leak...
//delete producer;
}
-/** Create the producer from the MLT XML QDomDocument */
#if 0
+/** Create the producer from the MLT XML QDomDocument */
void Render::initSceneList()
{
kDebug() << "-------- INIT SCENE LIST ------_";
}
#endif
-
-
-/** Create the producer from the MLT XML QDomDocument */
int Render::setProducer(Mlt::Producer *producer, int position)
{
if (m_winid == -1) return -1;
m_fps = m_mltProducer->get_fps();
int error = connectPlaylist();
+
if (position != -1) {
m_mltProducer->seek(position);
emit rendererPosition(position);
- }
+ } else emit rendererPosition((int) m_mltProducer->position());
m_isBlocked = false;
return error;
}
-
-
-/** Create the producer from the MLT XML QDomDocument */
int Render::setSceneList(QDomDocument list, int position)
{
return setSceneList(list.toString(), position);
}
-/** Create the producer from the MLT XML QDomDocument */
int Render::setSceneList(QString playlist, int position)
{
if (m_winid == -1) return -1;
m_isBlocked = true;
- int error;
+ int error = 0;
- //kWarning() << "////// RENDER, SET SCENE LIST: " << playlist;
+ kDebug() << "////// RENDER, SET SCENE LIST: " << playlist;
- if (m_mltConsumer == NULL) {
+ if (m_mltConsumer) {
+ if (!m_mltConsumer->is_stopped()) {
+ m_mltConsumer->stop();
+ }
+ m_mltConsumer->set("refresh", 0);
+ } else {
kWarning() << "/////// ERROR, TRYING TO USE NULL MLT CONSUMER";
- m_isBlocked = false;
- return -1;
+ error = -1;
}
- if (!m_mltConsumer->is_stopped()) {
- m_mltConsumer->stop();
- }
- m_mltConsumer->set("refresh", 0);
-
if (m_mltProducer) {
m_mltProducer->set_speed(0);
//if (KdenliveSettings::osdtimecode() && m_osdInfo) m_mltProducer->detach(*m_osdInfo);
resource = mlt_properties_get(properties, "mlt_service");
}
- int trackNb = tractor.count();
- while (trackNb > 0) {
- Mlt::Producer trackProducer(tractor.track(trackNb - 1));
+ for (int trackNb = tractor.count() - 1; trackNb >= 0; --trackNb) {
+ Mlt::Producer trackProducer(tractor.track(trackNb));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
if (trackPlaylist.type() == playlist_type) trackPlaylist.clear();
- trackNb--;
}
delete field;
}
if (!m_mltProducer || !m_mltProducer->is_valid()) {
kDebug() << " WARNING - - - - -INVALID PLAYLIST: " << tmp;
m_mltProducer = m_blackClip->cut(0, 50);
+ error = -1;
}
delete[] tmp;
}
kDebug() << "// NEW SCENE LIST DURATION SET TO: " << m_mltProducer->get_playtime();
- error = connectPlaylist();
+ if (error == 0) error = connectPlaylist();
+ else connectPlaylist();
fillSlowMotionProducers();
m_isBlocked = false;
//if (position != 0) emit rendererPosition(position);
}
-/** Create the producer from the MLT XML QDomDocument */
const QString Render::sceneList()
{
QString playlist;
return true;
}
-
void Render::saveZone(KUrl url, QString desc, QPoint zone)
{
kDebug() << "// SAVING CLIP ZONE, RENDER: " << m_name;
if (m_mltConsumer->start() == -1) {
// ARGH CONSUMER BROKEN!!!!
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."));
- emit blockMonitors();
- delete m_mltProducer;
- m_mltProducer = NULL;
+ delete m_mltConsumer;
+ m_mltConsumer = NULL;
return -1;
}
emit durationChanged(m_mltProducer->get_playtime());
if (m_mltConsumer && m_mltConsumer->is_stopped()) {
kDebug() << "----- MONITOR: " << m_name << " WAS STOPPED";
if (m_mltConsumer->start() == -1) {
- 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."));
- emit blockMonitors();
- delete m_mltProducer;
- m_mltProducer = NULL;
+ //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."));
+ kDebug(QtWarningMsg) << "/ / / / CANNOT START MONITOR";
} else {
kDebug() << "----- MONITOR: " << m_name << " REFRESH";
m_isBlocked = false;
m_isBlocked = true;
m_mltConsumer->set("refresh", 0);
m_mltProducer->set_speed(0.0);
+ /*
+ The 2 lines below create a flicker loop
emit rendererPosition(m_framePosition);
- m_mltProducer->seek(m_framePosition);
+ m_mltProducer->seek(m_framePosition);*/
m_mltConsumer->purge();
}
if (m_isZoneMode) resetZoneMode();
if (m_mltProducer->get_speed() == 0.0) {
m_isBlocked = false;
+ if (m_name == "clip" && m_framePosition == (int) m_mltProducer->get_out()) m_mltProducer->seek(0);
m_mltProducer->set_speed(1.0);
m_mltConsumer->set("refresh", 1);
} else {
m_isBlocked = true;
m_mltConsumer->set("refresh", 0);
m_mltProducer->set_speed(0.0);
- emit rendererPosition(m_framePosition);
+ //emit rendererPosition(m_framePosition);
m_mltProducer->seek(m_framePosition);
m_mltConsumer->purge();
//kDebug()<<" ********* RENDER PAUSE: "<<m_mltProducer->get_speed();
return;
m_isBlocked = false;
if (!m_isZoneMode) m_originalOut = m_mltProducer->get_playtime() - 1;
- m_mltProducer->set("out", stopTime.frames(m_fps));
+ m_mltProducer->set("out", (int)(stopTime.frames(m_fps)));
m_mltProducer->seek((int)(startTime.frames(m_fps)));
m_mltProducer->set_speed(1.0);
m_mltConsumer->set("refresh", 1);
m_mltConsumer->set("play.real_time", dropFrames);
#endif
if (m_mltConsumer->start() == -1) {
- emit blockMonitors();
- delete m_mltProducer;
- m_mltProducer = NULL;
+ kDebug(QtWarningMsg) << "ERROR, Cannot start monitor";
}
}
return m_name;
}
+void Render::emitFrameUpdated(Mlt::Frame& frame)
+{
+ mlt_image_format format = mlt_image_rgb24a;
+ int width = 0;
+ int height = 0;
+ const uchar* image = frame.get_image(format, width, height);
+ QImage qimage(width, height, QImage::Format_ARGB32);
+ memcpy(qimage.bits(), image, width * height * 4);
+ emit frameUpdated(qimage.rgbSwapped());
+}
void Render::emitFrameNumber(double position)
{
m_framePosition = position;
emit rendererPosition((int) position);
- //if (qApp->activeWindow()) QApplication::postEvent(qApp->activeWindow(), new PositionChangeEvent( GenTime((int) position, m_fps), m_monitorId));
}
void Render::emitConsumerStopped()
}
}
-
-
void Render::exportFileToFirewire(QString /*srcFileName*/, int /*port*/, GenTime /*startTime*/, GenTime /*endTime*/)
{
KMessageBox::sorry(0, i18n("Firewire is not enabled on your system.\n Please install Libiec61883 and recompile Kdenlive"));
}
-
void Render::exportCurrentFrame(KUrl url, bool /*notify*/)
{
if (!m_mltProducer) {
}
#endif
-/** MLT PLAYLIST DIRECT MANIPULATON **/
-
+/*
+ * MLT playlist direct manipulation.
+ */
void Render::mltCheckLength(Mlt::Tractor *tractor)
{
while (trackNb > 1) {
Mlt::Producer trackProducer(tractor->track(trackNb - 1));
trackDuration = trackProducer.get_playtime() - 1;
- //kDebug() << " / / /DURATON FOR TRACK " << trackNb - 1 << " = " << trackDuration;
+ // kDebug() << " / / /DURATON FOR TRACK " << trackNb - 1 << " = " << trackDuration;
if (trackDuration > duration) duration = trackDuration;
trackNb--;
}
if (blackclip == NULL || blackTrackPlaylist.count() != 1) {
blackTrackPlaylist.clear();
- m_blackClip->set("length", duration);
- m_blackClip->set("out", duration - 1);
- blackclip = m_blackClip->cut(0, duration - 1);
+ m_blackClip->set("length", duration + 1);
+ m_blackClip->set("out", duration);
+ blackclip = m_blackClip->cut(0, duration);
blackTrackPlaylist.insert_at(0, blackclip, 1);
} else {
if (duration > blackclip->parent().get_length()) {
- blackclip->parent().set("length", duration);
- blackclip->parent().set("out", duration - 1);
- blackclip->set("length", duration);
+ blackclip->parent().set("length", duration + 1);
+ blackclip->parent().set("out", duration);
+ blackclip->set("length", duration + 1);
}
- blackTrackPlaylist.resize_clip(0, 0, duration - 1);
+ blackTrackPlaylist.resize_clip(0, 0, duration);
}
delete blackclip;
}
}
-int Render::mltInsertClip(ItemInfo info, QDomElement element, Mlt::Producer *prod)
+Mlt::Producer *Render::checkSlowMotionProducer(Mlt::Producer *prod, QDomElement element)
+{
+ if (element.attribute("speed", "1.0").toDouble() == 1.0 && element.attribute("strobe", "1").toInt() == 1) return prod;
+
+ // We want a slowmotion producer
+ double speed = element.attribute("speed", "1.0").toDouble();
+ int strobe = element.attribute("strobe", "1").toInt();
+ QString url = QString::fromUtf8(prod->get("resource"));
+ url.append('?' + QString::number(speed));
+ if (strobe > 1) url.append("&strobe=" + QString::number(strobe));
+ Mlt::Producer *slowprod = m_slowmotionProducers.value(url);
+ if (!slowprod || slowprod->get_producer() == NULL) {
+ char *tmp = decodedString(url);
+ slowprod = new Mlt::Producer(*m_mltProfile, "framebuffer", tmp);
+ if (strobe > 1) slowprod->set("strobe", strobe);
+ delete[] tmp;
+ QString id = prod->get("id");
+ if (id.contains('_')) id = id.section('_', 0, 0);
+ QString producerid = "slowmotion:" + id + ':' + QString::number(speed);
+ if (strobe > 1) producerid.append(':' + QString::number(strobe));
+ tmp = decodedString(producerid);
+ slowprod->set("id", tmp);
+ delete[] tmp;
+ m_slowmotionProducers.insert(url, slowprod);
+ }
+ return slowprod;
+}
+
+int Render::mltInsertClip(ItemInfo info, QDomElement element, Mlt::Producer *prod, bool overwrite, bool push)
{
if (m_mltProducer == NULL) {
kDebug() << "PLAYLIST NOT INITIALISED //////";
}
mlt_service_lock(service.get_service());
Mlt::Producer trackProducer(tractor.track(info.track));
+ int trackDuration = trackProducer.get_playtime() - 1;
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
//kDebug()<<"/// INSERT cLIP: "<<info.cropStart.frames(m_fps)<<", "<<info.startPos.frames(m_fps)<<"-"<<info.endPos.frames(m_fps);
-
- if (element.attribute("speed", "1.0").toDouble() != 1.0 || element.attribute("strobe", "1").toInt() > 1) {
- // We want a slowmotion producer
- double speed = element.attribute("speed", "1.0").toDouble();
- int strobe = element.attribute("strobe", "1").toInt();
- QString url = QString::fromUtf8(prod->get("resource"));
- url.append('?' + QString::number(speed));
- if (strobe > 1) url.append("&strobe=" + QString::number(strobe));
- Mlt::Producer *slowprod = m_slowmotionProducers.value(url);
- if (!slowprod || slowprod->get_producer() == NULL) {
- char *tmp = decodedString(url);
- slowprod = new Mlt::Producer(*m_mltProfile, "framebuffer", tmp);
- if (strobe > 1) slowprod->set("strobe", strobe);
- delete[] tmp;
- QString id = prod->get("id");
- if (id.contains('_')) id = id.section('_', 0, 0);
- QString producerid = "slowmotion:" + id + ':' + QString::number(speed);
- if (strobe > 1) producerid.append(':' + QString::number(strobe));
- tmp = decodedString(producerid);
- slowprod->set("id", tmp);
- delete[] tmp;
- m_slowmotionProducers.insert(url, slowprod);
- }
- prod = slowprod;
+ prod = checkSlowMotionProducer(prod, element);
+ if (prod == NULL || !prod->is_valid()) {
+ mlt_service_unlock(service.get_service());
+ return -1;
}
- Mlt::Producer *clip = prod->cut((int) info.cropStart.frames(m_fps), (int)(info.endPos - info.startPos + info.cropStart).frames(m_fps) - 1);
- int newIndex = trackPlaylist.insert_at((int) info.startPos.frames(m_fps), clip, 1);
+ int cutPos = (int) info.cropStart.frames(m_fps);
+ if (cutPos < 0) cutPos = 0;
+ int insertPos = (int) info.startPos.frames(m_fps);
+ int cutDuration = (int)(info.endPos - info.startPos).frames(m_fps) - 1;
+ Mlt::Producer *clip = prod->cut(cutPos, cutDuration + cutPos);
+ if (overwrite && (insertPos < trackDuration)) {
+ // Replace zone with blanks
+ //trackPlaylist.split_at(insertPos, true);
+ trackPlaylist.remove_region(insertPos, cutDuration + 1);
+ int clipIndex = trackPlaylist.get_clip_index_at(insertPos);
+ trackPlaylist.insert_blank(clipIndex, cutDuration);
+ } else if (push) {
+ trackPlaylist.split_at(insertPos, true);
+ int clipIndex = trackPlaylist.get_clip_index_at(insertPos);
+ trackPlaylist.insert_blank(clipIndex, cutDuration);
+ }
+ int newIndex = trackPlaylist.insert_at(insertPos, clip, 1);
delete clip;
/*if (QString(prod->get("transparency")).toInt() == 1)
mltAddClipTransparency(info, info.track - 1, QString(prod->get("id")).toInt());*/
void Render::mltCutClip(int track, GenTime position)
{
-
m_isBlocked = true;
Mlt::Service service(m_mltProducer->parent().get_service());
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
int startPos = info.startPos.frames(m_fps);
int clipIndex = trackPlaylist.get_clip_index_at(startPos);
+ if (trackPlaylist.is_blank(clipIndex)) {
+ kDebug() << "// WARNING, TRYING TO REMOVE A BLANK: " << startPos;
+ return false;
+ }
+ mlt_service_lock(service.get_service());
Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
-
// keep effects
QList <Mlt::Filter *> filtersList;
Mlt::Service sourceService(clip->get_service());
ct++;
filter = sourceService.filter(ct);
}
- if (!mltRemoveClip(info.track, info.startPos)) return false;
- if (mltInsertClip(info, element, prod) == -1) return false;
+
+ trackPlaylist.replace_with_blank(clipIndex);
+ delete clip;
+ //if (!mltRemoveClip(info.track, info.startPos)) return false;
+ prod = checkSlowMotionProducer(prod, element);
+ if (prod == NULL || !prod->is_valid()) {
+ mlt_service_unlock(service.get_service());
+ return false;
+ }
+ Mlt::Producer *clip2 = prod->cut(info.cropStart.frames(m_fps), (info.cropDuration + info.cropStart).frames(m_fps));
+ trackPlaylist.insert_at(info.startPos.frames(m_fps), clip2, 1);
+ delete clip2;
+
+
+ //if (mltInsertClip(info, element, prod) == -1) return false;
if (!filtersList.isEmpty()) {
clipIndex = trackPlaylist.get_clip_index_at(startPos);
Mlt::Producer *destclip = trackPlaylist.get_clip(clipIndex);
for (int i = 0; i < filtersList.count(); i++)
destService.attach(*(filtersList.at(i)));
}
+ mlt_service_unlock(service.get_service());
return true;
}
resource = mlt_properties_get(properties, "mlt_service");
}
} else {
- int trackNb = tractor.count();
- while (trackNb > 1) {
- Mlt::Producer trackProducer(tractor.track(trackNb - 1));
+ for (int trackNb = tractor.count() - 1; trackNb >= 1; --trackNb) {
+ Mlt::Producer trackProducer(tractor.track(trackNb));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
-
//int clipNb = trackPlaylist.count();
- insertPos = trackClipStartList.value(trackNb - 1);
+ insertPos = trackClipStartList.value(trackNb);
if (insertPos != -1) {
insertPos += offset;
}
trackPlaylist.consolidate_blanks(0);
}
- trackNb--;
}
// now move transitions
mlt_service serv = m_mltProducer->parent().get_service();
}
}
-int Render::mltChangeClipSpeed(ItemInfo info, double speed, double oldspeed, int strobe, Mlt::Producer *prod)
+int Render::mltChangeClipSpeed(ItemInfo info, ItemInfo speedIndependantInfo, double speed, double /*oldspeed*/, int strobe, Mlt::Producer *prod)
{
m_isBlocked = true;
int newLength = 0;
delete original;
return -1;
}
- delete original;
QString serv = clipparent.get("mlt_service");
QString id = clipparent.get("id");
+ if (speed <= 0 && speed > -1) speed = 1.0;
//kDebug() << "CLIP SERVICE: " << serv;
if (serv == "avformat" && (speed != 1.0 || strobe > 1)) {
mlt_service_lock(service.get_service());
tmp = decodedString(producerid);
slowprod->set("id", tmp);
delete[] tmp;
+ // copy producer props
+ double ar = original->parent().get_double("force_aspect_ratio");
+ if (ar != 0.0) slowprod->set("force_aspect_ratio", ar);
+ double fps = original->parent().get_double("force_fps");
+ if (fps != 0.0) slowprod->set("force_fps", fps);
+ int threads = original->parent().get_int("threads");
+ if (threads != 0) slowprod->set("threads", threads);
+ if (original->parent().get("force_progressive"))
+ slowprod->set("force_progressive", original->parent().get_int("force_progressive"));
+ int ix = original->parent().get_int("video_index");
+ if (ix != 0) slowprod->set("video_index", ix);
m_slowmotionProducers.insert(url, slowprod);
}
Mlt::Producer *clip = trackPlaylist.replace_with_blank(clipIndex);
int blankEnd = trackPlaylist.clip_start(clipIndex) + trackPlaylist.clip_length(clipIndex);
Mlt::Producer *cut;
- GenTime duration = info.cropDuration;
- int originalStart = (int)(info.originalcropStart.frames(m_fps));
- if (clipIndex + 1 < trackPlaylist.count() && (info.startPos + info.cropDuration).frames(m_fps) > blankEnd) {
+ int originalStart = (int)(speedIndependantInfo.cropStart.frames(m_fps));
+ if (clipIndex + 1 < trackPlaylist.count() && (info.startPos + speedIndependantInfo.cropDuration).frames(m_fps) > blankEnd) {
GenTime maxLength = GenTime(blankEnd, m_fps) - info.startPos;
cut = prod->cut(originalStart, (int)(originalStart + maxLength.frames(m_fps) - 1));
- } else cut = prod->cut(originalStart, (int)(originalStart + info.cropDuration.frames(m_fps)) - 1);
+ } else cut = prod->cut(originalStart, (int)(originalStart + speedIndependantInfo.cropDuration.frames(m_fps)) - 1);
// move all effects to the correct producer
mltPasteEffects(clip, cut);
tmp = decodedString(producerid);
slowprod->set("id", tmp);
delete[] tmp;
+ // copy producer props
+ double ar = original->parent().get_double("force_aspect_ratio");
+ if (ar != 0.0) slowprod->set("force_aspect_ratio", ar);
+ double fps = original->parent().get_double("force_fps");
+ if (fps != 0.0) slowprod->set("force_fps", fps);
+ if (original->parent().get("force_progressive"))
+ slowprod->set("force_progressive", original->parent().get_int("force_progressive"));
+ int threads = original->parent().get_int("threads");
+ if (threads != 0) slowprod->set("threads", threads);
+ int ix = original->parent().get_int("video_index");
+ if (ix != 0) slowprod->set("video_index", ix);
m_slowmotionProducers.insert(url, slowprod);
}
Mlt::Producer *clip = trackPlaylist.replace_with_blank(clipIndex);
trackPlaylist.consolidate_blanks(0);
- GenTime duration = info.cropDuration / speed;
- int originalStart = (int)(info.originalcropStart.frames(m_fps) / speed);
+ GenTime duration = speedIndependantInfo.cropDuration / speed;
+ int originalStart = (int)(speedIndependantInfo.cropStart.frames(m_fps) / speed);
// Check that the blank space is long enough for our new duration
clipIndex = trackPlaylist.get_clip_index_at(startPos);
mlt_service_unlock(service.get_service());
}
-
+ delete original;
if (clipIndex + 1 == trackPlaylist.count()) mltCheckLength(&tractor);
m_isBlocked = false;
return newLength;
}
+bool Render::mltRemoveTrackEffect(int track, QString index, bool updateIndex)
+{
+ kDebug() << "REMOVE TK EFF: " << track << ", IX: " << index;
+ Mlt::Service service(m_mltProducer->parent().get_service());
+ bool success = false;
+ Mlt::Tractor tractor(service);
+ Mlt::Producer trackProducer(tractor.track(track));
+ Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
+ Mlt::Service clipService(trackPlaylist.get_service());
+
+ m_isBlocked = true;
+ int ct = 0;
+ Mlt::Filter *filter = clipService.filter(ct);
+ while (filter) {
+ if ((index == "-1" && strcmp(filter->get("kdenlive_id"), "")) || filter->get("kdenlive_ix") == index) {
+ if (clipService.detach(*filter) == 0) success = true;
+ } else if (updateIndex) {
+ // Adjust the other effects index
+ if (QString(filter->get("kdenlive_ix")).toInt() > index.toInt()) filter->set("kdenlive_ix", QString(filter->get("kdenlive_ix")).toInt() - 1);
+ ct++;
+ } else ct++;
+ filter = clipService.filter(ct);
+ }
+ m_isBlocked = false;
+ refresh();
+ return success;
+}
+
bool Render::mltRemoveEffect(int track, GenTime position, QString index, bool updateIndex, bool doRefresh)
{
+ if (position < GenTime()) {
+ // Remove track effect
+ return mltRemoveTrackEffect(track, index, updateIndex);
+ }
Mlt::Service service(m_mltProducer->parent().get_service());
bool success = false;
Mlt::Tractor tractor(service);
Mlt::Producer trackProducer(tractor.track(track));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
- //int clipIndex = trackPlaylist.get_clip_index_at(position.frames(m_fps));
- Mlt::Producer *clip = trackPlaylist.get_clip_at((int) position.frames(m_fps));
+
+ int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
+ Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
if (!clip) {
kDebug() << " / / / CANNOT FIND CLIP TO REMOVE EFFECT";
- return success;
+ return false;
}
+
Mlt::Service clipService(clip->get_service());
+ int duration = clip->get_playtime();
+ if (doRefresh) {
+ // Check if clip is visible in monitor
+ int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
+ if (diff < 0 || diff > duration) doRefresh = false;
+ }
delete clip;
+
// if (tag.startsWith("ladspa")) tag = "ladspa";
m_isBlocked = true;
int ct = 0;
return success;
}
+bool Render::mltAddTrackEffect(int track, EffectsParameterList params)
+{
+ Mlt::Service service(m_mltProducer->parent().get_service());
+ Mlt::Tractor tractor(service);
+ Mlt::Producer trackProducer(tractor.track(track));
+ Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
+ Mlt::Service trackService(trackProducer.get_service()); //trackPlaylist
+ return mltAddEffect(trackService, params, 15000, true);
+}
+
bool Render::mltAddEffect(int track, GenTime position, EffectsParameterList params, bool doRefresh)
{
Mlt::Producer trackProducer(tractor.track(track));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
- Mlt::Producer *clip = trackPlaylist.get_clip_at((int) position.frames(m_fps));
+ int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
+ Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
if (!clip) {
return false;
}
+
Mlt::Service clipService(clip->get_service());
m_isBlocked = true;
int duration = clip->get_playtime();
- bool updateIndex = false;
+ if (doRefresh) {
+ // Check if clip is visible in monitor
+ int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
+ if (diff < 0 || diff > duration) doRefresh = false;
+ }
delete clip;
+ return mltAddEffect(clipService, params, duration, doRefresh);
+}
+bool Render::mltAddEffect(Mlt::Service service, EffectsParameterList params, int duration, bool doRefresh)
+{
+ bool updateIndex = false;
const int filter_ix = params.paramValue("kdenlive_ix").toInt();
+ const QString region = params.paramValue("region");
int ct = 0;
- Mlt::Filter *filter = clipService.filter(ct);
+ Mlt::Filter *filter = service.filter(ct);
while (filter) {
if (QString(filter->get("kdenlive_ix")).toInt() == filter_ix) {
// A filter at that position already existed, so we will increase all indexes later
break;
}
ct++;
- filter = clipService.filter(ct);
+ filter = service.filter(ct);
}
if (params.paramValue("id") == "speed") {
// special case, speed effect is not really inserted, we just update the other effects index (kdenlive_ix)
ct = 0;
- filter = clipService.filter(ct);
+ filter = service.filter(ct);
while (filter) {
if (QString(filter->get("kdenlive_ix")).toInt() >= filter_ix) {
if (updateIndex) filter->set("kdenlive_ix", QString(filter->get("kdenlive_ix")).toInt() + 1);
}
ct++;
- filter = clipService.filter(ct);
+ filter = service.filter(ct);
}
m_isBlocked = false;
if (doRefresh) refresh();
// temporarily remove all effects after insert point
QList <Mlt::Filter *> filtersList;
ct = 0;
- filter = clipService.filter(ct);
+ filter = service.filter(ct);
while (filter) {
if (QString(filter->get("kdenlive_ix")).toInt() >= filter_ix) {
filtersList.append(filter);
- clipService.detach(*filter);
+ service.detach(*filter);
} else ct++;
- filter = clipService.filter(ct);
+ filter = service.filter(ct);
}
// create filter
QString tag = params.paramValue("tag");
- kDebug() << " / / INSERTING EFFECT: " << tag;
+ kDebug() << " / / INSERTING EFFECT: " << tag << ", REGI: " << region;
if (tag.startsWith("ladspa")) tag = "ladspa";
char *filterTag = decodedString(tag);
char *filterId = decodedString(params.paramValue("id"));
params.removeParam("max");
params.removeParam("factor");
int offset = 0;
- for (int i = 0; i < keyFrames.size() - 1; ++i) {
+ // Special case, only one keyframe, means we want a constant value
+ if (keyFrames.count() == 1) {
Mlt::Filter *filter = new Mlt::Filter(*m_mltProfile, filterTag);
if (filter && filter->is_valid()) {
filter->set("kdenlive_id", filterId);
- int x1 = keyFrames.at(i).section(':', 0, 0).toInt() + offset;
- double y1 = keyFrames.at(i).section(':', 1, 1).toDouble();
- int x2 = keyFrames.at(i + 1).section(':', 0, 0).toInt();
- double y2 = keyFrames.at(i + 1).section(':', 1, 1).toDouble();
- if (x2 == -1) x2 = duration;
-
+ int x1 = keyFrames.at(0).section(':', 0, 0).toInt();
+ double y1 = keyFrames.at(0).section(':', 1, 1).toDouble();
for (int j = 0; j < params.count(); j++) {
char *name = decodedString(params.at(j).name());
char *value = decodedString(params.at(j).value());
delete[] name;
delete[] value;
}
-
filter->set("in", x1);
- filter->set("out", x2);
//kDebug() << "// ADDING KEYFRAME vals: " << min<<" / "<<max<<", "<<y1<<", factor: "<<factor;
filter->set(starttag, QString::number((min + y1) / factor).toUtf8().data());
- filter->set(endtag, QString::number((min + y2) / factor).toUtf8().data());
- clipService.attach(*filter);
- offset = 1;
+ service.attach(*filter);
+ }
+ } else for (int i = 0; i < keyFrames.size() - 1; ++i) {
+ Mlt::Filter *filter = new Mlt::Filter(*m_mltProfile, filterTag);
+ if (filter && filter->is_valid()) {
+ filter->set("kdenlive_id", filterId);
+ int x1 = keyFrames.at(i).section(':', 0, 0).toInt() + offset;
+ double y1 = keyFrames.at(i).section(':', 1, 1).toDouble();
+ int x2 = keyFrames.at(i + 1).section(':', 0, 0).toInt();
+ double y2 = keyFrames.at(i + 1).section(':', 1, 1).toDouble();
+ if (x2 == -1) x2 = duration;
+
+ for (int j = 0; j < params.count(); j++) {
+ char *name = decodedString(params.at(j).name());
+ char *value = decodedString(params.at(j).value());
+ filter->set(name, value);
+ delete[] name;
+ delete[] value;
+ }
+
+ filter->set("in", x1);
+ filter->set("out", x2);
+ //kDebug() << "// ADDING KEYFRAME vals: " << min<<" / "<<max<<", "<<y1<<", factor: "<<factor;
+ filter->set(starttag, QString::number((min + y1) / factor).toUtf8().data());
+ filter->set(endtag, QString::number((min + y2) / factor).toUtf8().data());
+ service.attach(*filter);
+ offset = 1;
+ }
}
- }
delete[] starttag;
delete[] endtag;
} else {
- Mlt::Filter *filter = new Mlt::Filter(*m_mltProfile, filterTag);
- if (filter && filter->is_valid())
+ Mlt::Filter *filter;
+ QString prefix;
+ if (!region.isEmpty()) {
+ filter = new Mlt::Filter(*m_mltProfile, "region");
+ } else filter = new Mlt::Filter(*m_mltProfile, filterTag);
+ if (filter && filter->is_valid()) {
filter->set("kdenlive_id", filterId);
- else {
+ if (!region.isEmpty()) {
+ char *tmp = decodedString(region);
+ filter->set("resource", tmp);
+ tmp = decodedString(params.paramValue("kdenlive_ix"));
+ filter->set("kdenlive_ix", tmp);
+ filter->set("filter0", filterTag);
+ prefix = "filter0.";
+ delete[] tmp;
+ params.removeParam("id");
+ params.removeParam("region");
+ params.removeParam("kdenlive_ix");
+ }
+ } else {
kDebug() << "filter is NULL";
m_isBlocked = false;
return false;
}
-
params.removeParam("kdenlive_id");
for (int j = 0; j < params.count(); j++) {
- char *name = decodedString(params.at(j).name());
+ char *name = decodedString(prefix + params.at(j).name());
char *value = decodedString(params.at(j).value());
filter->set(name, value);
delete[] name;
params.removeParam("id");
params.removeParam("kdenlive_ix");
params.removeParam("tag");
- params.removeParam("disabled");
+ params.removeParam("disable");
+ params.removeParam("region");
for (int j = 0; j < params.count(); j++) {
effectArgs.append(' ' + params.at(j).value());
delete[] value;
}
+ if (params.paramValue("id") == "pan_zoom") {
+ filter->set_in_and_out(service.get_int("in"), service.get_int("out") + 1);
+ }
// attach filter to the clip
- clipService.attach(*filter);
+ service.attach(*filter);
}
delete[] filterId;
delete[] filterTag;
Mlt::Filter *filter = filtersList.at(i);
if (updateIndex)
filter->set("kdenlive_ix", QString(filter->get("kdenlive_ix")).toInt() + 1);
- clipService.attach(*filter);
+ service.attach(*filter);
}
m_isBlocked = false;
if (doRefresh) refresh();
return true;
}
+bool Render::mltEditTrackEffect(int track, EffectsParameterList params)
+{
+ kDebug() << "EDIT TK, FILTER: " << track;
+ Mlt::Service service(m_mltProducer->parent().get_service());
+ Mlt::Tractor tractor(service);
+ Mlt::Producer trackProducer(tractor.track(track));
+ Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
+ Mlt::Service clipService(trackPlaylist.get_service());
+ m_isBlocked = true;
+ int ct = 0;
+ QString index = params.paramValue("kdenlive_ix");
+ QString tag = params.paramValue("tag");
+
+ Mlt::Filter *filter = clipService.filter(ct);
+ while (filter) {
+ if (filter->get("kdenlive_ix") == index) {
+ break;
+ }
+ ct++;
+ filter = clipService.filter(ct);
+ }
+
+ if (!filter) {
+ kDebug() << "WARINIG, FILTER FOR EDITING NOT FOUND, ADDING IT! " << index << ", " << tag;
+ // filter was not found, it was probably a disabled filter, so add it to the correct place...
+
+ bool success = false;//mltAddTrackEffect(track, params);
+ m_isBlocked = false;
+ return success;
+ }
+ QString prefix;
+ QString ser = filter->get("mlt_service");
+ if (ser == "region") prefix = "filter0.";
+ mlt_service_lock(service.get_service());
+ for (int j = 0; j < params.count(); j++) {
+ char *name = decodedString(prefix + params.at(j).name());
+ char *value = decodedString(params.at(j).value());
+ filter->set(name, value);
+ delete[] name;
+ delete[] value;
+ }
+ mlt_service_unlock(service.get_service());
+
+ m_isBlocked = false;
+ refresh();
+ return true;
+
+}
+
bool Render::mltEditEffect(int track, GenTime position, EffectsParameterList params)
{
QString index = params.paramValue("kdenlive_ix");
QString tag = params.paramValue("tag");
- if (!params.paramValue("keyframes").isEmpty() || /*it.key().startsWith("#") || */tag.startsWith("ladspa") || tag == "sox" || tag == "autotrack_rectangle") {
+ if (!params.paramValue("keyframes").isEmpty() || /*it.key().startsWith("#") || */tag.startsWith("ladspa") || tag == "sox" || tag == "autotrack_rectangle" || params.hasParam("region")) {
// This is a keyframe effect, to edit it, we remove it and re-add it.
mltRemoveEffect(track, position, index, false);
bool success = mltAddEffect(track, position, params);
return success;
}
-
+ if (position < GenTime()) {
+ return mltEditTrackEffect(track, params);
+ }
// find filter
Mlt::Service service(m_mltProducer->parent().get_service());
-
Mlt::Tractor tractor(service);
Mlt::Producer trackProducer(tractor.track(track));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
- //int clipIndex = trackPlaylist.get_clip_index_at(position.frames(m_fps));
- Mlt::Producer *clip = trackPlaylist.get_clip_at((int) position.frames(m_fps));
+
+ int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
+ Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
if (!clip) {
kDebug() << "WARINIG, CANNOT FIND CLIP ON track: " << track << ", AT POS: " << position.frames(m_fps);
return false;
}
+
Mlt::Service clipService(clip->get_service());
+ int duration = clip->get_playtime();
+ bool doRefresh = true;
+ // Check if clip is visible in monitor
+ int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
+ if (diff < 0 || diff > duration) doRefresh = false;
delete clip;
m_isBlocked = true;
int ct = 0;
- Mlt::Filter *filter = clipService.filter(ct);
-
- /*
- kDebug() << "EDITING FILTER: "<<index <<", "<<tag;
+ /* kDebug() << "EDITING FILTER: "<<index <<", "<<tag;
kDebug() << "EFFect stack: ++++++++++++++++++++++++++";
while (filter) {
kDebug() << "Filter: "<< filter->get("kdenlive_id") <<", IX: "<<filter->get("kdenlive_ix");
filter = clipService.filter(ct);
}
kDebug() << "++++++++++++++++++++++++++";
- */
ct = 0;
- filter = clipService.filter(ct);
+ filter = clipService.filter(ct); */
+
+ Mlt::Filter *filter = clipService.filter(ct);
while (filter) {
if (filter->get("kdenlive_ix") == index) {
break;
m_isBlocked = false;
return success;
}
+ QString prefix;
+ QString ser = filter->get("mlt_service");
+ if (ser == "region") prefix = "filter0.";
mlt_service_lock(service.get_service());
for (int j = 0; j < params.count(); j++) {
- char *name = decodedString(params.at(j).name());
+ char *name = decodedString(prefix + params.at(j).name());
char *value = decodedString(params.at(j).value());
filter->set(name, value);
delete[] name;
mlt_service_unlock(service.get_service());
m_isBlocked = false;
- refresh();
+ if (doRefresh) refresh();
return true;
}
void Render::mltUpdateEffectPosition(int track, GenTime position, int oldPos, int newPos)
{
-
- kDebug() << "MOVING EFFECT FROM " << oldPos << ", TO: " << newPos;
Mlt::Service service(m_mltProducer->parent().get_service());
-
Mlt::Tractor tractor(service);
Mlt::Producer trackProducer(tractor.track(track));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
- //int clipIndex = trackPlaylist.get_clip_index_at(position.frames(m_fps));
- Mlt::Producer *clip = trackPlaylist.get_clip_at((int) position.frames(m_fps));
+
+ int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
+ Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
if (!clip) {
kDebug() << "WARINIG, CANNOT FIND CLIP ON track: " << track << ", AT POS: " << position.frames(m_fps);
return;
}
+
Mlt::Service clipService(clip->get_service());
+ int duration = clip->get_playtime();
+ bool doRefresh = true;
+ // Check if clip is visible in monitor
+ int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
+ if (diff < 0 || diff > duration) doRefresh = false;
delete clip;
+
m_isBlocked = true;
int ct = 0;
Mlt::Filter *filter = clipService.filter(ct);
}
m_isBlocked = false;
- refresh();
+ if (doRefresh) refresh();
}
void Render::mltMoveEffect(int track, GenTime position, int oldPos, int newPos)
{
-
- kDebug() << "MOVING EFFECT FROM " << oldPos << ", TO: " << newPos;
+ if (position < GenTime()) {
+ mltMoveTrackEffect(track, oldPos, newPos);
+ return;
+ }
Mlt::Service service(m_mltProducer->parent().get_service());
-
Mlt::Tractor tractor(service);
Mlt::Producer trackProducer(tractor.track(track));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
- //int clipIndex = trackPlaylist.get_clip_index_at(position.frames(m_fps));
- Mlt::Producer *clip = trackPlaylist.get_clip_at((int) position.frames(m_fps));
+
+ int clipIndex = trackPlaylist.get_clip_index_at((int) position.frames(m_fps));
+ Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
if (!clip) {
kDebug() << "WARINIG, CANNOT FIND CLIP ON track: " << track << ", AT POS: " << position.frames(m_fps);
return;
}
+
Mlt::Service clipService(clip->get_service());
+ int duration = clip->get_playtime();
+ bool doRefresh = true;
+ // Check if clip is visible in monitor
+ int diff = trackPlaylist.clip_start(clipIndex) + duration - m_mltProducer->position();
+ if (diff < 0 || diff > duration) doRefresh = false;
delete clip;
+
m_isBlocked = true;
int ct = 0;
QList <Mlt::Filter *> filtersList;
clipService.attach(*(filtersList.at(i)));
}
+ m_isBlocked = false;
+ if (doRefresh) refresh();
+}
+
+void Render::mltMoveTrackEffect(int track, int oldPos, int newPos)
+{
+ Mlt::Service service(m_mltProducer->parent().get_service());
+ Mlt::Tractor tractor(service);
+ Mlt::Producer trackProducer(tractor.track(track));
+ Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
+
+ Mlt::Service clipService(trackPlaylist.get_service());
+
+ m_isBlocked = true;
+ int ct = 0;
+ QList <Mlt::Filter *> filtersList;
+ Mlt::Filter *filter = clipService.filter(ct);
+ bool found = false;
+ if (newPos > oldPos) {
+ while (filter) {
+ if (!found && QString(filter->get("kdenlive_ix")).toInt() == oldPos) {
+ filter->set("kdenlive_ix", newPos);
+ filtersList.append(filter);
+ clipService.detach(*filter);
+ filter = clipService.filter(ct);
+ while (filter && QString(filter->get("kdenlive_ix")).toInt() <= newPos) {
+ filter->set("kdenlive_ix", QString(filter->get("kdenlive_ix")).toInt() - 1);
+ ct++;
+ filter = clipService.filter(ct);
+ }
+ found = true;
+ }
+ if (filter && QString(filter->get("kdenlive_ix")).toInt() > newPos) {
+ filtersList.append(filter);
+ clipService.detach(*filter);
+ } else ct++;
+ filter = clipService.filter(ct);
+ }
+ } else {
+ while (filter) {
+ if (QString(filter->get("kdenlive_ix")).toInt() == oldPos) {
+ filter->set("kdenlive_ix", newPos);
+ filtersList.append(filter);
+ clipService.detach(*filter);
+ } else ct++;
+ filter = clipService.filter(ct);
+ }
+
+ ct = 0;
+ filter = clipService.filter(ct);
+ while (filter) {
+ int pos = QString(filter->get("kdenlive_ix")).toInt();
+ if (pos >= newPos) {
+ if (pos < oldPos) filter->set("kdenlive_ix", pos + 1);
+ filtersList.append(filter);
+ clipService.detach(*filter);
+ } else ct++;
+ filter = clipService.filter(ct);
+ }
+ }
+
+ for (int i = 0; i < filtersList.count(); i++) {
+ clipService.attach(*(filtersList.at(i)));
+ }
m_isBlocked = false;
refresh();
}
Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
int previousStart = clip->get_in();
int newDuration = (int) clipDuration.frames(m_fps) - 1;
+ int currentOut = (int)(info.cropStart + info.cropDuration).frames(m_fps) - 1;
int diff = newDuration - (trackPlaylist.clip_length(clipIndex) - 1);
- if (newDuration > clip->get_length()) {
- clip->parent().set("length", newDuration + 1);
- clip->parent().set("out", newDuration);
- clip->set("length", newDuration + 1);
+ if (currentOut > clip->get_length()) {
+ clip->parent().set("length", currentOut + 1);
+ clip->parent().set("out", currentOut);
+ clip->set("length", currentOut + 1);
}
- if (newDuration > clip->get_out()) {
+ /*if (newDuration > clip->get_out()) {
clip->parent().set_in_and_out(0, newDuration + 1);
clip->set_in_and_out(0, newDuration + 1);
- }
+ }*/
delete clip;
trackPlaylist.resize_clip(clipIndex, previousStart, newDuration + previousStart);
trackPlaylist.consolidate_blanks(0);
kDebug() << "/// RESIZE ERROR, NXT CLIP IS NOT BLK: " << clipIndex;
}
}
- } else trackPlaylist.insert_blank(clipIndex, 0 - diff - 1);
+ } else if (clipIndex != trackPlaylist.count()) trackPlaylist.insert_blank(clipIndex, 0 - diff - 1);
trackPlaylist.consolidate_blanks(0);
mlt_service_unlock(service.get_service());
return false;
}
int previousStart = clip->get_in();
+ int previousOut = clip->get_out();
delete clip;
- int previousDuration = trackPlaylist.clip_length(clipIndex) - 1;
m_isBlocked = true;
- trackPlaylist.resize_clip(clipIndex, previousStart + frameOffset, previousStart + previousDuration + frameOffset);
+ trackPlaylist.resize_clip(clipIndex, previousStart + frameOffset, previousOut + frameOffset);
m_isBlocked = false;
mlt_service_unlock(service.get_service());
m_mltConsumer->set("refresh", 1);
mlt_service_lock(service.get_service());
int clipIndex = trackPlaylist.get_clip_index_at(info.startPos.frames(m_fps));
Mlt::Producer *clip = trackPlaylist.get_clip(clipIndex);
- if (clip == NULL) {
+ if (clip == NULL || clip->is_blank()) {
kDebug() << "//////// ERROR RSIZING NULL CLIP!!!!!!!!!!!";
mlt_service_unlock(service.get_service());
return false;
}
int previousStart = clip->get_in();
+ int previousOut = clip->get_out();
delete clip;
- int previousDuration = trackPlaylist.clip_length(clipIndex) - 1;
m_isBlocked = true;
- kDebug() << "RESIZE, old start: " << previousStart << ", PREV DUR: " << previousDuration << ", DIFF: " << moveFrame;
- trackPlaylist.resize_clip(clipIndex, previousStart + moveFrame, previousStart + previousDuration);
+ previousStart += moveFrame;
+ if (previousStart < 0) {
+ // special case, in point becoming negative (resizing images)
+ previousOut -= previousStart;
+ previousStart = 0;
+ }
+ // kDebug() << "RESIZE, new start: " << previousStart << ", " << previousOut;
+ trackPlaylist.resize_clip(clipIndex, previousStart, previousOut);
if (moveFrame > 0) trackPlaylist.insert_blank(clipIndex, moveFrame - 1);
else {
//int midpos = info.startPos.frames(m_fps) + moveFrame - 1;
int blankIndex = clipIndex - 1;
int blankLength = trackPlaylist.clip_length(blankIndex);
- kDebug() << " + resizing blank length " << blankLength << ", SIZE DIFF: " << moveFrame;
+ // kDebug() << " + resizing blank length " << blankLength << ", SIZE DIFF: " << moveFrame;
if (! trackPlaylist.is_blank(blankIndex)) {
kDebug() << "WARNING, CLIP TO RESIZE IS NOT BLANK";
}
return true;
}
-bool Render::mltMoveClip(int startTrack, int endTrack, GenTime moveStart, GenTime moveEnd, Mlt::Producer *prod)
+bool Render::mltMoveClip(int startTrack, int endTrack, GenTime moveStart, GenTime moveEnd, Mlt::Producer *prod, bool overwrite, bool insert)
{
- return mltMoveClip(startTrack, endTrack, (int) moveStart.frames(m_fps), (int) moveEnd.frames(m_fps), prod);
+ return mltMoveClip(startTrack, endTrack, (int) moveStart.frames(m_fps), (int) moveEnd.frames(m_fps), prod, overwrite, insert);
}
kWarning() << "// TRACTOR PROBLEM";
return false;
}
- mlt_service_lock(m_mltConsumer->get_service());
-
+ mlt_service_lock(service.get_service());
Mlt::Tractor tractor(service);
Mlt::Producer trackProducer(tractor.track(track));
Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
if (clipProducer == NULL || clipProducer->is_blank()) {
kDebug() << "// ERROR UPDATING CLIP PROD";
delete clipProducer;
- mlt_service_unlock(m_mltConsumer->get_service());
+ mlt_service_unlock(service.get_service());
m_isBlocked--;
return false;
}
Mlt::Producer *clip = prod->cut(clipProducer->get_in(), clipProducer->get_out());
- if (!clip) return false;
+ if (!clip || !clip->is_valid()) {
+ if (clip) delete clip;
+ delete clipProducer;
+ mlt_service_unlock(service.get_service());
+ m_isBlocked--;
+ return false;
+ }
// move all effects to the correct producer
mltPasteEffects(clipProducer, clip);
trackPlaylist.insert_at(pos, clip, 1);
delete clip;
delete clipProducer;
- mlt_service_unlock(m_mltConsumer->get_service());
+ mlt_service_unlock(service.get_service());
m_isBlocked--;
return true;
}
-bool Render::mltMoveClip(int startTrack, int endTrack, int moveStart, int moveEnd, Mlt::Producer *prod)
+bool Render::mltMoveClip(int startTrack, int endTrack, int moveStart, int moveEnd, Mlt::Producer *prod, bool overwrite, bool /*insert*/)
{
m_isBlocked++;
bool checkLength = false;
if (endTrack == startTrack) {
Mlt::Producer *clipProducer = trackPlaylist.replace_with_blank(clipIndex);
- if (!trackPlaylist.is_blank_at(moveEnd) || !clipProducer || clipProducer->is_blank()) {
+ if ((!overwrite && !trackPlaylist.is_blank_at(moveEnd)) || !clipProducer || !clipProducer->is_valid() || clipProducer->is_blank()) {
// error, destination is not empty
- if (!trackPlaylist.is_blank_at(moveEnd)) trackPlaylist.insert_at(moveStart, clipProducer, 1);
- if (clipProducer) delete clipProducer;
+ if (clipProducer) {
+ if (!trackPlaylist.is_blank_at(moveEnd) && clipProducer->is_valid()) trackPlaylist.insert_at(moveStart, clipProducer, 1);
+ delete clipProducer;
+ }
//int ix = trackPlaylist.get_clip_index_at(moveEnd);
kDebug() << "// ERROR MOVING CLIP TO : " << moveEnd;
mlt_service_unlock(service.get_service());
return false;
} else {
trackPlaylist.consolidate_blanks(0);
+ if (overwrite) {
+ trackPlaylist.remove_region(moveEnd, clipProducer->get_playtime());
+ int clipIndex = trackPlaylist.get_clip_index_at(moveEnd);
+ trackPlaylist.insert_blank(clipIndex, clipProducer->get_playtime() - 1);
+ }
int newIndex = trackPlaylist.insert_at(moveEnd, clipProducer, 1);
+ trackPlaylist.consolidate_blanks(1);
delete clipProducer;
/*if (QString(clipProducer.parent().get("transparency")).toInt() == 1) {
mltMoveTransparency(moveStart, moveEnd, startTrack, endTrack, QString(clipProducer.parent().get("id")).toInt());
} else {
Mlt::Producer destTrackProducer(tractor.track(endTrack));
Mlt::Playlist destTrackPlaylist((mlt_playlist) destTrackProducer.get_service());
- if (!destTrackPlaylist.is_blank_at(moveEnd)) {
+ if (!overwrite && !destTrackPlaylist.is_blank_at(moveEnd)) {
// error, destination is not empty
mlt_service_unlock(service.get_service());
m_isBlocked--;
// move all effects to the correct producer
mltPasteEffects(clipProducer, clip);
+ if (overwrite) {
+ destTrackPlaylist.remove_region(moveEnd, clip->get_playtime());
+ int clipIndex = destTrackPlaylist.get_clip_index_at(moveEnd);
+ destTrackPlaylist.insert_blank(clipIndex, clip->get_playtime() - 1);
+ }
+
int newIndex = destTrackPlaylist.insert_at(moveEnd, clip, 1);
if (clip == clipProducer) {
return true;
}
+
+QList <int> Render::checkTrackSequence(int track)
+{
+ QList <int> list;
+ Mlt::Service service(m_mltProducer->parent().get_service());
+ if (service.type() != tractor_type) {
+ kWarning() << "// TRACTOR PROBLEM";
+ return list;
+ }
+ Mlt::Tractor tractor(service);
+ mlt_service_lock(service.get_service());
+ Mlt::Producer trackProducer(tractor.track(track));
+ Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
+ int clipNb = trackPlaylist.count();
+ //kDebug() << "// PARSING SCENE TRACK: " << t << ", CLIPS: " << clipNb;
+ for (int i = 0; i < clipNb; i++) {
+ Mlt::Producer *c = trackPlaylist.get_clip(i);
+ int pos = trackPlaylist.clip_start(i);
+ if (!list.contains(pos)) list.append(pos);
+ pos += c->get_playtime();
+ if (!list.contains(pos)) list.append(pos);
+ delete c;
+ }
+ return list;
+}
+
bool Render::mltMoveTransition(QString type, int startTrack, int newTrack, int newTransitionTrack, GenTime oldIn, GenTime oldOut, GenTime newIn, GenTime newOut)
{
int new_in = (int)newIn.frames(m_fps);
int new_out = (int)newOut.frames(m_fps) - 1;
if (new_in >= new_out) return false;
+ int old_in = (int)oldIn.frames(m_fps);
+ int old_out = (int)oldOut.frames(m_fps) - 1;
- mlt_service serv = m_mltProducer->parent().get_service();
- m_isBlocked++;
- mlt_service_lock(serv);
- //m_mltConsumer->set("refresh", 0);
+ Mlt::Service service(m_mltProducer->parent().get_service());
+ Mlt::Tractor tractor(service);
+ Mlt::Field *field = tractor.field();
+ bool doRefresh = true;
+ // Check if clip is visible in monitor
+ int diff = old_out - m_mltProducer->position();
+ if (diff < 0 || diff > old_out - old_in) doRefresh = false;
+ if (doRefresh) {
+ diff = new_out - m_mltProducer->position();
+ if (diff < 0 || diff > new_out - new_in) doRefresh = false;
+ }
- mlt_service nextservice = mlt_service_get_producer(serv);
+ m_isBlocked++;
+ mlt_service_lock(service.get_service());
+
+ mlt_service nextservice = mlt_service_get_producer(service.get_service());
mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
QString mlt_type = mlt_properties_get(properties, "mlt_type");
QString resource = mlt_properties_get(properties, "mlt_service");
- int old_pos = (int)(oldIn.frames(m_fps) + oldOut.frames(m_fps)) / 2;
+ int old_pos = (int)(old_in + old_out) / 2;
+ bool found = false;
while (mlt_type == "transition") {
- mlt_transition tr = (mlt_transition) nextservice;
- int currentTrack = mlt_transition_get_b_track(tr);
- int currentIn = (int) mlt_transition_get_in(tr);
- int currentOut = (int) mlt_transition_get_out(tr);
+ Mlt::Transition transition((mlt_transition) nextservice);
+ int currentTrack = transition.get_b_track();
+ int currentIn = (int) transition.get_in();
+ int currentOut = (int) transition.get_out();
if (resource == type && startTrack == currentTrack && currentIn <= old_pos && currentOut >= old_pos) {
- mlt_transition_set_in_and_out(tr, new_in, new_out);
+ found = true;
if (newTrack - startTrack != 0) {
- //kDebug() << "///// TRANSITION CHANGE TRACK. CUrrent (b): " << currentTrack << 'x' << mlt_transition_get_a_track(tr) << ", NEw: " << newTrack << 'x' << newTransitionTrack;
-
- mlt_properties properties = MLT_TRANSITION_PROPERTIES(tr);
- mlt_properties_set_int(properties, "a_track", newTransitionTrack);
- mlt_properties_set_int(properties, "b_track", newTrack);
- //kDebug() << "set new start & end :" << new_in << new_out<< "TR OFFSET: "<<trackOffset<<", TRACKS: "<<mlt_transition_get_a_track(tr)<<'x'<<mlt_transition_get_b_track(tr);
- }
+ Mlt::Properties trans_props(transition.get_properties());
+ char *tmp = decodedString(transition.get("mlt_service"));
+ Mlt::Transition new_transition(*m_mltProfile, tmp);
+ delete[] tmp;
+ Mlt::Properties new_trans_props(new_transition.get_properties());
+ new_trans_props.inherit(trans_props);
+ new_transition.set_in_and_out(new_in, new_out);
+ field->disconnect_service(transition);
+ mltPlantTransition(field, new_transition, newTransitionTrack, newTrack);
+ //field->plant_transition(new_transition, newTransitionTrack, newTrack);
+ } else transition.set_in_and_out(new_in, new_out);
break;
}
nextservice = mlt_service_producer(nextservice);
mlt_type = mlt_properties_get(properties, "mlt_type");
resource = mlt_properties_get(properties, "mlt_service");
}
- mlt_service_unlock(serv);
+ mlt_service_unlock(service.get_service());
m_isBlocked--;
- refresh();
+ if (doRefresh) refresh();
//if (m_isBlocked == 0) m_mltConsumer->set("refresh", 1);
- return true;
+ return found;
+}
+
+
+void Render::mltPlantTransition(Mlt::Field *field, Mlt::Transition &tr, int a_track, int b_track)
+{
+ mlt_service nextservice = mlt_service_get_producer(field->get_service());
+ mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
+ QString mlt_type = mlt_properties_get(properties, "mlt_type");
+ QString resource = mlt_properties_get(properties, "mlt_service");
+ QList <Mlt::Transition *> trList;
+
+ while (mlt_type == "transition") {
+ Mlt::Transition transition((mlt_transition) nextservice);
+ int aTrack = transition.get_a_track();
+ int bTrack = transition.get_b_track();
+ if (resource != "mix" && (aTrack < a_track || (aTrack == a_track && bTrack > b_track))) {
+ Mlt::Properties trans_props(transition.get_properties());
+ char *tmp = decodedString(transition.get("mlt_service"));
+ Mlt::Transition *cp = new Mlt::Transition(*m_mltProfile, tmp);
+ delete[] tmp;
+ Mlt::Properties new_trans_props(cp->get_properties());
+ new_trans_props.inherit(trans_props);
+ trList.append(cp);
+ field->disconnect_service(transition);
+ }
+ //else kDebug() << "// FOUND TRANS OK, "<<resource<< ", A_: " << aTrack << ", B_ "<<bTrack;
+
+ nextservice = mlt_service_producer(nextservice);
+ if (nextservice == NULL) break;
+ properties = MLT_SERVICE_PROPERTIES(nextservice);
+ mlt_type = mlt_properties_get(properties, "mlt_type");
+ resource = mlt_properties_get(properties, "mlt_service");
+ }
+
+ field->plant_transition(tr, a_track, b_track);
+
+ // re-add upper transitions
+ for (int i = 0; i < trList.count(); i++) {
+ // kDebug()<< "REPLANT ON TK: "<<trList.at(i)->get_a_track()<<", "<<trList.at(i)->get_b_track();
+ field->plant_transition(*trList.at(i), trList.at(i)->get_a_track(), trList.at(i)->get_b_track());
+ }
}
-void Render::mltUpdateTransition(QString oldTag, QString tag, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml)
+void Render::mltUpdateTransition(QString oldTag, QString tag, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml, bool force)
{
- if (oldTag == tag) mltUpdateTransitionParams(tag, a_track, b_track, in, out, xml);
+ if (oldTag == tag && !force) mltUpdateTransitionParams(tag, a_track, b_track, in, out, xml);
else {
mltDeleteTransition(oldTag, a_track, b_track, in, out, xml, false);
mltAddTransition(tag, a_track, b_track, in, out, xml, false);
}
- refresh();
- //mltSavePlaylist();
+
+ if (m_mltProducer->position() > in.frames(m_fps) && m_mltProducer->position() < out.frames(m_fps)) refresh();
}
void Render::mltUpdateTransitionParams(QString type, int a_track, int b_track, GenTime in, GenTime out, QDomElement xml)
QMap<QString, QString>::Iterator it;
QString key;
mlt_properties transproperties = MLT_TRANSITION_PROPERTIES(tr);
+
+ QString currentId = mlt_properties_get(transproperties, "kdenlive_id");
+ if (currentId != xml.attribute("id")) {
+ // The transition ID is not the same, so reset all properties
+ char *tmp = decodedString(xml.attribute("id"));
+ mlt_properties_set(transproperties, "kdenlive_id", tmp);
+ delete[] tmp;
+ // Cleanup previous properties
+ QStringList permanentProps;
+ permanentProps << "factory" << "kdenlive_id" << "mlt_service" << "mlt_type" << "in";
+ permanentProps << "out" << "a_track" << "b_track";
+ for (int i = 0; i < mlt_properties_count(transproperties); i++) {
+ QString propName = mlt_properties_get_name(transproperties, i);
+ if (!propName.startsWith('_') && ! permanentProps.contains(propName)) {
+ tmp = decodedString(propName);
+ mlt_properties_set(transproperties, tmp, "");
+ delete[] tmp;
+ }
+ }
+ }
+
mlt_properties_set_int(transproperties, "force_track", xml.attribute("force_track").toInt());
- // update the transition id in case it uses the same MLT service but different Kdenlive id
- char *tmp = decodedString(xml.attribute("id"));
- mlt_properties_set(transproperties, "kdenlive_id", tmp);
- delete[] tmp;
+ mlt_properties_set_int(transproperties, "automatic", xml.attribute("automatic", "0").toInt());
+
if (currentBTrack != a_track) {
- mlt_properties_set_int(properties, "a_track", a_track);
+ mlt_properties_set_int(transproperties, "a_track", a_track);
}
for (it = map.begin(); it != map.end(); ++it) {
key = it.key();
Mlt::Transition *transition = new Mlt::Transition(*m_mltProfile, transId);
if (out != GenTime())
transition->set_in_and_out((int) in.frames(m_fps), (int) out.frames(m_fps) - 1);
+
+ if (do_refresh && (m_mltProducer->position() < in.frames(m_fps) || m_mltProducer->position() > out.frames(m_fps))) do_refresh = false;
QMap<QString, QString>::Iterator it;
QString key;
if (xml.attribute("automatic") == "1") transition->set("automatic", 1);
delete[] name;
delete[] value;
}
- // attach filter to the clip
- field->plant_transition(*transition, a_track, b_track);
+ // attach transition
+ mltPlantTransition(field, *transition, a_track, b_track);
+ // field->plant_transition(*transition, a_track, b_track);
delete[] transId;
if (do_refresh) refresh();
return true;
int a_track = mappedProps.value("a_track").toInt();
int b_track = mappedProps.value("b_track").toInt();
if (a_track > 0 && a_track >= ix) a_track --;
- if (b_track > 0 && b_track >= ix) b_track --;
+ if (b_track == ix) {
+ // transition was on the deleted track, so remove it
+ tractor.removeChild(transitions.at(i));
+ i--;
+ continue;
+ }
+ if (b_track > 0 && b_track > ix) b_track --;
for (int j = 0; j < props.count(); j++) {
QDomElement f = props.at(j).toElement();
if (f.attribute("name") == "a_track") f.firstChild().setNodeValue(QString::number(a_track));
projects / kdenlive / blobdiff