Mercurial Mercurial > oss > FCL > sf > mw > qtextensions / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
qtmobility/plugins/multimedia/symbian/mmf/audiosource/s60audioencodercontrol.cpp
changeset 5 453da2cfceef
parent 4 90517678cc4f
child 11 06b8e2af4411
equal deleted inserted replaced
4:90517678cc4f 5:453da2cfceef 
    45 #include <QAudioFormat>
 
    45 #include <QAudioFormat>
 
    46 
    46 
    47 #include <QtCore/qdebug.h>
 
    47 #include <QtCore/qdebug.h>
 
    48 
    48 
    49 S60AudioEncoderControl::S60AudioEncoderControl(QObject *session, QObject *parent)
 
    49 S60AudioEncoderControl::S60AudioEncoderControl(QObject *session, QObject *parent)
 
    50     :QAudioEncoderControl(parent)
 
    50     :QAudioEncoderControl(parent), m_quality(QtMediaServices::NormalQuality)
 
    51 {
 
    51 {   
    52     qDebug()<<"S60AudioEncoderControl::S60AudioEncoderControl";
 
    52     m_session = qobject_cast<S60AudioCaptureSession*>(session);
 
    53     QAudioFormat fmt;
 
    53     QAudioFormat fmt = m_session->format();
 
    54     fmt.setSampleSize(8);
 
    54     // medium, 22050Hz mono S16
 
       
    55     fmt.setSampleType(QAudioFormat::SignedInt);
 
       
    56     fmt.setSampleSize(16);
 
       
    57     fmt.setFrequency(22050);
 
    55     fmt.setChannels(1);
 
    58     fmt.setChannels(1);
 
    56     fmt.setFrequency(8000);
 
    59     m_session->setFormat(fmt);
 
    57     fmt.setSampleType(QAudioFormat::SignedInt);
 
       
    58     //fmt.setCodec("audio/pcm");
 
       
    59 
       
    60     m_session = qobject_cast<S60AudioCaptureSession*>(session);
 
       
    61 }
 
    60 }
 
    62 
    61 
    63 S60AudioEncoderControl::~S60AudioEncoderControl()
 
    62 S60AudioEncoderControl::~S60AudioEncoderControl()
 
    64 {
 
    63 {
 
    65 }
 
    64 }
 
    92 }
 
    91 }
 
    93 
    92 
    94 void S60AudioEncoderControl::setBitRate(int value)
 
    93 void S60AudioEncoderControl::setBitRate(int value)
 
    95 {
 
    94 {
 
    96     Q_UNUSED(value)
 
    95     Q_UNUSED(value)
 
    97 }
 
    96     //Note: None of the default codecs provided in the MMF support the setting of bit rates.                
    98 
    97 }
 
    99 QtMedia::EncodingQuality S60AudioEncoderControl::quality() const
 
    98 
   100 {
 
    99 QtMediaServices::EncodingQuality S60AudioEncoderControl::quality() const
 
   101     return QtMedia::NormalQuality;
 
   100 {
 
   102 }
 
   101     return m_quality;
 
   103 
   102 }
 
   104 void S60AudioEncoderControl::setQuality(QtMedia::EncodingQuality value)
 
   103 
       
   104 void S60AudioEncoderControl::setQuality(QtMediaServices::EncodingQuality value)
 
   105 {
 
   105 {
 
   106     QAudioFormat fmt = m_session->format();
 
   106     QAudioFormat fmt = m_session->format();
 
   107 
   107 
   108     switch (value) {
 
   108     switch (value) {
 
   109         case QtMedia::VeryLowQuality:
 
   109     case QtMediaServices::VeryLowQuality:
 
   110         case QtMedia::LowQuality:
 
   110     case QtMediaServices::LowQuality:
 
   111             // low, 8000Hz mono U8
 
   111         // low, 8000Hz mono U8
 
   112             fmt.setSampleType(QAudioFormat::UnSignedInt);
 
   112         fmt.setSampleType(QAudioFormat::UnSignedInt);
 
   113             fmt.setSampleSize(8);
 
   113         fmt.setSampleSize(8);
 
   114             fmt.setFrequency(8000);
 
   114         fmt.setFrequency(8000);
 
   115             fmt.setChannels(1);
 
   115         fmt.setChannels(1);
 
   116             break;
 
   116         break;
 
   117         case QtMedia::NormalQuality:
 
   117     case QtMediaServices::NormalQuality:
 
   118             // medium, 22050Hz mono S16
 
   118         // medium, 22050Hz mono S16
 
   119             fmt.setSampleType(QAudioFormat::SignedInt);
 
   119         fmt.setSampleType(QAudioFormat::SignedInt);
 
   120             fmt.setSampleSize(16);
 
   120         fmt.setSampleSize(16);
 
   121             fmt.setFrequency(22050);
 
   121         fmt.setFrequency(22050);
 
   122             fmt.setChannels(1);
 
   122         fmt.setChannels(1);
 
   123             break;
 
   123         break;
 
   124         case QtMedia::HighQuality:
 
   124     case QtMediaServices::HighQuality:
 
   125         case QtMedia::VeryHighQuality:    
   125     case QtMediaServices::VeryHighQuality:    
   126             // high, 44100Hz mono S16
 
   126         // high, 44100Hz mono S16
 
   127             fmt.setSampleType(QAudioFormat::SignedInt);
 
   127         fmt.setSampleType(QAudioFormat::SignedInt);
 
   128             fmt.setSampleSize(16);
 
   128         fmt.setSampleSize(16);
 
   129             fmt.setFrequency(44100);
 
   129         fmt.setFrequency(44100);
 
   130             fmt.setChannels(1);
 
   130         fmt.setChannels(1);
 
   131             break;
 
   131         break;
 
   132         default:
 
   132     default:
 
   133             break;
 
   133         break;
 
   134     }
 
   134     }
 
   135     m_session->setFormat(fmt);
 
   135     m_session->setFormat(fmt);
 
       
   136     m_quality = value;  
   136 }
 
   137 }
 
   137 
   138 
   138 QStringList S60AudioEncoderControl::supportedEncodingOptions(const QString &codec) const
 
   139 QStringList S60AudioEncoderControl::supportedEncodingOptions(const QString &codec) const
 
   139 {
 
   140 {
 
   140     Q_UNUSED(codec)
 
   141     Q_UNUSED(codec)
 
   141 
       
   142     QStringList list;
 
   142     QStringList list;
 
   143     return list;
 
   143     if (codec == "PCM") 
       
   144         list << "quality" << "channels" << "samplerate";        
       
   145      return list;
 
   144 }
 
   146 }
 
   145 
   147 
   146 QVariant S60AudioEncoderControl::encodingOption(const QString &codec, const QString &name) const
 
   148 QVariant S60AudioEncoderControl::encodingOption(const QString &codec, const QString &name) const
 
   147 {
 
   149 {
 
   148     Q_UNUSED(codec)
 
   150     if (codec == "PCM") {
 
   149 	QAudioFormat fmt = m_session->format();
 
   151         QAudioFormat fmt = m_session->format();
 
   150     
   152         
   151     if(qstrcmp(name.toLocal8Bit().constData(), "bitrate") == 0) {
 
   153         if(qstrcmp(name.toLocal8Bit().constData(), "bitrate") == 0) {
 
   152         return QVariant(fmt.frequency());
 
   154             return QVariant(bitRate());
 
       
   155         }
 
       
   156         else if(qstrcmp(name.toLocal8Bit().constData(), "quality") == 0) {
 
       
   157             return QVariant(quality());
 
       
   158         }        
       
   159         else if(qstrcmp(name.toLocal8Bit().constData(), "channels") == 0) {
 
       
   160             return QVariant(fmt.channels());
 
       
   161         }                
       
   162         else if(qstrcmp(name.toLocal8Bit().constData(), "samplerate") == 0) {
 
       
   163             return QVariant(fmt.frequency());
 
       
   164         }       
   153     }
 
   165     }
 
   154 
       
   155     return QVariant();
 
   166     return QVariant();
 
   156 }
 
   167 }
 
   157 
   168 
   158 void S60AudioEncoderControl::setEncodingOption(
 
   169 void S60AudioEncoderControl::setEncodingOption(
 
   159         const QString &codec, const QString &name, const QVariant &value)
 
   170         const QString &codec, const QString &name, const QVariant &value)
 
   160 {
 
   171 {
 
   161     Q_UNUSED(value)
 
   172     if (codec == "PCM") {        
   162     Q_UNUSED(codec)
 
   173         if(qstrcmp(name.toLocal8Bit().constData(), "bitrate") == 0) {
 
   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());
 
   174             setBitRate(value.toInt());
 
   171 
   175         } else if(qstrcmp(name.toLocal8Bit().constData(), "quality") == 0) {
 
   172     } else if(qstrcmp(name.toLocal8Bit().constData(), "quality") == 0) {
 
   176             setQuality((QtMediaServices::EncodingQuality)value.toInt());
 
   173         setQuality((QtMedia::EncodingQuality)value.toInt());
 
   177         } else if(qstrcmp(name.toLocal8Bit().constData(), "channels") == 0) {
 
   174 
   178             setChannelCount(value.toInt());
 
   175     } else
 
   179         } else if(qstrcmp(name.toLocal8Bit().constData(), "samplerate") == 0) {
 
   176         qWarning() << "option: " << name << " is an unknown option!";
 
   180             setSampleRate(value.toInt());       
       
   181         }        
       
   182     }
 
   177 }
 
   183 }
 
   178 
   184 
   179 int S60AudioEncoderControl::sampleRate() const
 
   185 int S60AudioEncoderControl::sampleRate() const
 
   180 {
 
   186 {
 
   181     return m_session->format().frequency();
 
   187     return m_session->format().frequency();
 
   182 }
 
   188 }
 
   183 
   189 
   184 void S60AudioEncoderControl::setSampleRate(int sampleRate)
 
   190 void S60AudioEncoderControl::setSampleRate(int sampleRate)
 
   185 {
 
   191 {
 
   186     if (sampleRate > 0) {
 
   192     QAudioFormat fmt = m_session->format();
 
   187         QAudioFormat fmt = m_session->format();
 
   193     fmt.setFrequency(sampleRate);
 
   188         fmt.setFrequency(sampleRate);
 
   194     m_session->setFormat(fmt);
 
   189         m_session->setFormat(fmt);
 
       
   190     }
 
       
   191 }
 
   195 }
 
   192 
   196 
   193 QList<int> S60AudioEncoderControl::supportedSampleRates(const QAudioEncoderSettings &settings, bool *continuous) const
 
   197 QList<int> S60AudioEncoderControl::supportedSampleRates(const QAudioEncoderSettings &settings, bool *continuous) const
 
   194 {
 
   198 {
 
   195     if (continuous)
 
   199     if (continuous)
 
   196         *continuous = false;
 
   200         *continuous = false;
 
   197     
   201     
   198     return m_session->supportedAudioSampleRates();       
   202     return m_session->supportedAudioSampleRates(settings);       
   199 }
 
   203 }
 
   200 
   204 
   201 int S60AudioEncoderControl::channelCount() const
 
   205 int S60AudioEncoderControl::channelCount() const
 
   202 {
 
   206 {
 
   203     return m_session->format().channels();
 
   207     return m_session->format().channels();
 
   204 }
 
   208 }
 
   205 
   209 
   206 void S60AudioEncoderControl::setChannelCount(int channels)
 
   210 void S60AudioEncoderControl::setChannelCount(int channels)
 
   207 {
 
   211 {
 
   208     if (channels > 0) {
 
   212     QAudioFormat fmt = m_session->format();
 
   209         QAudioFormat fmt = m_session->format();
 
   213     fmt.setChannels(channels);
 
   210         fmt.setChannels(channels);
 
   214     m_session->setFormat(fmt);
 
   211         m_session->setFormat(fmt);
 
       
   212     }
 
       
   213 }
 
       
   214 
       
   215 QList<int> S60AudioEncoderControl::supportedChannelCounts() const
 
       
   216 {
 
       
   217     return QList<int>() << 1 << 2;
 
       
   218 }
 
   215 }
 
   219 
   216 
   220 int S60AudioEncoderControl::sampleSize() const
 
   217 int S60AudioEncoderControl::sampleSize() const
 
   221 {
 
   218 {
 
   222     return m_session->format().sampleSize();
 
   219     return m_session->format().sampleSize();
 
   225 void S60AudioEncoderControl::setSampleSize(int sampleSize)
 
   222 void S60AudioEncoderControl::setSampleSize(int sampleSize)
 
   226 {
 
   223 {
 
   227     QAudioFormat fmt = m_session->format();
 
   224     QAudioFormat fmt = m_session->format();
 
   228     fmt.setSampleSize(sampleSize);
 
   225     fmt.setSampleSize(sampleSize);
 
   229     m_session->setFormat(fmt);
 
   226     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 }
 
   227 }
 
   237 
   228 
   238 QAudioEncoderSettings S60AudioEncoderControl::audioSettings() const
 
   229 QAudioEncoderSettings S60AudioEncoderControl::audioSettings() const
 
   239 {
 
   230 {
 
   240     QAudioEncoderSettings settings;
 
   231     QAudioEncoderSettings settings;
 
   246     return settings;
 
   237     return settings;
 
   247 }
 
   238 }
 
   248 
   239 
   249 void S60AudioEncoderControl::setAudioSettings(const QAudioEncoderSettings &settings)
 
   240 void S60AudioEncoderControl::setAudioSettings(const QAudioEncoderSettings &settings)
 
   250 {
 
   241 {
 
   251     setAudioCodec(settings.codec());
 
   242     if (settings.encodingMode() == QtMediaServices::ConstantQualityEncoding) {             
   252     setBitRate(settings.bitRate());
 
   243         setAudioCodec(settings.codec());
 
   253     setSampleRate(settings.sampleRate());
 
   244         setQuality(settings.quality());
 
   254     setChannelCount(settings.channelCount());
 
   245         if (settings.sampleRate() > 0)
 
   255     // Setting quality will override other settings except codec
 
   246             setSampleRate(settings.sampleRate());   
   256     setQuality(settings.quality());
 
   247         if (settings.channelCount() > 0)
 
   257 }
 
   248             setChannelCount(settings.channelCount());
 
       
   249     }else {        
       
   250         setAudioCodec(settings.codec());        
       
   251         setSampleRate(settings.sampleRate());
 
       
   252         setChannelCount(settings.channelCount());
 
       
   253     }    
       
   254 }
FCL/sf/mw/qtextensions