qtmobility/examples/audiorecorder/audiorecorder.cpp
changeset 14 6fbed849b4f4
parent 11 06b8e2af4411
child 15 1f895d8a5b2b
equal deleted inserted replaced
11:06b8e2af4411 14:6fbed849b4f4
    43 #include <qaudiocapturesource.h>
    43 #include <qaudiocapturesource.h>
    44 #include <qmediarecorder.h>
    44 #include <qmediarecorder.h>
    45 #include <qmediaservice.h>
    45 #include <qmediaservice.h>
    46 #include <qaudioencodercontrol.h>
    46 #include <qaudioencodercontrol.h>
    47 
    47 
    48 #include <QtMultimedia/qaudioformat.h>
    48 #include <qaudioformat.h>
    49 
    49 
    50 #include "audiorecorder.h"
    50 #include "audiorecorder.h"
    51 
    51 
    52 AudioRecorder::AudioRecorder()
    52 AudioRecorder::AudioRecorder()
    53 {
    53 {
    54     audiosource = new QAudioCaptureSource;
    54     audiosource = new QAudioCaptureSource;
    55     capture = new QMediaRecorder(audiosource);
    55     capture = new QMediaRecorder(audiosource);
    56 
    56 
    57     if (capture->supportedAudioCodecs().size() > 0) {
    57     if (capture->supportedAudioCodecs().size() > 0) {
    58         QAudioEncoderSettings audioSettings;
    58         QAudioEncoderSettings audioSettings;
    59         audioSettings.setQuality(QtMediaServices::LowQuality);
    59         audioSettings.setQuality(QtMultimedia::LowQuality);
    60         audioSettings.setEncodingMode(QtMediaServices::ConstantQualityEncoding);
    60         audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);
    61         audioSettings.setCodec(capture->supportedAudioCodecs().first());
    61         audioSettings.setCodec(capture->supportedAudioCodecs().first());
    62         capture->setEncodingSettings(audioSettings,QVideoEncoderSettings(),
    62         capture->setEncodingSettings(audioSettings,QVideoEncoderSettings(),
    63                 capture->supportedContainers().first());
    63                 capture->supportedContainers().first());
    64     }
    64     }
    65 
    65 
    80     deviceLabel->setText(tr("Audio Device"));
    80     deviceLabel->setText(tr("Audio Device"));
    81     deviceBox = new QComboBox(this);
    81     deviceBox = new QComboBox(this);
    82     deviceBox->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
    82     deviceBox->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
    83     deviceBox->setMinimumSize(200,10);
    83     deviceBox->setMinimumSize(200,10);
    84 
    84 
       
    85     QLabel* encmodeLabel = new QLabel;
       
    86     encmodeLabel->setText(tr("Encode Mode"));
       
    87     encModeBox = new QComboBox(this);
       
    88     encModeBox->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
       
    89     encModeBox->setMinimumSize(200,10);
       
    90 
    85     QLabel* containerLabel = new QLabel;
    91     QLabel* containerLabel = new QLabel;
    86     containerLabel->setText(tr("File Container"));
    92     containerLabel->setText(tr("File Container"));
    87     containersBox = new QComboBox(this);
    93     containersBox = new QComboBox(this);
    88     containersBox->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
    94     containersBox->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
    89     containersBox->setMinimumSize(200,10);
    95     containersBox->setMinimumSize(200,10);
   114 
   120 
   115     QList<QString> inputs = audiosource->audioInputs();
   121     QList<QString> inputs = audiosource->audioInputs();
   116     for(int i = 0; i < inputs.size(); i++)
   122     for(int i = 0; i < inputs.size(); i++)
   117         deviceBox->addItem(inputs.at(i));
   123         deviceBox->addItem(inputs.at(i));
   118 
   124 
       
   125     QList<QString> encmodes;
       
   126     encmodes <<"ConstantQuality"<<"ConstantBitRate";
       
   127     for(int i = 0; i < encmodes.size(); i++)
       
   128         encModeBox->addItem(encmodes.at(i));
       
   129 
   119     QStringList codecs = capture->supportedAudioCodecs();
   130     QStringList codecs = capture->supportedAudioCodecs();
       
   131     if (codecs.count() == 2)
       
   132         swap(codecs[0], codecs[1]);
   120     for(int i = 0; i < codecs.count(); i++)
   133     for(int i = 0; i < codecs.count(); i++)
   121         codecsBox->addItem(codecs.at(i));
   134         codecsBox->addItem(codecs.at(i));
   122 
   135 
   123     QStringList containers = capture->supportedContainers();
   136     QStringList containers = capture->supportedContainers();
   124     for(int i = 0; i < containers.count(); i++)
   137     for(int i = 0; i < containers.count(); i++)
   143 
   156 
   144     connect(capture, SIGNAL(durationChanged(qint64)), this, SLOT(updateProgress(qint64)));
   157     connect(capture, SIGNAL(durationChanged(qint64)), this, SLOT(updateProgress(qint64)));
   145     connect(capture, SIGNAL(stateChanged(QMediaRecorder::State)), this, SLOT(stateChanged(QMediaRecorder::State)));
   158     connect(capture, SIGNAL(stateChanged(QMediaRecorder::State)), this, SLOT(stateChanged(QMediaRecorder::State)));
   146     connect(capture, SIGNAL(error(QMediaRecorder::Error)), this, SLOT(errorChanged(QMediaRecorder::Error)));
   159     connect(capture, SIGNAL(error(QMediaRecorder::Error)), this, SLOT(errorChanged(QMediaRecorder::Error)));
   147 
   160 
       
   161     if (codecs.count() > 0) {
       
   162     QAudioEncoderSettings audioSettings;
       
   163     audioSettings.setQuality(QtMultimedia::LowQuality);
       
   164     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);
       
   165     audioSettings.setCodec(codecs.first());
       
   166     capture->setEncodingSettings(audioSettings,QVideoEncoderSettings(),
       
   167             containers.first());
       
   168     }
       
   169 
   148     layout->addWidget(deviceLabel,0,0,Qt::AlignHCenter);
   170     layout->addWidget(deviceLabel,0,0,Qt::AlignHCenter);
   149     connect(deviceBox,SIGNAL(activated(int)),SLOT(deviceChanged(int)));
   171     connect(deviceBox,SIGNAL(activated(int)),SLOT(deviceChanged(int)));
   150     layout->addWidget(deviceBox,0,1,1,3,Qt::AlignLeft);
   172     layout->addWidget(deviceBox,0,1,1,3,Qt::AlignLeft);
   151 
   173 
   152     layout->addWidget(containerLabel,1,0,Qt::AlignHCenter);
   174     layout->addWidget(encmodeLabel,1,0,Qt::AlignHCenter);
       
   175     connect(encModeBox,SIGNAL(activated(int)),SLOT(encmodeChanged(int)));
       
   176     layout->addWidget(encModeBox,1,1,1,3,Qt::AlignLeft);
       
   177 
       
   178     layout->addWidget(containerLabel,2,0,Qt::AlignHCenter);
   153     connect(containersBox,SIGNAL(activated(int)),SLOT(containerChanged(int)));
   179     connect(containersBox,SIGNAL(activated(int)),SLOT(containerChanged(int)));
   154     layout->addWidget(containersBox,1,1,1,3,Qt::AlignLeft);
   180     layout->addWidget(containersBox,2,1,1,3,Qt::AlignLeft);
   155 
   181 
   156     layout->addWidget(codecLabel,2,0,Qt::AlignHCenter);
   182     layout->addWidget(codecLabel,3,0,Qt::AlignHCenter);
   157     connect(codecsBox,SIGNAL(activated(int)),SLOT(codecChanged(int)));
   183     connect(codecsBox,SIGNAL(activated(int)),SLOT(codecChanged(int)));
   158     layout->addWidget(codecsBox,2,1,1,3,Qt::AlignLeft);   
   184     layout->addWidget(codecsBox,3,1,1,3,Qt::AlignLeft);
   159     
   185     
   160     layout->addWidget(sampleRateLabel,3,0,Qt::AlignHCenter);
   186     layout->addWidget(sampleRateLabel,4,0,Qt::AlignHCenter);
   161     connect(sampleRateBox,SIGNAL(activated(int)),SLOT(sampleRateChanged(int)));
   187     connect(sampleRateBox,SIGNAL(activated(int)),SLOT(sampleRateChanged(int)));
   162     layout->addWidget(sampleRateBox,3,1,1,3,Qt::AlignLeft);
   188     layout->addWidget(sampleRateBox,4,1,1,3,Qt::AlignLeft);
   163     
   189     
   164     layout->addWidget(channelLabel,4,0,Qt::AlignHCenter);
   190     layout->addWidget(channelLabel,5,0,Qt::AlignHCenter);
   165     connect(channelBox,SIGNAL(activated(int)),SLOT(channelCountChanged(int)));
   191     connect(channelBox,SIGNAL(activated(int)),SLOT(channelCountChanged(int)));
   166     layout->addWidget(channelBox,4,1,1,3,Qt::AlignLeft);
   192     layout->addWidget(channelBox,5,1,1,3,Qt::AlignLeft);
   167     
   193     
   168     layout->addWidget(qualityLabel,5,0,Qt::AlignHCenter);
   194     layout->addWidget(qualityLabel,6,0,Qt::AlignHCenter);
   169     connect(qualityBox,SIGNAL(activated(int)),SLOT(qualityChanged(int)));
   195     connect(qualityBox,SIGNAL(activated(int)),SLOT(qualityChanged(int)));
   170     layout->addWidget(qualityBox,5,1,1,3,Qt::AlignLeft);
   196     layout->addWidget(qualityBox,6,1,1,3,Qt::AlignLeft);
   171 
   197 
   172     fileButton = new QPushButton(this);
   198     fileButton = new QPushButton(this);
   173     fileButton->setText(tr("Output File"));    
   199     fileButton->setText(tr("Output File"));    
   174     connect(fileButton,SIGNAL(clicked()),SLOT(selectOutputFile()));
   200     connect(fileButton,SIGNAL(clicked()),SLOT(selectOutputFile()));
   175     layout->addWidget(fileButton,6,0,Qt::AlignHCenter);
   201     layout->addWidget(fileButton,7,0,Qt::AlignHCenter);
   176     
   202     
   177     pauseButton = new QPushButton(this);    
   203     pauseButton = new QPushButton(this);    
   178     pauseButton->setText(tr("Pause"));
   204     pauseButton->setText(tr("Pause"));
   179     connect(pauseButton,SIGNAL(clicked()),SLOT(togglePause()));
   205     connect(pauseButton,SIGNAL(clicked()),SLOT(togglePause()));
   180     layout->addWidget(pauseButton,6,1,Qt::AlignHCenter);
   206     layout->addWidget(pauseButton,7,1,Qt::AlignHCenter);
   181 
   207 
   182     button = new QPushButton(this);
   208     button = new QPushButton(this);
   183     button->setText(tr("Record"));
   209     button->setText(tr("Record"));
   184     connect(button,SIGNAL(clicked()),SLOT(toggleRecord()));
   210     connect(button,SIGNAL(clicked()),SLOT(toggleRecord()));
   185     layout->addWidget(button,6,2,Qt::AlignHCenter);
   211     layout->addWidget(button,7,2,Qt::AlignHCenter);
   186 
   212 
   187     statusLabel = new QLabel;
   213     statusLabel = new QLabel;
   188     statusLabel->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
   214     statusLabel->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
   189     statusLabel->setMinimumSize(130,10);
   215     statusLabel->setMinimumSize(130,10);
   190     statusLabel->setFrameStyle(QFrame::Panel | QFrame::Sunken);
   216     statusLabel->setFrameStyle(QFrame::Panel | QFrame::Sunken);
   191     statusLabel->setLineWidth(1);
   217     statusLabel->setLineWidth(1);
   192     layout->addWidget(statusLabel,7,0,Qt::AlignHCenter);
   218     layout->addWidget(statusLabel,8,0,Qt::AlignHCenter);
   193     
   219     
   194     QLabel* durationLabel = new QLabel;
   220     QLabel* durationLabel = new QLabel;
   195     durationLabel->setText(tr("Duration"));
   221     durationLabel->setText(tr("Duration"));
   196     layout->addWidget(durationLabel,7,1,Qt::AlignRight);
   222     layout->addWidget(durationLabel,8,1,Qt::AlignRight);
   197 
   223 
   198     recTime = new QLabel;
   224     recTime = new QLabel;
   199     layout->addWidget(recTime,7,2,Qt::AlignLeft);
   225     layout->addWidget(recTime,8,2,Qt::AlignLeft);
   200     
   226     
   201     window->setLayout(layout);
   227     window->setLayout(layout);
   202     setCentralWidget(window);
   228     setCentralWidget(window);
   203     window->show();
   229     window->show();
   204 
   230 
   302 { 
   328 { 
   303     QAudioEncoderSettings settings = capture->audioSettings();    
   329     QAudioEncoderSettings settings = capture->audioSettings();    
   304     
   330     
   305     switch(idx) {
   331     switch(idx) {
   306     case 0:
   332     case 0:
   307         settings.setQuality(QtMediaServices::LowQuality);
   333         settings.setQuality(QtMultimedia::LowQuality);
   308         break;
   334         break;
   309     case 1:
   335     case 1:
   310         settings.setQuality(QtMediaServices::NormalQuality);
   336         settings.setQuality(QtMultimedia::NormalQuality);
   311         break;
   337         break;
   312     default:
   338     default:
   313         settings.setQuality(QtMediaServices::HighQuality);
   339         settings.setQuality(QtMultimedia::HighQuality);
       
   340     }
       
   341     capture->setEncodingSettings(settings);
       
   342 }
       
   343 
       
   344 void AudioRecorder::encmodeChanged(int idx)
       
   345 {
       
   346     QAudioEncoderSettings settings = capture->audioSettings();
       
   347 
       
   348     switch(idx) {
       
   349     case 0:
       
   350         settings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);
       
   351         break;
       
   352     case 1:
       
   353         settings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
       
   354         break;
       
   355     default:
       
   356         settings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);
   314     }
   357     }
   315     capture->setEncodingSettings(settings);
   358     capture->setEncodingSettings(settings);
   316 }
   359 }
   317 
   360 
   318 void AudioRecorder::toggleRecord()
   361 void AudioRecorder::toggleRecord()
   321         if(!paused) {
   364         if(!paused) {
   322             recTime->setText("0");
   365             recTime->setText("0");
   323             currentTime = 0;
   366             currentTime = 0;
   324         }
   367         }
   325 #ifdef Q_OS_SYMBIAN    
   368 #ifdef Q_OS_SYMBIAN    
   326     capture->setOutputLocation(recordPathAudio(destination));
   369     if (!paused)    
       
   370         capture->setOutputLocation(recordPathAudio(destination));
   327 #endif
   371 #endif
   328         capture->record();        
   372         capture->record();        
   329         active = true;
   373         active = true;
   330         paused = false;
   374         paused = false;
   331     } else {
   375     } else {
   382     }    
   426     }    
   383 }
   427 }
   384 
   428 
   385 void AudioRecorder::updateChannelCount(int idx)
   429 void AudioRecorder::updateChannelCount(int idx)
   386 {    
   430 {    
   387     QAudioEncoderControl *audioEncoder = qobject_cast<QAudioEncoderControl*>(capture->service()->control(QAudioEncoderControl_iid));
   431     QMediaControl *control = audiosource->service()->requestControl(QAudioEncoderControl_iid);
       
   432     if (!control)
       
   433         return;
       
   434 
       
   435     QAudioEncoderControl *audioEncoder = qobject_cast<QAudioEncoderControl*>(control);
       
   436     if (!audioEncoder) {
       
   437         audiosource->service()->releaseControl(control);
       
   438         return;
       
   439     }
       
   440 
   388     channelBox->clear();
   441     channelBox->clear();
   389     QStringList list = audioEncoder->supportedEncodingOptions(codecsBox->itemText(idx));
   442     QStringList list = audioEncoder->supportedEncodingOptions(codecsBox->itemText(idx));
   390     QList<int> channels;
   443     QList<int> channels;
   391     if (list.contains("channels"))
   444     if (list.contains("channels"))
   392         channels <<1<<2;
   445         channels <<1<<2;
   398     }        
   451     }        
   399 }
   452 }
   400 
   453 
   401 void AudioRecorder::updateQuality(int idx)
   454 void AudioRecorder::updateQuality(int idx)
   402 {    
   455 {    
   403     QAudioEncoderControl *audioEncoder = qobject_cast<QAudioEncoderControl*>(capture->service()->control(QAudioEncoderControl_iid));
   456     QMediaControl *control = audiosource->service()->requestControl(QAudioEncoderControl_iid);
       
   457     if (!control)
       
   458         return;
       
   459 
       
   460     QAudioEncoderControl *audioEncoder = qobject_cast<QAudioEncoderControl*>(control);
       
   461     if (!audioEncoder) {
       
   462         audiosource->service()->releaseControl(control);
       
   463         return;
       
   464     }
       
   465 
   404     qualityBox->clear();
   466     qualityBox->clear();
   405     QStringList list = audioEncoder->supportedEncodingOptions(codecsBox->itemText(idx));
   467     QStringList list = audioEncoder->supportedEncodingOptions(codecsBox->itemText(idx));
   406     QList<int> channels;
   468     QList<int> channels;
   407     if (list.contains("quality")) {
   469     if (list.contains("quality")) {
   408         qualityBox->addItem(tr("Low"));
   470         qualityBox->addItem(tr("Low"));