git.sesse.net Git - kdenlive/blob - src/mltdevicecapture.cpp

   1 /***************************************************************************
   2                         mltdevicecapture.cpp  -  description
   3                            -------------------
   4    begin                : Sun May 21 2011
   5    copyright            : (C) 2011 by Jean-Baptiste Mardelle (jb@kdenlive.org)
   6
   7 ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18
  19 #include "mltdevicecapture.h"
  20 #include "kdenlivesettings.h"
  21 #include "definitions.h"
  22 //#include "recmonitor.h"
  23 //#include "renderer.h"
  24 #include "blackmagic/devices.h"
  25
  26 #include <mlt++/Mlt.h>
  27
  28 #include <KDebug>
  29 #include <KStandardDirs>
  30 #include <KMessageBox>
  31 #include <KLocale>
  32 #include <KTemporaryFile>
  33
  34 #include <QTimer>
  35 #include <QDir>
  36 #include <QString>
  37 #include <QApplication>
  38 #include <QThread>
  39
  40 #include <cstdlib>
  41 #include <cstdarg>
  42
  43 #include <QDebug>
  44
  45
  46
  47 static void consumer_gl_frame_show(mlt_consumer, MltDeviceCapture * self, mlt_frame frame_ptr)
  48 {
  49     // detect if the producer has finished playing. Is there a better way to do it?
  50     Mlt::Frame frame(frame_ptr);
  51     self->showFrame(frame);
  52 }
  53
  54 static void rec_consumer_frame_show(mlt_consumer, MltDeviceCapture * self, mlt_frame frame_ptr)
  55 {
  56     Mlt::Frame frame(frame_ptr);
  57     if (!frame.is_valid()) return;
  58     self->gotCapturedFrame(frame);
  59 }
  60
  61 static void rec_consumer_frame_preview(mlt_consumer, MltDeviceCapture * self, mlt_frame frame_ptr)
  62 {
  63     Mlt::Frame frame(frame_ptr);
  64     if (!frame.is_valid()) return;
  65     if (self->sendFrameForAnalysis && frame_ptr->convert_image) {
  66         self->emitFrameUpdated(frame);
  67     }
  68     if (self->doCapture > 0) {
  69         self->doCapture --;
  70         if (self->doCapture == 0) self->saveFrame(frame);
  71     }
  72
  73     //TODO: connect record monitor to audio scopes
  74
  75     if (self->analyseAudio) {
  76         self->showAudio(frame);
  77     }
  78
  79 }
  80
  81
  82 MltDeviceCapture::MltDeviceCapture(QString profile, VideoPreviewContainer *surface, QWidget *parent) :
  83     AbstractRender("capture", parent),
  84     doCapture(0),
  85     sendFrameForAnalysis(false),
  86     analyseAudio(KdenliveSettings::monitor_audio()),
  87     processingImage(false),
  88     m_mltConsumer(NULL),
  89     m_mltProducer(NULL),
  90     m_mltProfile(NULL),
  91     m_droppedFrames(0),
  92     m_livePreview(KdenliveSettings::recording_preview()),
  93     m_captureDisplayWidget(surface),
  94     m_winid((int) surface->winId())
  95 {
  96     if (profile.isEmpty()) profile = KdenliveSettings::current_profile();
  97     buildConsumer(profile);
  98     connect(this, SIGNAL(unblockPreview()), this, SLOT(slotPreparePreview()));
  99 }
 100
 101 MltDeviceCapture::~MltDeviceCapture()
 102 {
 103     if (m_mltConsumer) delete m_mltConsumer;
 104     if (m_mltProducer) delete m_mltProducer;
 105     if (m_mltProfile) delete m_mltProfile;
 106 }
 107
 108 void MltDeviceCapture::buildConsumer(const QString &profileName)
 109 {
 110     if (!profileName.isEmpty()) m_activeProfile = profileName;
 111
 112     if (m_mltProfile) delete m_mltProfile;
 113
 114     char *tmp = qstrdup(m_activeProfile.toUtf8().constData());
 115     setenv("MLT_PROFILE", tmp, 1);
 116     m_mltProfile = new Mlt::Profile(tmp);
 117     m_mltProfile->set_explicit(true);
 118     delete[] tmp;
 119
 120     QString videoDriver = KdenliveSettings::videodrivername();
 121     if (!videoDriver.isEmpty()) {
 122         if (videoDriver == "x11_noaccel") {
 123             setenv("SDL_VIDEO_YUV_HWACCEL", "0", 1);
 124             videoDriver = "x11";
 125         } else {
 126             unsetenv("SDL_VIDEO_YUV_HWACCEL");
 127         }
 128     }
 129     setenv("SDL_VIDEO_ALLOW_SCREENSAVER", "1", 1);
 130
 131     if (m_winid == 0) {
 132         // OpenGL monitor
 133         m_mltConsumer = new Mlt::Consumer(*m_mltProfile, "sdl_audio");
 134         m_mltConsumer->set("preview_off", 1);
 135         m_mltConsumer->set("preview_format", mlt_image_rgb24);
 136         m_mltConsumer->listen("consumer-frame-show", this, (mlt_listener) consumer_gl_frame_show);
 137     } else {
 138         m_mltConsumer = new Mlt::Consumer(*m_mltProfile, "sdl_preview");
 139         m_mltConsumer->set("window_id", m_winid);
 140         m_mltConsumer->listen("consumer-frame-show", this, (mlt_listener) rec_consumer_frame_preview);
 141     }
 142     //m_mltConsumer->set("resize", 1);
 143     //m_mltConsumer->set("terminate_on_pause", 1);
 144     m_mltConsumer->set("window_background", KdenliveSettings::window_background().name().toUtf8().constData());
 145     //m_mltConsumer->set("rescale", "nearest");
 146
 147     QString audioDevice = KdenliveSettings::audiodevicename();
 148     if (!audioDevice.isEmpty())
 149         m_mltConsumer->set("audio_device", audioDevice.toUtf8().constData());
 150
 151     if (!videoDriver.isEmpty())
 152         m_mltConsumer->set("video_driver", videoDriver.toUtf8().constData());
 153
 154     QString audioDriver = KdenliveSettings::audiodrivername();
 155
 156     if (!audioDriver.isEmpty())
 157         m_mltConsumer->set("audio_driver", audioDriver.toUtf8().constData());
 158
 159     //m_mltConsumer->set("progressive", 0);
 160     //m_mltConsumer->set("buffer", 1);
 161     //m_mltConsumer->set("real_time", 0);
 162 }
 163
 164 void MltDeviceCapture::stop()
 165 {
 166     bool isPlaylist = false;
 167     disconnect(this, SIGNAL(imageReady(QImage)), this, SIGNAL(frameUpdated(QImage)));
 168     m_captureDisplayWidget->stop();
 169
 170     if (m_mltConsumer) {
 171         m_mltConsumer->set("refresh", 0);
 172         m_mltConsumer->stop();
 173         //if (!m_mltConsumer->is_stopped()) m_mltConsumer->stop();
 174     }
 175     if (m_mltProducer) {
 176         QList <Mlt::Producer *> prods;
 177         Mlt::Service service(m_mltProducer->parent().get_service());
 178         mlt_service_lock(service.get_service());
 179         if (service.type() == tractor_type) {
 180             isPlaylist = true;
 181             Mlt::Tractor tractor(service);
 182             mlt_tractor_close(tractor.get_tractor());
 183             Mlt::Field *field = tractor.field();
 184             mlt_service nextservice = mlt_service_get_producer(service.get_service());
 185             mlt_service nextservicetodisconnect;
 186             mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
 187             QString mlt_type = mlt_properties_get(properties, "mlt_type");
 188             QString resource = mlt_properties_get(properties, "mlt_service");
 189             // Delete all transitions
 190             while (mlt_type == "transition") {
 191                 nextservicetodisconnect = nextservice;
 192                 nextservice = mlt_service_producer(nextservice);
 193                 mlt_field_disconnect_service(field->get_field(), nextservicetodisconnect);
 194                 if (nextservice == NULL) break;
 195                 properties = MLT_SERVICE_PROPERTIES(nextservice);
 196                 mlt_type = mlt_properties_get(properties, "mlt_type");
 197                 resource = mlt_properties_get(properties, "mlt_service");
 198             }
 199             delete field;
 200             field = NULL;
 201         }
 202         mlt_service_unlock(service.get_service());
 203         delete m_mltProducer;
 204         m_mltProducer = NULL;
 205     }
 206     // For some reason, the consumer seems to be deleted by previous stuff when in playlist mode
 207     if (!isPlaylist && m_mltConsumer) delete m_mltConsumer;
 208     m_mltConsumer = NULL;
 209 }
 210
 211
 212 void MltDeviceCapture::doRefresh()
 213 {
 214     if (m_mltConsumer) m_mltConsumer->set("refresh", 1);
 215 }
 216
 217
 218 void MltDeviceCapture::emitFrameUpdated(Mlt::Frame& frame)
 219 {
 220     /*
 221     //TEST: is it better to convert the frame in a thread outside of MLT??
 222     if (processingImage) return;
 223     mlt_image_format format = (mlt_image_format) frame.get_int("format"); //mlt_image_rgb24;
 224     int width = frame.get_int("width");
 225     int height = frame.get_int("height");
 226     unsigned char *buffer = (unsigned char *) frame.get_data("image");
 227     if (format == mlt_image_yuv422) {
 228         QtConcurrent::run(this, &MltDeviceCapture::uyvy2rgb, (unsigned char *) buffer, width, height);
 229     }
 230     */
 231
 232     mlt_image_format format = mlt_image_rgb24;
 233     int width = 0;
 234     int height = 0;
 235     const uchar* image = frame.get_image(format, width, height);
 236     QImage qimage(width, height, QImage::Format_ARGB32);
 237     memcpy(qimage.bits(), image, width * height * 3);
 238     emit frameUpdated(qimage.rgbSwapped());
 239 }
 240
 241 void MltDeviceCapture::showFrame(Mlt::Frame& frame)
 242 {
 243     mlt_image_format format = mlt_image_rgb24;
 244     int width = 0;
 245     int height = 0;
 246     const uchar* image = frame.get_image(format, width, height);
 247     QImage qimage(width, height, QImage::Format_RGB888);
 248     memcpy(qimage.scanLine(0), image, width * height * 3);
 249     emit showImageSignal(qimage);
 250
 251     if (sendFrameForAnalysis && frame.get_frame()->convert_image) {
 252         emit frameUpdated(qimage.rgbSwapped());
 253     }
 254 }
 255
 256 void MltDeviceCapture::showAudio(Mlt::Frame& frame)
 257 {
 258     if (!frame.is_valid() || frame.get_int("test_audio") != 0) {
 259         return;
 260     }
 261     mlt_audio_format audio_format = mlt_audio_s16;
 262     int freq = 0;
 263     int num_channels = 0;
 264     int samples = 0;
 265     int16_t* data = (int16_t*)frame.get_audio(audio_format, freq, num_channels, samples);
 266
 267     if (!data) {
 268         return;
 269     }
 270
 271     // Data format: [ c00 c10 c01 c11 c02 c12 c03 c13 ... c0{samples-1} c1{samples-1} for 2 channels.
 272     // So the vector is of size samples*channels.
 273     QVector<int16_t> sampleVector(samples*num_channels);
 274     memcpy(sampleVector.data(), data, samples*num_channels*sizeof(int16_t));
 275     if (samples > 0) {
 276         emit audioSamplesSignal(sampleVector, freq, num_channels, samples);
 277     }
 278 }
 279
 280 bool MltDeviceCapture::slotStartPreview(const QString &producer, bool xmlFormat)
 281 {
 282     if (m_mltConsumer == NULL) {
 283         buildConsumer();
 284     }
 285     char *tmp = qstrdup(producer.toUtf8().constData());
 286     if (xmlFormat) m_mltProducer = new Mlt::Producer(*m_mltProfile, "xml-string", tmp);
 287     else m_mltProducer = new Mlt::Producer(*m_mltProfile, tmp);
 288     delete[] tmp;
 289
 290     if (m_mltProducer == NULL || !m_mltProducer->is_valid()) {
 291         if (m_mltProducer) {
 292             delete m_mltProducer;
 293             m_mltProducer = NULL;
 294         }
 295         kDebug()<<"//// ERROR CREATRING PROD";
 296         return false;
 297     }
 298     m_mltConsumer->connect(*m_mltProducer);
 299     if (m_mltConsumer->start() == -1) {
 300         delete m_mltConsumer;
 301         m_mltConsumer = NULL;
 302         return 0;
 303     }
 304     connect(this, SIGNAL(imageReady(QImage)), this, SIGNAL(frameUpdated(QImage)));
 305     return 1;
 306 }
 307
 308 void MltDeviceCapture::gotCapturedFrame(Mlt::Frame& frame)
 309 {
 310     if (m_mltProducer) {
 311         int dropped = m_mltProducer->get_int("dropped");
 312         if (dropped > m_droppedFrames) {
 313             m_droppedFrames = dropped;
 314             emit droppedFrames(m_droppedFrames);
 315         }
 316     }
 317     m_frameCount++;
 318     if (m_livePreview == 2) return;
 319     if (m_livePreview == 0 && (m_frameCount % 10 > 0)) return;
 320     mlt_image_format format = mlt_image_rgb24;
 321     int width = 0;
 322     int height = 0;
 323     uint8_t *data = frame.get_image(format, width, height, 0);
 324     //QImage image(width, height, QImage::Format_RGB888);
 325     //memcpy(image.bits(), data, width * height * 3);
 326     QImage image((uchar *)data, width, height, QImage::Format_RGB888);
 327
 328     m_captureDisplayWidget->setImage(image);
 329
 330     //TEST: is it better to process frame conversion ouside MLT???
 331     /*
 332     if (!m_livePreview || processingImage) return;
 333
 334     mlt_image_format format = (mlt_image_format) frame.get_int("format"); //mlt_image_rgb24a;
 335     int width = frame.get_int("width");
 336     int height = frame.get_int("height");
 337     unsigned char *buffer = (unsigned char *) frame.get_data("image");
 338     //unsigned char *buffer = frame.get_image(format, width, height);
 339     //convert from uyvy422 to rgba
 340     if (format == mlt_image_yuv422) {
 341         QtConcurrent::run(this, &MltDeviceCapture::uyvy2rgb, (unsigned char *) buffer, width, height);
 342         //CaptureHandler::uyvy2rgb((uchar *)frameBytes, (uchar *)image.bits(), videoFrame->GetWidth(), videoFrame->GetHeight());
 343     }*/
 344 }
 345
 346 void MltDeviceCapture::saveFrame(Mlt::Frame& frame)
 347 {
 348     mlt_image_format format = mlt_image_rgb24;
 349     int width = 0;
 350     int height = 0;
 351     const uchar* image = frame.get_image(format, width, height);
 352     QImage qimage(width, height, QImage::Format_RGB888);
 353     memcpy(qimage.bits(), image, width * height * 3);
 354
 355     // Re-enable overlay
 356     Mlt::Service service(m_mltProducer->parent().get_service());
 357     Mlt::Tractor tractor(service);
 358     Mlt::Producer trackProducer(tractor.track(0));
 359     trackProducer.set("hide", 0);
 360
 361     qimage.save(m_capturePath);
 362     emit frameSaved(m_capturePath);
 363     m_capturePath.clear();
 364 }
 365
 366 void MltDeviceCapture::captureFrame(const QString &path)
 367 {
 368     if (m_mltProducer == NULL || !m_mltProducer->is_valid()) return;
 369
 370     // Hide overlay track before doing the capture
 371     Mlt::Service service(m_mltProducer->parent().get_service());
 372     Mlt::Tractor tractor(service);
 373     Mlt::Producer trackProducer(tractor.track(0));
 374     mlt_service_lock(service.get_service());
 375     trackProducer.set("hide", 1);
 376     m_mltConsumer->purge();
 377     mlt_service_unlock(service.get_service());
 378     m_capturePath = path;
 379     // Wait for 5 frames before capture to make sure overlay is gone
 380     doCapture = 5;
 381 }
 382
 383 bool MltDeviceCapture::slotStartCapture(const QString &params, const QString &path, const QString &playlist, int livePreview, bool xmlPlaylist)
 384 {
 385     stop();
 386     m_livePreview = livePreview;
 387     m_frameCount = 0;
 388     m_droppedFrames = 0;
 389     if (m_mltProfile) delete m_mltProfile;
 390     char *tmp = qstrdup(m_activeProfile.toUtf8().constData());
 391     m_mltProfile = new Mlt::Profile(tmp);
 392     delete[] tmp;
 393     m_mltProfile->get_profile()->is_explicit = 1;
 394     kDebug()<<"-- CREATING CAP: "<<params<<", PATH: "<<path;
 395     tmp = qstrdup(QString("avformat:" + path).toUtf8().constData());
 396     m_mltConsumer = new Mlt::Consumer(*m_mltProfile, tmp);
 397     m_mltConsumer->set("real_time", -KdenliveSettings::mltthreads());
 398     delete[] tmp;
 399
 400     QStringList paramList = params.split(" ", QString::SkipEmptyParts);
 401     char *tmp2;
 402     for (int i = 0; i < paramList.count(); i++) {
 403         tmp = qstrdup(paramList.at(i).section("=", 0, 0).toUtf8().constData());
 404         QString value = paramList.at(i).section("=", 1, 1);
 405         if (value == "%threads") value = QString::number(QThread::idealThreadCount());
 406         tmp2 = qstrdup(value.toUtf8().constData());
 407         m_mltConsumer->set(tmp, tmp2);
 408         delete[] tmp;
 409         delete[] tmp2;
 410     }
 411
 412     if (m_mltConsumer == NULL || !m_mltConsumer->is_valid()) {
 413         if (m_mltConsumer) {
 414             delete m_mltConsumer;
 415             m_mltConsumer = NULL;
 416         }
 417         return false;
 418     }
 419
 420     // FIXME: the event object returned by the listen gets leaked...
 421     if (m_livePreview < 2) m_mltConsumer->listen("consumer-frame-render", this, (mlt_listener) rec_consumer_frame_show);
 422     tmp = qstrdup(playlist.toUtf8().constData());
 423     if (xmlPlaylist) {
 424         // create an xml producer
 425         m_mltProducer = new Mlt::Producer(*m_mltProfile, "xml-string", tmp);
 426     }
 427     else {
 428         // create a producer based on mltproducer parameter
 429         m_mltProducer = new Mlt::Producer(*m_mltProfile, tmp);
 430     }
 431     delete[] tmp;
 432
 433     if (m_mltProducer == NULL || !m_mltProducer->is_valid()) {
 434         kDebug()<<"//// ERROR CREATRING PROD";
 435         return false;
 436     }
 437
 438     m_mltConsumer->connect(*m_mltProducer);
 439     if (m_mltConsumer->start() == -1) {
 440         delete m_mltConsumer;
 441         m_mltConsumer = NULL;
 442         return 0;
 443     }
 444     m_captureDisplayWidget->start();
 445     return 1;
 446 }
 447
 448
 449 void MltDeviceCapture::setOverlay(const QString &path)
 450 {
 451     if (m_mltProducer == NULL || !m_mltProducer->is_valid()) return;
 452     Mlt::Producer parentProd(m_mltProducer->parent());
 453     if (parentProd.get_producer() == NULL) {
 454         kDebug() << "PLAYLIST BROKEN, CANNOT INSERT CLIP //////";
 455         return;
 456     }
 457
 458     Mlt::Service service(parentProd.get_service());
 459     if (service.type() != tractor_type) {
 460         kWarning() << "// TRACTOR PROBLEM";
 461         return;
 462     }
 463     Mlt::Tractor tractor(service);
 464     if ( tractor.count() < 2) {
 465         kWarning() << "// TRACTOR PROBLEM";
 466         return;
 467     }
 468     mlt_service_lock(service.get_service());
 469     Mlt::Producer trackProducer(tractor.track(0));
 470     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
 471
 472     trackPlaylist.remove(0);
 473     if (path.isEmpty()) {
 474         mlt_service_unlock(service.get_service());
 475         return;
 476     }
 477
 478     // Add overlay clip
 479     char *tmp = qstrdup(path.toUtf8().constData());
 480     Mlt::Producer *clip = new Mlt::Producer (*m_mltProfile, "loader", tmp);
 481     delete[] tmp;
 482     clip->set_in_and_out(0, 99999);
 483     trackPlaylist.insert_at(0, clip, 1);
 484
 485     // Add transition
 486     mlt_service serv = m_mltProducer->parent().get_service();
 487     mlt_service nextservice = mlt_service_get_producer(serv);
 488     mlt_properties properties = MLT_SERVICE_PROPERTIES(nextservice);
 489     QString mlt_type = mlt_properties_get(properties, "mlt_type");
 490     if (mlt_type != "transition") {
 491         // transition does not exist, add it
 492         Mlt::Field *field = tractor.field();
 493         Mlt::Transition *transition = new Mlt::Transition(*m_mltProfile, "composite");
 494         transition->set_in_and_out(0, 0);
 495         transition->set("geometry", "0/0:100%x100%:70");
 496         transition->set("fill", 1);
 497         transition->set("operator", "and");
 498         transition->set("a_track", 0);
 499         transition->set("b_track", 1);
 500         field->plant_transition(*transition, 0, 1);
 501     }
 502     mlt_service_unlock(service.get_service());
 503     //delete clip;
 504 }
 505
 506 void MltDeviceCapture::setOverlayEffect(const QString &tag, QStringList parameters)
 507 {
 508     if (m_mltProducer == NULL || !m_mltProducer->is_valid()) return;
 509     Mlt::Service service(m_mltProducer->parent().get_service());
 510     Mlt::Tractor tractor(service);
 511     Mlt::Producer trackProducer(tractor.track(0));
 512     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
 513     Mlt::Service trackService(trackProducer.get_service());
 514
 515     mlt_service_lock(service.get_service());
 516
 517     // delete previous effects
 518     Mlt::Filter *filter;
 519     filter = trackService.filter(0);
 520     if (filter && !tag.isEmpty()) {
 521         QString currentService = filter->get("mlt_service");
 522         if (currentService == tag) {
 523             // Effect is already there
 524             mlt_service_unlock(service.get_service());
 525             return;
 526         }
 527     }
 528     while (filter) {
 529         trackService.detach(*filter);
 530         delete filter;
 531         filter = trackService.filter(0);
 532     }
 533
 534     if (tag.isEmpty()) {
 535         mlt_service_unlock(service.get_service());
 536         return;
 537     }
 538
 539     char *tmp = qstrdup(tag.toUtf8().constData());
 540     filter = new Mlt::Filter(*m_mltProfile, tmp);
 541     delete[] tmp;
 542     if (filter && filter->is_valid()) {
 543         for (int j = 0; j < parameters.count(); j++) {
 544             filter->set(parameters.at(j).section("=", 0, 0).toUtf8().constData(), parameters.at(j).section("=", 1, 1).toUtf8().constData());
 545         }
 546         trackService.attach(*filter);
 547     }
 548     mlt_service_unlock(service.get_service());
 549 }
 550
 551 void MltDeviceCapture::mirror(bool activate)
 552 {
 553     if (m_mltProducer == NULL || !m_mltProducer->is_valid()) return;
 554     Mlt::Service service(m_mltProducer->parent().get_service());
 555     Mlt::Tractor tractor(service);
 556     Mlt::Producer trackProducer(tractor.track(1));
 557     Mlt::Playlist trackPlaylist((mlt_playlist) trackProducer.get_service());
 558     Mlt::Service trackService(trackProducer.get_service());
 559
 560     mlt_service_lock(service.get_service());
 561
 562     // delete previous effects
 563     Mlt::Filter *filter;
 564     filter = trackService.filter(0);
 565     while (filter) {
 566         trackService.detach(*filter);
 567         delete filter;
 568         filter = trackService.filter(0);
 569     }
 570
 571     if (!activate) {
 572         mlt_service_unlock(service.get_service());
 573         return;
 574     }
 575
 576     filter = new Mlt::Filter(*m_mltProfile, "mirror");
 577     if (filter && filter->is_valid()) {
 578         filter->set("mirror", "flip");
 579         trackService.attach(*filter);
 580     }
 581     mlt_service_unlock(service.get_service());
 582 }
 583
 584 void MltDeviceCapture::uyvy2rgb(unsigned char *yuv_buffer, int width, int height)
 585 {
 586     processingImage = true;
 587     QImage image(width, height, QImage::Format_RGB888);
 588     unsigned char *rgb_buffer = image.bits();
 589
 590     int len;
 591     int r, g, b;
 592     int Y, U, V, Y2;
 593     int rgb_ptr, y_ptr, t;
 594
 595     len = width * height / 2;
 596
 597     rgb_ptr = 0;
 598     y_ptr = 0;
 599
 600     for (t = 0; t < len; t++) {
 601
 602
 603         Y = yuv_buffer[y_ptr];
 604         U = yuv_buffer[y_ptr+1];
 605         Y2 = yuv_buffer[y_ptr+2];
 606         V = yuv_buffer[y_ptr+3];
 607         y_ptr += 4;
 608
 609         r = ((298 * (Y - 16)               + 409 * (V - 128) + 128) >> 8);
 610
 611         g = ((298 * (Y - 16) - 100 * (U - 128) - 208 * (V - 128) + 128) >> 8);
 612
 613         b = ((298 * (Y - 16) + 516 * (U - 128)               + 128) >> 8);
 614
 615         if (r > 255) r = 255;
 616         if (g > 255) g = 255;
 617         if (b > 255) b = 255;
 618
 619         if (r < 0) r = 0;
 620         if (g < 0) g = 0;
 621         if (b < 0) b = 0;
 622
 623         rgb_buffer[rgb_ptr] = r;
 624         rgb_buffer[rgb_ptr+1] = g;
 625         rgb_buffer[rgb_ptr+2] = b;
 626         rgb_ptr += 3;
 627
 628
 629         r = ((298 * (Y2 - 16)               + 409 * (V - 128) + 128) >> 8);
 630
 631         g = ((298 * (Y2 - 16) - 100 * (U - 128) - 208 * (V - 128) + 128) >> 8);
 632
 633         b = ((298 * (Y2 - 16) + 516 * (U - 128)               + 128) >> 8);
 634
 635         if (r > 255) r = 255;
 636         if (g > 255) g = 255;
 637         if (b > 255) b = 255;
 638
 639         if (r < 0) r = 0;
 640         if (g < 0) g = 0;
 641         if (b < 0) b = 0;
 642
 643         rgb_buffer[rgb_ptr] = r;
 644         rgb_buffer[rgb_ptr+1] = g;
 645         rgb_buffer[rgb_ptr+2] = b;
 646         rgb_ptr += 3;
 647     }
 648     //emit imageReady(image);
 649     m_captureDisplayWidget->setImage(image);
 650     emit unblockPreview();
 651     //processingImage = false;
 652 }
 653
 654 void MltDeviceCapture::slotPreparePreview()
 655 {
 656     QTimer::singleShot(1000, this, SLOT(slotAllowPreview()));
 657 }
 658
 659 void MltDeviceCapture::slotAllowPreview()
 660 {
 661     processingImage = false;
 662 }
 663
 664