1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "s60audioencodercontrol.h"

    43 #include "s60audiocapturesession.h"

    44 

    45 #include <QAudioFormat>

    46 

    47 #include <QtCore/qdebug.h>

    48 

    49 S60AudioEncoderControl::S60AudioEncoderControl(QObject *session, QObject *parent)

    50     :QAudioEncoderControl(parent)

    51 {

    52     qDebug()<<"S60AudioEncoderControl::S60AudioEncoderControl";

    53     QAudioFormat fmt;

    54     fmt.setSampleSize(8);

    55     fmt.setChannels(1);

    56     fmt.setFrequency(8000);

    57     fmt.setSampleType(QAudioFormat::SignedInt);

    58     //fmt.setCodec("audio/pcm");

    59 

    60     m_session = qobject_cast<S60AudioCaptureSession*>(session);

    61 }

    62 

    63 S60AudioEncoderControl::~S60AudioEncoderControl()

    64 {

    65 }

    66 

    67 QStringList S60AudioEncoderControl::supportedAudioCodecs() const

    68 {

    69     return m_session->supportedAudioCodecs();

    70 }

    71 

    72 QString S60AudioEncoderControl::audioCodec() const

    73 {

    74     return m_session->format().codec();

    75 }

    76 

    77 bool S60AudioEncoderControl::setAudioCodec(const QString &codecName)

    78 {

    79     QAudioFormat fmt = m_session->format();

    80     fmt.setCodec(codecName);

    81     return m_session->setFormat(fmt);

    82 }

    83 

    84 QString S60AudioEncoderControl::codecDescription(const QString &codecName) const

    85 {

    86 	return m_session->codecDescription(codecName);    

    87 }

    88 

    89 int S60AudioEncoderControl::bitRate() const

    90 {

    91     return (m_session->format().frequency() * m_session->format().channels() * (m_session->format().sampleSize() / 8));

    92 }

    93 

    94 void S60AudioEncoderControl::setBitRate(int value)

    95 {

    96     Q_UNUSED(value)

    97 }

    98 

    99 QtMedia::EncodingQuality S60AudioEncoderControl::quality() const

   100 {

   101     return QtMedia::NormalQuality;

   102 }

   103 

   104 void S60AudioEncoderControl::setQuality(QtMedia::EncodingQuality value)

   105 {

   106     QAudioFormat fmt = m_session->format();

   107 

   108     switch (value) {

   109         case QtMedia::VeryLowQuality:

   110         case QtMedia::LowQuality:

   111             // low, 8000Hz mono U8

   112             fmt.setSampleType(QAudioFormat::UnSignedInt);

   113             fmt.setSampleSize(8);

   114             fmt.setFrequency(8000);

   115             fmt.setChannels(1);

   116             break;

   117         case QtMedia::NormalQuality:

   118             // medium, 22050Hz mono S16

   119             fmt.setSampleType(QAudioFormat::SignedInt);

   120             fmt.setSampleSize(16);

   121             fmt.setFrequency(22050);

   122             fmt.setChannels(1);

   123             break;

   124         case QtMedia::HighQuality:

   125         case QtMedia::VeryHighQuality:    

   126             // high, 44100Hz mono S16

   127             fmt.setSampleType(QAudioFormat::SignedInt);

   128             fmt.setSampleSize(16);

   129             fmt.setFrequency(44100);

   130             fmt.setChannels(1);

   131             break;

   132         default:

   133             break;

   134     }

   135     m_session->setFormat(fmt);

   136 }

   137 

   138 QStringList S60AudioEncoderControl::supportedEncodingOptions(const QString &codec) const

   139 {

   140     Q_UNUSED(codec)

   141 

   142     QStringList list;

   143     return list;

   144 }

   145 

   146 QVariant S60AudioEncoderControl::encodingOption(const QString &codec, const QString &name) const

   147 {

   148     Q_UNUSED(codec)

   149 	QAudioFormat fmt = m_session->format();

   150     

   151     if(qstrcmp(name.toLocal8Bit().constData(), "bitrate") == 0) {

   152         return QVariant(fmt.frequency());

   153     }

   154 

   155     return QVariant();

   156 }

   157 

   158 void S60AudioEncoderControl::setEncodingOption(

   159         const QString &codec, const QString &name, const QVariant &value)

   160 {

   161     Q_UNUSED(value)

   162     Q_UNUSED(codec)

   163 

   164     //QAudioFormat fmt = m_session->format();

   165 

   166     if(qstrcmp(name.toLocal8Bit().constData(), "bitrate") == 0) {

   167         if (value.toString() == "vbr")

   168             setBitRate(-1);

   169         else

   170             setBitRate(value.toInt());

   171 

   172     } else if(qstrcmp(name.toLocal8Bit().constData(), "quality") == 0) {

   173         setQuality((QtMedia::EncodingQuality)value.toInt());

   174 

   175     } else

   176         qWarning() << "option: " << name << " is an unknown option!";

   177 }

   178 

   179 int S60AudioEncoderControl::sampleRate() const

   180 {

   181     return m_session->format().frequency();

   182 }

   183 

   184 void S60AudioEncoderControl::setSampleRate(int sampleRate)

   185 {

   186     if (sampleRate > 0) {

   187         QAudioFormat fmt = m_session->format();

   188         fmt.setFrequency(sampleRate);

   189         m_session->setFormat(fmt);

   190     }

   191 }

   192 

   193 QList<int> S60AudioEncoderControl::supportedSampleRates(const QAudioEncoderSettings &settings, bool *continuous) const

   194 {

   195     if (continuous)

   196         *continuous = false;

   197     

   198     return m_session->supportedAudioSampleRates();       

   199 }

   200 

   201 int S60AudioEncoderControl::channelCount() const

   202 {

   203     return m_session->format().channels();

   204 }

   205 

   206 void S60AudioEncoderControl::setChannelCount(int channels)

   207 {

   208     if (channels > 0) {

   209         QAudioFormat fmt = m_session->format();

   210         fmt.setChannels(channels);

   211         m_session->setFormat(fmt);

   212     }

   213 }

   214 

   215 QList<int> S60AudioEncoderControl::supportedChannelCounts() const

   216 {

   217     return QList<int>() << 1 << 2;

   218 }

   219 

   220 int S60AudioEncoderControl::sampleSize() const

   221 {

   222     return m_session->format().sampleSize();

   223 }

   224 

   225 void S60AudioEncoderControl::setSampleSize(int sampleSize)

   226 {

   227     QAudioFormat fmt = m_session->format();

   228     fmt.setSampleSize(sampleSize);

   229     m_session->setFormat(fmt);

   230 }

   231 

   232 QList<int> S60AudioEncoderControl::supportedSampleSizes() const

   233 {

   234     //QList<int> sizes = m_session->deviceInfo()->supportedSampleSizes();

   235     return QList<int>(); //sizes;

   236 }

   237 

   238 QAudioEncoderSettings S60AudioEncoderControl::audioSettings() const

   239 {

   240     QAudioEncoderSettings settings;

   241     settings.setCodec(audioCodec());

   242     settings.setBitRate(bitRate());

   243     settings.setQuality(quality());

   244     settings.setSampleRate(sampleRate());

   245     settings.setChannelCount(channelCount());

   246     return settings;

   247 }

   248 

   249 void S60AudioEncoderControl::setAudioSettings(const QAudioEncoderSettings &settings)

   250 {

   251     setAudioCodec(settings.codec());

   252     setBitRate(settings.bitRate());

   253     setSampleRate(settings.sampleRate());

   254     setChannelCount(settings.channelCount());

   255     // Setting quality will override other settings except codec

   256     setQuality(settings.quality());

   257 }