#include "../blackmagic/devices.h"
#include "../v4l/v4lcapture.h"
#include "../slideshowclip.h"
+#include "../profilesdialog.h"
+#include "../mltdevicecapture.h"
+#include "../recmonitor.h"
+#include "../monitormanager.h"
#include "ui_smconfig_ui.h"
#include "kdenlivesettings.h"
}
-StopmotionWidget::StopmotionWidget(KUrl projectFolder, QList< QAction* > actions, QWidget* parent) :
+StopmotionMonitor::StopmotionMonitor(QWidget *parent) :
+ AbstractMonitor(parent),
+ m_captureDevice(NULL)
+{
+}
+
+StopmotionMonitor::~StopmotionMonitor()
+{
+}
+
+void StopmotionMonitor::setRender(MltDeviceCapture *render)
+{
+ m_captureDevice = render;
+}
+
+AbstractRender *StopmotionMonitor::abstractRender()
+{
+ return m_captureDevice;
+}
+
+const QString StopmotionMonitor::name() const
+{
+ return QString("stopmotion");
+}
+
+
+void StopmotionMonitor::stop()
+{
+ if (m_captureDevice) m_captureDevice->stop();
+ emit stopCapture();
+}
+
+void StopmotionMonitor::start()
+{
+}
+
+StopmotionWidget::StopmotionWidget(MonitorManager *manager, KUrl projectFolder, QList< QAction* > actions, QWidget* parent) :
QDialog(parent)
, Ui::Stopmotion_UI()
, m_projectFolder(projectFolder)
- , m_bmCapture(NULL)
+ , m_captureDevice(NULL)
, m_sequenceFrame(0)
, m_animatedIndex(-1)
, m_animate(false)
+ , m_manager(manager)
+ , m_monitor(new StopmotionMonitor(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());
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"));
capture_button->setEnabled(false);
+
// Build config menu
QMenu* confMenu = new QMenu;
config_button->setIcon(KIcon("configure"));
config_button->setMenu(confMenu);
- // Build capture menu
- QMenu* capMenu = new QMenu;
- m_intervalCapture = new QAction(KIcon("edit-redo"), i18n("Interval capture"), this);
- m_intervalCapture->setCheckable(true);
- m_intervalCapture->setChecked(false);
- connect(m_intervalCapture, SIGNAL(triggered(bool)), this, SLOT(slotIntervalCapture(bool)));
- capMenu->addAction(m_intervalCapture);
- capture_button->setMenu(capMenu);
-
connect(sequence_name, SIGNAL(textChanged(const QString&)), this, SLOT(sequenceNameChanged(const QString&)));
connect(sequence_name, SIGNAL(currentIndexChanged(int)), live_button, SLOT(setFocus()));
- m_layout = new QVBoxLayout;
+ // Video widget holder
+ QVBoxLayout *layout = new QVBoxLayout;
+ layout->setContentsMargins(0, 0, 0, 0);
+ layout->setSpacing(0);
+ m_videoBox = new VideoPreviewContainer();
+ m_videoBox->setContentsMargins(0, 0, 0, 0);
+ m_videoBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+ //m_videoBox->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+ m_videoBox->setLineWidth(4);
+ layout->addWidget(m_videoBox);
+
+
if (BMInterface::getBlackMagicDeviceList(capture_device, NULL)) {
// Found a BlackMagic device
- m_bmCapture = new BmdCaptureHandler(m_layout);
- connect(m_bmCapture, SIGNAL(gotMessage(const QString&)), this, SLOT(slotGotHDMIMessage(const QString&)));
+ //m_bmCapture = new BmdCaptureHandler(m_layout);
+ //connect(m_bmCapture, SIGNAL(gotMessage(const QString&)), this, SLOT(slotGotHDMIMessage(const QString&)));
}
if (QFile::exists(KdenliveSettings::video4vdevice())) {
#if !defined(Q_WS_MAC) && !defined(Q_OS_FREEBSD)
- V4lCaptureHandler v4l(NULL);
// 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 = v4l.getDeviceName(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);
}
}
- /*V4lCaptureHandler v4lhandler(NULL);
- QStringList deviceInfo = v4lhandler.getDeviceName(KdenliveSettings::video4vdevice());
- capture_device->addItem(deviceInfo.at(0), "v4l");
- capture_device->setItemData(capture_device->count() - 1, deviceInfo.at(3), Qt::UserRole + 1);*/
- if (m_bmCapture == NULL) {
- 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());
- }
+ //if (m_bmCapture == NULL) {
+
+ //m_captureDevice->sendFrameForAnalysis = m_analyse;
+ /*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
}
connect(capture_device, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdateHandler()));
- if (m_bmCapture) {
+ /*if (m_bmCapture) {
connect(m_bmCapture, SIGNAL(frameSaved(const QString)), this, SLOT(slotNewThumb(const QString)));
connect(m_bmCapture, SIGNAL(gotFrame(QImage)), this, SIGNAL(gotFrame(QImage)));
- } else live_button->setEnabled(false);
+ } else live_button->setEnabled(false);*/
+
m_frame_preview = new MyLabel(this);
connect(m_frame_preview, SIGNAL(seek(bool)), this, SLOT(slotSeekFrame(bool)));
connect(m_frame_preview, SIGNAL(switchToLive()), this, SLOT(slotSwitchLive()));
- m_layout->addWidget(m_frame_preview);
+ layout->addWidget(m_frame_preview);
m_frame_preview->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
- video_preview->setLayout(m_layout);
+ video_preview->setLayout(layout);
+
+ //kDebug()<<video_preview->winId();
+
+ QString path = KStandardDirs::locateLocal("appdata", "profiles/video4linux");
+ m_captureDevice = new MltDeviceCapture(path, m_videoBox, this);
+ m_captureDevice->sendFrameForAnalysis = KdenliveSettings::analyse_stopmotion();
+ m_monitor->setRender(m_captureDevice);
+ connect(m_captureDevice, SIGNAL(frameSaved(const QString)), this, SLOT(slotNewThumb(const QString)));
+
live_button->setChecked(false);
button_addsequence->setEnabled(false);
connect(live_button, SIGNAL(toggled(bool)), this, SLOT(slotLive(bool)));
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()
{
- if (m_bmCapture)
- m_bmCapture->stopPreview();
+ /*if (m_bmCapture)
+ m_bmCapture->stopPreview();*/
+ if (m_captureDevice) {
+ m_captureDevice->stop();
+ delete m_captureDevice;
+ m_captureDevice = NULL;
+ }
+
+ delete m_monitor;
}
void StopmotionWidget::slotUpdateOverlayEffect(QAction* act)
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);
}
}
frame_list->setHidden(!show);
}
-void StopmotionWidget::slotIntervalCapture(bool capture)
-{
- if (capture) slotCaptureFrame();
-}
-
void StopmotionWidget::slotUpdateHandler()
{
- QString data = capture_device->itemData(capture_device->currentIndex()).toString();
+ /*QString data = capture_device->itemData(capture_device->currentIndex()).toString();
slotLive(false);
if (m_bmCapture) {
delete m_bmCapture;
if (m_bmCapture) connect(m_bmCapture, SIGNAL(gotMessage(const QString&)), this, SLOT(slotGotHDMIMessage(const QString&)));
}
live_button->setEnabled(m_bmCapture != NULL);
- m_layout->addWidget(m_frame_preview);
+ m_layout->addWidget(m_frame_preview);*/
}
void StopmotionWidget::slotGotHDMIMessage(const QString& message)
void StopmotionWidget::slotSwitchLive()
{
setUpdatesEnabled(false);
- if (m_frame_preview->isHidden()) {
- if (m_bmCapture) m_bmCapture->hidePreview(true);
+ slotLive(!live_button->isChecked());
+ /*if (m_frame_preview->isHidden()) {
+ //if (m_bmCapture) m_bmCapture->hidePreview(true);
+ m_videoBox->setHidden(true);
m_frame_preview->setHidden(false);
} else {
m_frame_preview->setHidden(true);
- if (m_bmCapture) m_bmCapture->hidePreview(false);
+ //if (m_bmCapture) m_bmCapture->hidePreview(false);
+ m_videoBox->setHidden(false);
capture_button->setEnabled(true);
- }
+ }*/
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->setHidden(true);
+ m_videoBox->setHidden(false);
+ QString path = KStandardDirs::locateLocal("appdata", "profiles/video4linux");
+
+ kDebug()<<"SURFACE; "<<m_videoBox->width()<<"x"<<m_videoBox->height();
+ if (m_captureDevice == NULL) {
+ m_captureDevice = new MltDeviceCapture(path, m_videoBox, this);
+ m_captureDevice->sendFrameForAnalysis = KdenliveSettings::analyse_stopmotion();
+ m_monitor->setRender(m_captureDevice);
+ connect(m_captureDevice, SIGNAL(frameSaved(const QString)), this, SLOT(slotNewThumb(const QString)));
+ }
+
+ MltVideoProfile profile = ProfilesDialog::getVideoProfile(path);
+ m_manager->activateMonitor("stopmotion");
+ QString producer = QString("avformat-novalidate:video4linux2:%1?width:%2&height:%3&frame_rate:%4").arg(KdenliveSettings::video4vdevice()).arg(profile.width).arg(profile.height).arg((double) profile.frame_rate_num / profile.frame_rate_den);
+ if (m_captureDevice->slotStartPreview(producer)) {
+ kDebug()<<"// STARt CAPTURE GO";
+ capture_button->setEnabled(true);
+ live_button->setChecked(true);
+ log_box->insertItem(-1, i18n("Playing %1x%2 (%3 fps)", profile.width, profile.height, QString::number((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_frame_preview->setHidden(false);
+ live_button->setChecked(false);
+ if (m_captureDevice) {
+ m_captureDevice->stop();
+ m_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_frame_preview->setHidden(false);
capture_button->setEnabled(false);
live_button->setChecked(false);
- }
+ }*/
live_button->blockSignals(false);
}
-void StopmotionWidget::slotShowOverlay(bool isOn)
+void StopmotionWidget::slotShowOverlay(bool /*isOn*/)
{
- if (isOn) {
+/* if (isOn) {
if (live_button->isChecked() && m_sequenceFrame > 0) {
slotUpdateOverlay();
}
} else if (m_bmCapture) {
m_bmCapture->hideOverlay();
- }
+ }*/
}
void StopmotionWidget::slotUpdateOverlay()
{
- if (m_bmCapture == NULL) return;
+ if (m_captureDevice == NULL) return;
QString path = getPathForFrame(m_sequenceFrame - 1);
if (!QFile::exists(path)) return;
QImage img(path);
}
#endif
- m_bmCapture->showOverlay(img);
+ //m_bmCapture->showOverlay(img);
}
void StopmotionWidget::sequenceNameChanged(const QString& name)
void StopmotionWidget::slotCaptureFrame()
{
- if (m_bmCapture == NULL) return;
+ 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;
+ if (seqName.isEmpty()) {
+ m_captureAction->setChecked(false);
+ return;
+ }
sequence_name->blockSignals(true);
sequence_name->setItemText(sequence_name->currentIndex(), seqName);
sequence_name->blockSignals(false);
m_sequenceFrame = 0;
}
//capture_button->setEnabled(false);
+ if (m_intervalTimer.isActive()) {
+ // stop interval capture
+ m_intervalTimer.stop();
+ return;
+ }
QString currentPath = getPathForFrame(m_sequenceFrame);
- m_bmCapture->captureFrame(currentPath);
+ m_captureDevice->captureFrame(currentPath);
KNotification::event("FrameCaptured", i18n("Frame Captured"), QPixmap(), this);
m_sequenceFrame++;
button_addsequence->setEnabled(true);
- if (m_intervalCapture->isChecked()) QTimer::singleShot(KdenliveSettings::captureinterval() * 1000, this, SLOT(slotCaptureFrame()));
+ 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::slotPreNotify()
+{
+ if (m_captureAction->isChecked()) KNotification::event("ReadyToCapture", i18n("Going to Capture Frame"), QPixmap(), this);
}
capture_button->setEnabled(false);
slotLive(false);
if (!img.isNull()) {
- if (m_bmCapture) m_bmCapture->hidePreview(true);
+ //m_videoBox->setHidden(true);
+
m_frame_preview->setImage(img);
m_frame_preview->setHidden(false);
m_frame_preview->update();
void StopmotionWidget::slotSwitchAnalyse(bool isOn)
{
KdenliveSettings::setAnalyse_stopmotion(isOn);
- m_bmCapture->setAnalyse(isOn);
+ if (m_captureDevice) m_captureDevice->sendFrameForAnalysis = isOn;
+ //m_bmCapture->setAnalyse(isOn);
}
projects / kdenlive / blobdiff