***************************************************************************/
#include "stopmotion.h"
-#include "../blackmagic/devices.h"
-#include "../slideshowclip.h"
+#ifdef USE_V4L
+#include "v4l/v4lcapture.h"
+#endif
+#include "slideshowclip.h"
+#include "profilesdialog.h"
+#include "mltdevicecapture.h"
+#include "recmonitor.h"
+#include "monitormanager.h"
+#include "ui_smconfig_ui.h"
#include "kdenlivesettings.h"
-
#include <KDebug>
#include <KGlobalSettings>
#include <KFileDialog>
#include <kdeversion.h>
#include <KNotification>
+#include <QtConcurrentRun>
#include <QInputDialog>
#include <QComboBox>
#include <QVBoxLayout>
#include <QPainter>
#include <QAction>
#include <QWheelEvent>
+#include <QMenu>
-MyLabel::MyLabel(QWidget *parent)
+MyLabel::MyLabel(QWidget* parent) :
+ QLabel(parent)
{
}
-void MyLabel::setImage(QImage img)
+void MyLabel::setImage(const QImage& img)
{
m_img = img;
}
//virtual
-void MyLabel::wheelEvent(QWheelEvent * event)
+void MyLabel::wheelEvent(QWheelEvent* event)
+{
+ if (event->delta() > 0)
+ emit seek(true);
+ else
+ emit seek(false);
+}
+
+//virtual
+void MyLabel::mousePressEvent(QMouseEvent*)
{
- if (event->delta() > 0) emit seek(true);
- else emit seek(false);
+ emit switchToLive();
}
//virtual
-void MyLabel::paintEvent( QPaintEvent * event)
+void MyLabel::paintEvent(QPaintEvent* event)
{
+ Q_UNUSED(event);
+
QRect r(0, 0, width(), height());
QPainter p(this);
p.fillRect(r, QColor(KdenliveSettings::window_background()));
int calculatedWidth = aspect_ratio * height();
if (calculatedWidth > width()) pictureHeight = width() / aspect_ratio;
else {
- int calculatedHeight = width() / aspect_ratio;
- if (calculatedHeight > height()) pictureWidth = height() * aspect_ratio;
+ int calculatedHeight = width() / aspect_ratio;
+ if (calculatedHeight > height()) pictureWidth = height() * aspect_ratio;
}
p.drawImage(QRect((width() - pictureWidth) / 2, (height() - pictureHeight) / 2, pictureWidth, pictureHeight), m_img, QRect(0, 0, m_img.width(), m_img.height()));
p.end();
}
-StopmotionWidget::StopmotionWidget(KUrl projectFolder, QWidget *parent) :
- QDialog(parent)
- , Ui::Stopmotion_UI()
- , m_projectFolder(projectFolder)
- , m_sequenceFrame(0)
- , m_animatedIndex(-1)
+StopmotionMonitor::StopmotionMonitor(MonitorManager *manager, QWidget *parent) :
+ AbstractMonitor(Kdenlive::stopmotionMonitor, manager, parent),
+ m_captureDevice(NULL)
+{
+ createVideoSurface();
+}
+
+StopmotionMonitor::~StopmotionMonitor()
+{
+}
+
+void StopmotionMonitor::slotSwitchFullScreen()
+{
+}
+
+void StopmotionMonitor::setRender(MltDeviceCapture *render)
+{
+ m_captureDevice = render;
+}
+
+AbstractRender *StopmotionMonitor::abstractRender()
+{
+ return m_captureDevice;
+}
+
+Kdenlive::MONITORID StopmotionMonitor::id() const
+{
+ return Kdenlive::stopmotionMonitor;
+}
+
+
+void StopmotionMonitor::stop()
+{
+ if (m_captureDevice) m_captureDevice->stop();
+ emit stopCapture();
+}
+
+void StopmotionMonitor::start()
+{
+}
+
+void StopmotionMonitor::slotPlay()
+{
+}
+
+void StopmotionMonitor::slotMouseSeek(int /*eventDelta*/, bool /*fast*/)
+{
+}
+
+StopmotionWidget::StopmotionWidget(MonitorManager *manager, const KUrl &projectFolder, const QList<QAction *> &actions, QWidget* parent) :
+ QDialog(parent)
+ , Ui::Stopmotion_UI()
+ , m_projectFolder(projectFolder)
+ , m_captureDevice(NULL)
+ , m_sequenceFrame(0)
+ , m_animatedIndex(-1)
+ , m_animate(false)
+ , m_manager(manager)
+ , m_monitor(new StopmotionMonitor(manager, this))
{
+ //setAttribute(Qt::WA_DeleteOnClose);
+ //HACK: the monitor widget is hidden, it is just used to control the capturedevice from monitormanager
+ m_monitor->setHidden(true);
+ connect(m_monitor, SIGNAL(stopCapture()), this, SLOT(slotStopCapture()));
+ m_manager->appendMonitor(m_monitor);
+ QAction* analyse = new QAction(i18n("Send frames to color scopes"), this);
+ analyse->setCheckable(true);
+ analyse->setChecked(KdenliveSettings::analyse_stopmotion());
+ connect(analyse, SIGNAL(triggered(bool)), this, SLOT(slotSwitchAnalyse(bool)));
+
+ QAction* mirror = new QAction(i18n("Mirror display"), this);
+ mirror->setCheckable(true);
+ //mirror->setChecked(KdenliveSettings::analyse_stopmotion());
+ connect(mirror, SIGNAL(triggered(bool)), this, SLOT(slotSwitchMirror(bool)));
+
+ addActions(actions);
setupUi(this);
setWindowTitle(i18n("Stop Motion Capture"));
setFont(KGlobalSettings::toolBarFont());
live_button->setIcon(KIcon("camera-photo"));
- frameoverlay_button->setIcon(KIcon("edit-paste"));
- m_captureAction = new QAction(KIcon("media-record"), i18n("Capture frame"), this);
- m_captureAction->setShortcut(QKeySequence(Qt::Key_Space));
+
+ m_captureAction = actions.at(0);
connect(m_captureAction, SIGNAL(triggered()), this, SLOT(slotCaptureFrame()));
+ m_captureAction->setCheckable(true);
+ m_captureAction->setChecked(false);
capture_button->setDefaultAction(m_captureAction);
-
+
+ connect(actions.at(1), SIGNAL(triggered()), this, SLOT(slotSwitchLive()));
+
+ QAction *intervalCapture = new QAction(i18n("Interval capture"), this);
+ intervalCapture->setIcon(KIcon("chronometer"));
+ intervalCapture->setCheckable(true);
+ intervalCapture->setChecked(false);
+ capture_interval->setDefaultAction(intervalCapture);
+
preview_button->setIcon(KIcon("media-playback-start"));
- removelast_button->setIcon(KIcon("edit-delete"));
- frameoverlay_button->setEnabled(false);
- removelast_button->setEnabled(false);
capture_button->setEnabled(false);
- connect(sequence_name, SIGNAL(textChanged(const QString &)), this, SLOT(sequenceNameChanged(const QString &)));
- BMInterface::getBlackMagicDeviceList(capture_device, NULL);
- QVBoxLayout *lay = new QVBoxLayout;
- m_bmCapture = new CaptureHandler(lay);
+
+ // Build config menu
+ QMenu* confMenu = new QMenu;
+ m_showOverlay = actions.at(2);
+ connect(m_showOverlay, SIGNAL(triggered(bool)), this, SLOT(slotShowOverlay(bool)));
+ overlay_button->setDefaultAction(m_showOverlay);
+ //confMenu->addAction(m_showOverlay);
+
+ m_effectIndex = KdenliveSettings::stopmotioneffect();
+ QMenu* effectsMenu = new QMenu(i18n("Overlay effect"));
+ QActionGroup* effectGroup = new QActionGroup(this);
+ QAction* noEffect = new QAction(i18n("No Effect"), effectGroup);
+ noEffect->setData(0);
+ QAction* contrastEffect = new QAction(i18n("Contrast"), effectGroup);
+ contrastEffect->setData(1);
+ QAction* edgeEffect = new QAction(i18n("Edge detect"), effectGroup);
+ edgeEffect->setData(2);
+ QAction* brightEffect = new QAction(i18n("Brighten"), effectGroup);
+ brightEffect->setData(3);
+ QAction* invertEffect = new QAction(i18n("Invert"), effectGroup);
+ invertEffect->setData(4);
+ QAction* thresEffect = new QAction(i18n("Threshold"), effectGroup);
+ thresEffect->setData(5);
+
+ effectsMenu->addAction(noEffect);
+ effectsMenu->addAction(contrastEffect);
+ effectsMenu->addAction(edgeEffect);
+ effectsMenu->addAction(brightEffect);
+ effectsMenu->addAction(invertEffect);
+ effectsMenu->addAction(thresEffect);
+ QList <QAction*> list = effectsMenu->actions();
+ for (int i = 0; i < list.count(); ++i) {
+ list.at(i)->setCheckable(true);
+ if (list.at(i)->data().toInt() == m_effectIndex) {
+ list.at(i)->setChecked(true);
+ }
+ }
+ connect(effectsMenu, SIGNAL(triggered(QAction*)), this, SLOT(slotUpdateOverlayEffect(QAction*)));
+ confMenu->addMenu(effectsMenu);
+
+ QAction* showThumbs = new QAction(KIcon("image-x-generic"), i18n("Show sequence thumbnails"), this);
+ showThumbs->setCheckable(true);
+ showThumbs->setChecked(KdenliveSettings::showstopmotionthumbs());
+ connect(showThumbs, SIGNAL(triggered(bool)), this, SLOT(slotShowThumbs(bool)));
+
+ QAction* removeCurrent = new QAction(KIcon("edit-delete"), i18n("Delete current frame"), this);
+ removeCurrent->setShortcut(Qt::Key_Delete);
+ connect(removeCurrent, SIGNAL(triggered()), this, SLOT(slotRemoveFrame()));
+
+ QAction* conf = new QAction(KIcon("configure"), i18n("Configure"), this);
+ connect(conf, SIGNAL(triggered()), this, SLOT(slotConfigure()));
+
+ confMenu->addAction(showThumbs);
+ confMenu->addAction(removeCurrent);
+ confMenu->addAction(analyse);
+ confMenu->addAction(mirror);
+ confMenu->addAction(conf);
+ config_button->setIcon(KIcon("configure"));
+ config_button->setMenu(confMenu);
+
+ connect(sequence_name, SIGNAL(textChanged(QString)), this, SLOT(sequenceNameChanged(QString)));
+ connect(sequence_name, SIGNAL(currentIndexChanged(int)), live_button, SLOT(setFocus()));
+
+ // Video widget holder
+ QVBoxLayout *layout = new QVBoxLayout;
+ layout->setContentsMargins(0, 0, 0, 0);
+ layout->setSpacing(0);
+ m_monitor->videoBox->setLineWidth(4);
+ layout->addWidget(m_monitor->videoBox);
+
+ if (KdenliveSettings::decklink_device_found()) {
+ // Found a BlackMagic device
+ }
+
+ if (QFile::exists(KdenliveSettings::video4vdevice())) {
+#ifdef USE_V4L
+ // Video 4 Linux device detection
+ for (int i = 0; i < 10; ++i) {
+ QString path = "/dev/video" + QString::number(i);
+ if (QFile::exists(path)) {
+ QStringList deviceInfo = V4lCaptureHandler::getDeviceName(path);
+ if (!deviceInfo.isEmpty()) {
+ capture_device->addItem(deviceInfo.at(0), "v4l");
+ capture_device->setItemData(capture_device->count() - 1, path, Qt::UserRole + 1);
+ capture_device->setItemData(capture_device->count() - 1, deviceInfo.at(1), Qt::UserRole + 2);
+ if (path == KdenliveSettings::video4vdevice()) capture_device->setCurrentIndex(capture_device->count() - 1);
+ }
+ }
+ }
+#endif /* USE_V4L */
+ }
+
+ connect(capture_device, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdateDeviceHandler()));
+ /*if (m_bmCapture) {
+ connect(m_bmCapture, SIGNAL(frameSaved(QString)), this, SLOT(slotNewThumb(QString)));
+ connect(m_bmCapture, SIGNAL(gotFrame(QImage)), this, SIGNAL(gotFrame(QImage)));
+ } else live_button->setEnabled(false);*/
+
m_frame_preview = new MyLabel(this);
connect(m_frame_preview, SIGNAL(seek(bool)), this, SLOT(slotSeekFrame(bool)));
- lay->addWidget(m_frame_preview);
+ connect(m_frame_preview, SIGNAL(switchToLive()), this, SLOT(slotSwitchLive()));
+ layout->addWidget(m_frame_preview);
m_frame_preview->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
- video_preview->setLayout(lay);
+ video_preview->setLayout(layout);
+
+ //kDebug()<<video_preview->winId();
+
+ QString profilePath;
+ // Create MLT producer data
+ if (capture_device->itemData(capture_device->currentIndex()) == "v4l") {
+ // Capture using a video4linux device
+ profilePath = KStandardDirs::locateLocal("appdata", "profiles/video4linux");
+ }
+ else {
+ // Decklink capture
+ profilePath = KdenliveSettings::current_profile();
+ }
+
+ m_captureDevice = new MltDeviceCapture(profilePath, m_monitor->videoSurface, this);
+ m_captureDevice->sendFrameForAnalysis = KdenliveSettings::analyse_stopmotion();
+ m_monitor->setRender(m_captureDevice);
+ connect(m_captureDevice, SIGNAL(frameSaved(QString)), this, SLOT(slotNewThumb(QString)));
+
live_button->setChecked(false);
- frameoverlay_button->setChecked(false);
button_addsequence->setEnabled(false);
- connect(live_button, SIGNAL(clicked(bool)), this, SLOT(slotLive(bool)));
- connect(frameoverlay_button, SIGNAL(clicked(bool)), this, SLOT(slotShowOverlay(bool)));
- connect(frame_number, SIGNAL(valueChanged(int)), this, SLOT(slotShowFrame(int)));
+ connect(live_button, SIGNAL(toggled(bool)), this, SLOT(slotLive(bool)));
connect(button_addsequence, SIGNAL(clicked(bool)), this, SLOT(slotAddSequence()));
- connect(preview_button, SIGNAL(clicked(bool)), this, SLOT(slotPlayPreview()));
+ connect(preview_button, SIGNAL(clicked(bool)), this, SLOT(slotPlayPreview(bool)));
connect(frame_list, SIGNAL(currentRowChanged(int)), this, SLOT(slotShowSelectedFrame()));
+ connect(frame_list, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(slotShowSelectedFrame()));
+ connect(this, SIGNAL(doCreateThumbs(QImage,int)), this, SLOT(slotCreateThumbs(QImage,int)));
-
+ frame_list->addAction(removeCurrent);
+ frame_list->setContextMenuPolicy(Qt::ActionsContextMenu);
+ frame_list->setHidden(!KdenliveSettings::showstopmotionthumbs());
parseExistingSequences();
+ QTimer::singleShot(500, this, SLOT(slotLive()));
+ connect(&m_intervalTimer, SIGNAL(timeout()), this, SLOT(slotCaptureFrame()));
+ m_intervalTimer.setSingleShot(true);
+ m_intervalTimer.setInterval(KdenliveSettings::captureinterval() * 1000);
}
StopmotionWidget::~StopmotionWidget()
{
- m_bmCapture->stopPreview();
+ m_manager->removeMonitor(m_monitor);
+ if (m_captureDevice) {
+ m_captureDevice->stop();
+ delete m_captureDevice;
+ m_captureDevice = NULL;
+ }
+
+ delete m_monitor;
+}
+
+void StopmotionWidget::slotUpdateOverlayEffect(QAction* act)
+{
+ if (act) m_effectIndex = act->data().toInt();
+ KdenliveSettings::setStopmotioneffect(m_effectIndex);
+ slotUpdateOverlay();
+}
+
+void StopmotionWidget::closeEvent(QCloseEvent* e)
+{
+ slotLive(false);
+ QDialog::closeEvent(e);
+}
+
+void StopmotionWidget::slotConfigure()
+{
+ QDialog d;
+ Ui::SmConfig_UI ui;
+ ui.setupUi(&d);
+ d.setWindowTitle(i18n("Configure Stop Motion"));
+ ui.sm_interval->setValue(KdenliveSettings::captureinterval());
+ ui.sm_interval->setSuffix(ki18np(" second", " seconds"));
+ ui.sm_notifytime->setSuffix(ki18np(" second", " seconds"));
+ ui.sm_notifytime->setValue(KdenliveSettings::sm_notifytime());
+ connect(ui.sm_prenotify, SIGNAL(toggled(bool)), ui.sm_notifytime, SLOT(setEnabled(bool)));
+ ui.sm_prenotify->setChecked(KdenliveSettings::sm_prenotify());
+ ui.sm_loop->setChecked(KdenliveSettings::sm_loop());
+ ui.sm_framesplayback->setValue(KdenliveSettings::sm_framesplayback());
+
+ if (d.exec() == QDialog::Accepted) {
+ KdenliveSettings::setSm_loop(ui.sm_loop->isChecked());
+ KdenliveSettings::setCaptureinterval(ui.sm_interval->value());
+ KdenliveSettings::setSm_framesplayback(ui.sm_framesplayback->value());
+ KdenliveSettings::setSm_notifytime(ui.sm_notifytime->value());
+ KdenliveSettings::setSm_prenotify(ui.sm_prenotify->isChecked());
+ m_intervalTimer.setInterval(KdenliveSettings::captureinterval() * 1000);
+ }
+}
+
+void StopmotionWidget::slotShowThumbs(bool show)
+{
+ KdenliveSettings::setShowstopmotionthumbs(show);
+ if (show) {
+ frame_list->clear();
+ sequenceNameChanged(sequence_name->currentText());
+ } else {
+ m_filesList.clear();
+ frame_list->clear();
+ }
+ frame_list->setHidden(!show);
+}
+
+
+void StopmotionWidget::slotUpdateDeviceHandler()
+{
+ slotLive(false);
+ delete m_captureDevice;
+ m_captureDevice = NULL;
+ /*QString data = capture_device->itemData(capture_device->currentIndex()).toString();
+ slotLive(false);
+ if (m_bmCapture) {
+ delete m_bmCapture;
+ }
+ m_layout->removeWidget(m_frame_preview);
+ if (data == "v4l") {
+#ifdef USE_V4L
+ m_bmCapture = new V4lCaptureHandler(m_layout);
+ m_bmCapture->setDevice(capture_device->itemData(capture_device->currentIndex(), Qt::UserRole + 1).toString(), capture_device->itemData(capture_device->currentIndex(), Qt::UserRole + 2).toString());
+#endif
+ } else {
+ m_bmCapture = new BmdCaptureHandler(m_layout);
+ if (m_bmCapture) connect(m_bmCapture, SIGNAL(gotMessage(QString)), this, SLOT(slotGotHDMIMessage(QString)));
+ }
+ live_button->setEnabled(m_bmCapture != NULL);
+ m_layout->addWidget(m_frame_preview);*/
+}
+
+void StopmotionWidget::slotGotHDMIMessage(const QString& message)
+{
+ log_box->insertItem(0, message);
}
void StopmotionWidget::parseExistingSequences()
//dir.setNameFilters(filters);
QStringList sequences = dir.entryList(filters, QDir::Files, QDir::Name);
//kDebug()<<"PF: "<<<<", sm: "<<sequences;
- foreach(QString sequencename, sequences) {
- sequence_name->addItem(sequencename.section("_", 0, -2));
+ foreach(const QString &sequencename, sequences) {
+ sequence_name->addItem(sequencename.section('_', 0, -2));
}
}
+void StopmotionWidget::slotSwitchLive()
+{
+ setUpdatesEnabled(false);
+ slotLive(!live_button->isChecked());
+ setUpdatesEnabled(true);
+}
+
+void StopmotionWidget::slotStopCapture()
+{
+ slotLive(false);
+}
+
void StopmotionWidget::slotLive(bool isOn)
{
+ live_button->blockSignals(true);
+ capture_button->setEnabled(false);
if (isOn) {
- m_frame_preview->setImage(QImage());
- m_frame_preview->setHidden(true);
- m_bmCapture->startPreview(KdenliveSettings::hdmicapturedevice(), KdenliveSettings::hdmicapturemode());
- capture_button->setEnabled(true);
+ m_frame_preview->setHidden(true);
+ m_monitor->videoBox->setHidden(false);
+ QLocale locale;
+
+ MltVideoProfile profile;
+ QString resource;
+ QString service;
+ QString profilePath;
+ // Create MLT producer data
+ if (capture_device->itemData(capture_device->currentIndex()) == "v4l") {
+ // Capture using a video4linux device
+ profilePath = KStandardDirs::locateLocal("appdata", "profiles/video4linux");
+ profile = ProfilesDialog::getVideoProfile(profilePath);
+ service = "avformat-novalidate";
+ QString devicePath = capture_device->itemData(capture_device->currentIndex(), Qt::UserRole + 1).toString();
+ resource = QString("video4linux2:%1?width:%2&height:%3&frame_rate:%4").arg(devicePath).arg(profile.width).arg(profile.height).arg((double) profile.frame_rate_num / profile.frame_rate_den);
+ }
+ else {
+ // Decklink capture
+ profilePath = KdenliveSettings::current_profile();
+ profile = ProfilesDialog::getVideoProfile(profilePath);
+ service = "decklink";
+ resource = capture_device->itemData(capture_device->currentIndex(), Qt::UserRole + 1).toString();
+ }
+
+ if (m_captureDevice == NULL) {
+ m_captureDevice = new MltDeviceCapture(profilePath, m_monitor->videoSurface, this);
+ m_captureDevice->sendFrameForAnalysis = KdenliveSettings::analyse_stopmotion();
+ m_monitor->setRender(m_captureDevice);
+ connect(m_captureDevice, SIGNAL(frameSaved(QString)), this, SLOT(slotNewThumb(QString)));
+ }
+
+ m_manager->activateMonitor(Kdenlive::stopmotionMonitor);
+ QString producer = createProducer(profile, service, resource);
+ if (m_captureDevice->slotStartPreview(producer, true)) {
+ if (m_showOverlay->isChecked()) {
+ reloadOverlay();
+ slotUpdateOverlay();
+ }
+ capture_button->setEnabled(true);
+ live_button->setChecked(true);
+ log_box->insertItem(-1, i18n("Playing %1x%2 (%3 fps)", profile.width, profile.height, locale.toString((double)profile.frame_rate_num/profile.frame_rate_den).rightJustified(2, '0')));
+ log_box->setCurrentIndex(0);
+ }
+ else {
+ kDebug()<<"// problem starting stopmo";
+ log_box->insertItem(-1, i18n("Failed to start device"));
+ log_box->setCurrentIndex(0);
+ }
}
else {
- m_bmCapture->stopPreview();
- capture_button->setEnabled(false);
+ m_frame_preview->setHidden(false);
+ live_button->setChecked(false);
+ if (m_captureDevice) {
+ m_captureDevice->stop();
+ m_monitor->videoBox->setHidden(true);
+ log_box->insertItem(-1, i18n("Stopped"));
+ log_box->setCurrentIndex(0);
+ //delete m_captureDevice;
+ //m_captureDevice = NULL;
+ }
}
+
+ /*
+ if (isOn && m_bmCapture) {
+ //m_frame_preview->setImage(QImage());
+ m_frame_preview->setHidden(true);
+ m_bmCapture->startPreview(KdenliveSettings::hdmi_capturedevice(), KdenliveSettings::hdmi_capturemode(), false);
+ capture_button->setEnabled(true);
+ live_button->setChecked(true);
+ } else {
+ if (m_bmCapture) m_bmCapture->stopPreview();
+ m_frame_preview->setHidden(false);
+ capture_button->setEnabled(false);
+ live_button->setChecked(false);
+ }*/
+ live_button->blockSignals(false);
}
void StopmotionWidget::slotShowOverlay(bool isOn)
{
if (isOn) {
- if (live_button->isChecked() && m_sequenceFrame > 0) {
- slotUpdateOverlay();
- }
+ // Overlay last frame of the sequence
+ reloadOverlay();
+ slotUpdateOverlay();
}
else {
- m_bmCapture->hideOverlay();
+ // Remove overlay
+ m_captureDevice->setOverlay(QString());
}
}
-void StopmotionWidget::slotUpdateOverlay()
+void StopmotionWidget::reloadOverlay()
{
QString path = getPathForFrame(m_sequenceFrame - 1);
- if (!QFile::exists(path)) return;
- QImage img(path);
- if (img.isNull()) {
- QTimer::singleShot(1000, this, SLOT(slotUpdateOverlay()));
- return;
+ if (!QFile::exists(path)) {
+ log_box->insertItem(-1, i18n("No previous frame found"));
+ log_box->setCurrentIndex(0);
+ return;
+ }
+ m_captureDevice->setOverlay(path);
+}
+
+void StopmotionWidget::slotUpdateOverlay()
+{
+ if (m_captureDevice == NULL) return;
+
+ QString tag;
+ QStringList params;
+
+ switch (m_effectIndex) {
+ case 1:
+ tag = "frei0r.contrast0r";
+ params << "Contrast=1.2";
+ break;
+ case 2:
+ tag = "charcoal";
+ params << "x_scatter=4" << "y_scatter=4" << "scale=1" << "mix=0";
+ break;
+ case 3:
+ tag = "frei0r.brightness";
+ params << "Brightness=0.7";
+ break;
+ case 4:
+ tag = "invert";
+ break;
+ case 5:
+ tag = "threshold";
+ params << "midpoint=125";
+ break;
+ default:
+ break;
+
}
- m_bmCapture->showOverlay(img);
+ m_captureDevice->setOverlayEffect(tag, params);
}
-void StopmotionWidget::sequenceNameChanged(const QString &name)
+void StopmotionWidget::sequenceNameChanged(const QString& name)
{
+ // Get rid of frames from previous sequence
+ disconnect(this, SIGNAL(doCreateThumbs(QImage,int)), this, SLOT(slotCreateThumbs(QImage,int)));
+ m_filesList.clear();
+ m_future.waitForFinished();
frame_list->clear();
if (name.isEmpty()) {
- button_addsequence->setEnabled(false);
- frame_number->blockSignals(true);
- frame_number->setValue(m_sequenceFrame);
- frame_number->blockSignals(false);
- frameoverlay_button->setEnabled(false);
- removelast_button->setEnabled(false);
- }
- else {
- // Check if we are editing an existing sequence
- int count = 0;
- QString pattern = SlideshowClip::selectedPath(getPathForFrame(0, sequence_name->currentText()), false, QString(), &count);
- m_sequenceFrame = count;
- if (count > 0) {
- m_sequenceName = sequence_name->currentText();
- //TODO: Do the thumbnail stuff in a thread
- for (int i = 0; i < count; i++) {
- slotUpdateFrameList(i);
- }
- button_addsequence->setEnabled(true);
- frameoverlay_button->setEnabled(true);
- }
- else {
- button_addsequence->setEnabled(false);
- frameoverlay_button->setEnabled(false);
- }
- frame_number->setRange(0, m_sequenceFrame);
- frame_number->blockSignals(true);
- frame_number->setValue(m_sequenceFrame);
- frame_number->blockSignals(false);
- capture_button->setEnabled(true);
+ button_addsequence->setEnabled(false);
+ } else {
+ // Check if we are editing an existing sequence
+ QString pattern = SlideshowClip::selectedPath(getPathForFrame(0, sequence_name->currentText()), false, QString(), &m_filesList);
+ m_sequenceFrame = m_filesList.isEmpty() ? 0 : SlideshowClip::getFrameNumberFromPath(m_filesList.last()) + 1;
+ if (!m_filesList.isEmpty()) {
+ m_sequenceName = sequence_name->currentText();
+ connect(this, SIGNAL(doCreateThumbs(QImage,int)), this, SLOT(slotCreateThumbs(QImage,int)));
+ m_future = QtConcurrent::run(this, &StopmotionWidget::slotPrepareThumbs);
+ button_addsequence->setEnabled(true);
+ } else {
+ // new sequence
+ connect(this, SIGNAL(doCreateThumbs(QImage,int)), this, SLOT(slotCreateThumbs(QImage,int)));
+ button_addsequence->setEnabled(false);
+ }
+ capture_button->setEnabled(live_button->isChecked());
}
}
void StopmotionWidget::slotCaptureFrame()
{
+ if (m_captureDevice == NULL) return;
if (sequence_name->currentText().isEmpty()) {
- QString seqName = QInputDialog::getText(this, i18n("Create New Sequence"), i18n("Enter sequence name"));
- if (seqName.isEmpty()) return;
- sequence_name->blockSignals(true);
- sequence_name->setItemText(sequence_name->currentIndex(), seqName);
- sequence_name->blockSignals(false);
+ QString seqName = QInputDialog::getText(this, i18n("Create New Sequence"), i18n("Enter sequence name"));
+ if (seqName.isEmpty()) {
+ m_captureAction->setChecked(false);
+ return;
+ }
+ sequence_name->blockSignals(true);
+ sequence_name->setItemText(sequence_name->currentIndex(), seqName);
+ sequence_name->blockSignals(false);
}
if (m_sequenceName != sequence_name->currentText()) {
- m_sequenceName = sequence_name->currentText();
- m_sequenceFrame = 0;
+ m_sequenceName = sequence_name->currentText();
+ m_sequenceFrame = 0;
}
- capture_button->setEnabled(false);
- m_bmCapture->captureFrame(getPathForFrame(m_sequenceFrame));
- KNotification::event("FrameCaptured");
- frameoverlay_button->setEnabled(true);
+ //capture_button->setEnabled(false);
+ if (m_intervalTimer.isActive()) {
+ // stop interval capture
+ m_intervalTimer.stop();
+ return;
+ }
+ QString currentPath = getPathForFrame(m_sequenceFrame);
+ m_captureDevice->captureFrame(currentPath);
+ KNotification::event("FrameCaptured", i18n("Frame Captured"), QPixmap(), this);
m_sequenceFrame++;
- frame_number->setRange(0, m_sequenceFrame);
- frame_number->blockSignals(true);
- frame_number->setValue(m_sequenceFrame);
- frame_number->blockSignals(false);
button_addsequence->setEnabled(true);
- //if (frameoverlay_button->isChecked()) QTimer::singleShot(1000, this, SLOT(slotUpdateOverlay()));
- QTimer::singleShot(1000, this, SLOT(slotUpdateFrameList()));
+ if (capture_interval->isChecked()) {
+ if (KdenliveSettings::sm_prenotify()) QTimer::singleShot((KdenliveSettings::captureinterval() - KdenliveSettings::sm_notifytime()) * 1000, this, SLOT(slotPreNotify()));
+ m_intervalTimer.start();
+ }
+ else m_captureAction->setChecked(false);
}
-void StopmotionWidget::slotUpdateFrameList(int ix)
+void StopmotionWidget::slotPreNotify()
+{
+ if (m_captureAction->isChecked()) KNotification::event("ReadyToCapture", i18n("Going to Capture Frame"), QPixmap(), this);
+}
+
+
+void StopmotionWidget::slotNewThumb(const QString &path)
+{
+ if (!KdenliveSettings::showstopmotionthumbs()) return;
+ m_filesList.append(path);
+ if (m_showOverlay->isChecked()) reloadOverlay();
+ if (!m_future.isRunning()) m_future = QtConcurrent::run(this, &StopmotionWidget::slotPrepareThumbs);
+
+}
+
+void StopmotionWidget::slotPrepareThumbs()
+{
+ if (m_filesList.isEmpty()) return;
+ QString path = m_filesList.takeFirst();
+ emit doCreateThumbs(QImage(path), SlideshowClip::getFrameNumberFromPath(path));
+
+}
+
+void StopmotionWidget::slotCreateThumbs(const QImage &img, int ix)
{
- kDebug()<< "// GET FRAME: "<<ix;
- if (ix == -1) ix = m_sequenceFrame - 1;
- QString path = getPathForFrame(ix);
- if (!QFile::exists(path)) {
- capture_button->setEnabled(true);
- return;
- }
- QImage img(path);
if (img.isNull()) {
- if (ix == m_sequenceFrame - 1) QTimer::singleShot(1000, this, SLOT(slotUpdateFrameList()));
- return;
+ m_future = QtConcurrent::run(this, &StopmotionWidget::slotPrepareThumbs);
+ return;
}
int height = 90;
int width = height * img.width() / img.height();
QString nb = QString::number(ix);
QPainter p(&pix);
QFontInfo finfo(font());
- p.fillRect(0, 0, finfo.pixelSize() * nb.count() + 6, finfo.pixelSize() + 6, QColor(0, 0, 0, 150));
+ p.fillRect(0, 0, finfo.pixelSize() * nb.count() + 6, finfo.pixelSize() + 6, QColor(80, 80, 80, 150));
p.setPen(Qt::white);
p.drawText(QPoint(3, finfo.pixelSize() + 3), nb);
p.end();
QIcon icon(pix);
- QListWidgetItem *item = new QListWidgetItem(icon, QString(), frame_list);
- item->setData(Qt::UserRole, path);
- item->setData(Qt::UserRole + 1, ix);
- item->setToolTip(path);
- capture_button->setEnabled(true);
+ QListWidgetItem* item = new QListWidgetItem(icon, QString(), frame_list);
+ item->setToolTip(getPathForFrame(ix, sequence_name->currentText()));
+ item->setData(Qt::UserRole, ix);
+ frame_list->blockSignals(true);
+ frame_list->setCurrentItem(item);
+ frame_list->blockSignals(false);
+ m_future = QtConcurrent::run(this, &StopmotionWidget::slotPrepareThumbs);
}
QString StopmotionWidget::getPathForFrame(int ix, QString seqName)
{
- if (seqName.isEmpty()) seqName = m_sequenceName;
- return m_projectFolder.path(KUrl::AddTrailingSlash) + seqName + "_" + QString::number(ix).rightJustified(4, '0', false) + ".png";
-}
-
-void StopmotionWidget::slotShowFrame(int ix)
-{
- if (m_sequenceFrame == 0) {
- //there are no images in sequence
- return;
- }
- frameoverlay_button->blockSignals(true);
- frameoverlay_button->setChecked(false);
- frameoverlay_button->blockSignals(false);
- if (ix < m_sequenceFrame) {
- // Show previous frame
- slotLive(false);
- live_button->setChecked(false);
- QImage img(getPathForFrame(ix));
- capture_button->setEnabled(false);
- if (!img.isNull()) {
- //m_bmCapture->showOverlay(img, false);
- m_bmCapture->hidePreview(true);
- m_frame_preview->setImage(img);
- m_frame_preview->setHidden(false);
- m_frame_preview->update();
- selectFrame(ix);
- }
+ if (seqName.isEmpty())
+ seqName = m_sequenceName;
+ return m_projectFolder.path(KUrl::AddTrailingSlash) + seqName + QLatin1Char('_') + QString::number(ix).rightJustified(4, '0', false) + QLatin1String(".png");
+}
+
+void StopmotionWidget::slotShowFrame(const QString& path)
+{
+ //slotLive(false);
+ QImage img(path);
+ capture_button->setEnabled(false);
+ slotLive(false);
+ if (!img.isNull()) {
+ m_frame_preview->setImage(img);
+ m_frame_preview->setHidden(false);
+ m_frame_preview->update();
}
- else {
- slotLive(true);
- m_frame_preview->setImage(QImage());
- m_frame_preview->setHidden(true);
- m_bmCapture->hideOverlay();
- m_bmCapture->hidePreview(false);
- capture_button->setEnabled(true);
- }
}
void StopmotionWidget::slotShowSelectedFrame()
{
- QListWidgetItem *item = frame_list->currentItem();
+ QListWidgetItem* item = frame_list->currentItem();
if (item) {
- int ix = item->data(Qt::UserRole + 1).toInt();
- //frame_number->blockSignals(true);
- frame_number->setValue(ix);
- //frame_number->blockSignals(false);
- //slotShowFrame(ix);
+ //int ix = item->data(Qt::UserRole).toInt();;
+ slotShowFrame(item->toolTip());
}
}
emit addOrUpdateSequence(getPathForFrame(0));
}
-void StopmotionWidget::slotPlayPreview()
+void StopmotionWidget::slotPlayPreview(bool animate)
{
- if (m_animatedIndex != -1) {
- // stop animation
- m_animatedIndex = -1;
- return;
+ m_animate = animate;
+ if (!animate) {
+ // stop animation
+ m_animationList.clear();
+ return;
}
- QListWidgetItem *item = frame_list->currentItem();
- if (item) {
- m_animatedIndex = item->data(Qt::UserRole + 1).toInt();
+ if (KdenliveSettings::showstopmotionthumbs()) {
+ if (KdenliveSettings::sm_framesplayback() == 0) frame_list->setCurrentRow(0);
+ else frame_list->setCurrentRow(frame_list->count() - KdenliveSettings::sm_framesplayback());
+ QTimer::singleShot(200, this, SLOT(slotAnimate()));
+ } else {
+ SlideshowClip::selectedPath(getPathForFrame(0, sequence_name->currentText()), false, QString(), &m_animationList);
+ if (KdenliveSettings::sm_framesplayback() > 0) {
+ // only play the last x frames
+ while (m_animationList.count() > KdenliveSettings::sm_framesplayback() + 1) {
+ m_animationList.removeFirst();
+ }
+ }
+ m_animatedIndex = 0;
+ slotAnimate();
}
- QTimer::singleShot(200, this, SLOT(slotAnimate()));
}
void StopmotionWidget::slotAnimate()
{
- slotShowFrame(m_animatedIndex);
- m_animatedIndex++;
- if (m_animatedIndex < m_sequenceFrame) QTimer::singleShot(200, this, SLOT(slotAnimate()));
- else m_animatedIndex = -1;
+ if (m_animate) {
+ if (KdenliveSettings::showstopmotionthumbs()) {
+ int newRow = frame_list->currentRow() + 1;
+ if (KdenliveSettings::sm_loop() || newRow < frame_list->count()) {
+ if (newRow >= frame_list->count()) {
+ if (KdenliveSettings::sm_framesplayback() == 0) newRow = 0;
+ else {
+ // seek to correct frame
+ newRow = frame_list->count() - KdenliveSettings::sm_framesplayback();
+ }
+ }
+ frame_list->setCurrentRow(newRow);
+ QTimer::singleShot(100, this, SLOT(slotAnimate()));
+ return;
+ }
+ } else {
+ if (m_animatedIndex >= m_animationList.count()) {
+ if (KdenliveSettings::sm_loop()) m_animatedIndex = 0;
+ else m_animatedIndex = -1;
+ }
+ if (m_animatedIndex > -1) {
+ slotShowFrame(m_animationList.at(m_animatedIndex));
+ m_animatedIndex++;
+ QTimer::singleShot(100, this, SLOT(slotAnimate()));
+ return;
+ }
+ }
+ }
+ m_animate = false;
+ preview_button->setChecked(false);
+
}
-void StopmotionWidget::selectFrame(int ix)
+QListWidgetItem* StopmotionWidget::getFrameFromIndex(int ix)
{
- frame_list->blockSignals(true);
- QListWidgetItem *item = frame_list->item(ix);
- int current = item->data(Qt::UserRole + 1).toInt();
- if (current == ix) {
- frame_list->setCurrentItem(item);
- }
- else if (current < ix) {
- for (int i = ix; i < frame_list->count(); i++) {
- item = frame_list->item(i);
- current = item->data(Qt::UserRole + 1).toInt();
- if (current == ix) {
- frame_list->setCurrentItem(item);
- break;
- }
- }
+ QListWidgetItem* item = NULL;
+ int pos = ix;
+ if (ix >= frame_list->count()) {
+ pos = frame_list->count() - 1;
}
- else {
- for (int i = ix; i >= 0; i--) {
- item = frame_list->item(i);
- current = item->data(Qt::UserRole + 1).toInt();
- if (current == ix) {
- frame_list->setCurrentItem(item);
- break;
- }
- }
+ if (ix < 0) pos = 0;
+ item = frame_list->item(pos);
+
+ int value = item->data(Qt::UserRole).toInt();
+ if (value == ix) return item;
+ else if (value < ix) {
+ pos++;
+ while (pos < frame_list->count()) {
+ item = frame_list->item(pos);
+ value = item->data(Qt::UserRole).toInt();
+ if (value == ix) return item;
+ pos++;
+ }
+ } else {
+ pos --;
+ while (pos >= 0) {
+ item = frame_list->item(pos);
+ value = item->data(Qt::UserRole).toInt();
+ if (value == ix) return item;
+ pos --;
+ }
}
+ return NULL;
+}
+
+
+void StopmotionWidget::selectFrame(int ix)
+{
+ frame_list->blockSignals(true);
+ QListWidgetItem* item = getFrameFromIndex(ix);
+ if (!item)
+ return;
+ frame_list->setCurrentItem(item);
frame_list->blockSignals(false);
}
{
int ix = frame_list->currentRow();
if (forward) {
- if (ix < frame_list->count() - 1) frame_list->setCurrentRow(ix + 1);
+ if (ix < frame_list->count() - 1) frame_list->setCurrentRow(ix + 1);
+ } else if (ix > 0) frame_list->setCurrentRow(ix - 1);
+}
+
+void StopmotionWidget::slotRemoveFrame()
+{
+ if (frame_list->currentItem() == NULL) return;
+ QString path = frame_list->currentItem()->toolTip();
+ if (KMessageBox::questionYesNo(this, i18n("Delete frame %1 from disk?", path), i18n("Delete Frame")) != KMessageBox::Yes)
+ return;
+
+ QFile f(path);
+ if (f.remove()) {
+ QListWidgetItem* item = frame_list->takeItem(frame_list->currentRow());
+ int ix = item->data(Qt::UserRole).toInt();
+ if (ix == m_sequenceFrame - 1) {
+ // We are removing the last frame, update counter
+ QListWidgetItem* item2 = frame_list->item(frame_list->count() - 1);
+ if (item2) m_sequenceFrame = item2->data(Qt::UserRole).toInt() + 1;
+ }
+ delete item;
}
- else if (ix > 0) frame_list->setCurrentRow(ix - 1);
}
+void StopmotionWidget::slotSwitchAnalyse(bool isOn)
+{
+ KdenliveSettings::setAnalyse_stopmotion(isOn);
+ if (m_captureDevice) m_captureDevice->sendFrameForAnalysis = isOn;
+}
+
+void StopmotionWidget::slotSwitchMirror(bool isOn)
+{
+ //KdenliveSettings::setAnalyse_stopmotion(isOn);
+ if (m_captureDevice)
+ m_captureDevice->mirror(isOn);
+}
+
+
+const QString StopmotionWidget::createProducer(const MltVideoProfile &profile, const QString &service, const QString &resource)
+{
+ Q_UNUSED(profile)
+
+ QString playlist = "<mlt title=\"capture\"><producer id=\"producer0\" in=\"0\" out=\"99999\"><property name=\"mlt_type\">producer</property><property name=\"length\">100000</property><property name=\"eof\">pause</property><property name=\"resource\">" + resource + "</property><property name=\"mlt_service\">" + service + "</property></producer>";
+
+ // overlay track
+ playlist.append("<playlist id=\"playlist0\"></playlist>");
+
+ // video4linux track
+ playlist.append("<playlist id=\"playlist1\"><entry producer=\"producer0\" in=\"0\" out=\"99999\"/></playlist>");
+
+ playlist.append("<tractor id=\"tractor0\" title=\"video0\" global_feed=\"1\" in=\"0\" out=\"99999\">");
+ playlist.append("<track producer=\"playlist0\"/>");
+ playlist.append("<track producer=\"playlist1\"/>");
+ playlist.append("</tractor></mlt>");
+
+
+ return playlist;
+}
+
+
+
+#include "stopmotion.moc"
projects / kdenlive / blobdiff