/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "v4lradiocontrol_maemo5.h"

#include "v4lradioservice.h"

#include "linux/videodev2.h"

#include <linux/videodev.h>

#include <sys/soundcard.h>

#include <stdio.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#include <fcntl.h>

#include <unistd.h>

V4LRadioControl::V4LRadioControl(QObject *parent)

    : QRadioTunerControl(parent)

    , fd(1)

    , m_error(false)

    , muted(false)

    , stereo(false)

    , step(100000)

    , sig(0)

    , scanning(false)

    , currentBand(QRadioTuner::FM)

    , pipeline(0)

{

    if (QDBusConnection::systemBus().isConnected()) {

        FMRXEnablerIFace = new QDBusInterface("de.pycage.FMRXEnabler",

                                             "/de/pycage/FMRXEnabler",

                                             "de.pycage.FMRXEnabler",

                                             QDBusConnection::systemBus());

    }

    enableFMRX();

    createGstPipeline();

    initRadio();

    setupHeadPhone();

    setMuted(false);

    timer = new QTimer(this);

    timer->setInterval(200);

    connect(timer,SIGNAL(timeout()),this,SLOT(search()));

    timer->start();

    tickTimer = new QTimer(this);

    tickTimer->setInterval(10000);

    connect(tickTimer,SIGNAL(timeout()),this,SLOT(enableFMRX()));

    tickTimer->start();

}

V4LRadioControl::~V4LRadioControl()

{

    if (pipeline)

    {

        gst_element_set_state (pipeline, GST_STATE_NULL);

        gst_object_unref (GST_OBJECT (pipeline));

    }

    if(fd > 0)

        ::close(fd);

}

void V4LRadioControl::enableFMRX()

{

    if (FMRXEnablerIFace && FMRXEnablerIFace->isValid()) {

        FMRXEnablerIFace->call("request"); // Return value ignored

    }

}

// Workaround to capture sound from the PGA line and play it back using gstreamer

// because N900 doesn't output sound directly to speakers

bool V4LRadioControl::createGstPipeline()

{

    GstElement *source, *sink;

    gst_init (NULL, NULL);

    pipeline = gst_pipeline_new("my-pipeline");

    source = gst_element_factory_make ("pulsesrc", "source");

    sink = gst_element_factory_make ("pulsesink", "sink");

    gst_bin_add_many (GST_BIN (pipeline), source, sink, (char *)NULL);

    if (!gst_element_link_many (source, sink, (char *)NULL)) {

        return false;

    }

    gst_element_set_state (pipeline, GST_STATE_PLAYING);

    return true;

}

bool V4LRadioControl::isAvailable() const

{

    return available;

}

QtMedia::AvailabilityError V4LRadioControl::availabilityError() const

{

    if (fd > 0)

        return QtMedia::NoError;

    else

        return QtMedia::ResourceError;

}

QRadioTuner::State V4LRadioControl::state() const

{

    return fd > 0 ? QRadioTuner::ActiveState : QRadioTuner::StoppedState;

}

QRadioTuner::Band V4LRadioControl::band() const

{

    return currentBand;

}

bool V4LRadioControl::isBandSupported(QRadioTuner::Band b) const

{

    QRadioTuner::Band bnd = (QRadioTuner::Band)b;

    switch(bnd) {

        case QRadioTuner::FM:

            if(freqMin <= 87500000 && freqMax >= 108000000)

                return true;

            break;

        case QRadioTuner::LW:

            if(freqMin <= 148500 && freqMax >= 283500)

                return true;

        case QRadioTuner::AM:

            if(freqMin <= 520000 && freqMax >= 1610000)

                return true;

        default:

            if(freqMin <= 1711000 && freqMax >= 30000000)

                return true;

    }

    return false;

}

void V4LRadioControl::setBand(QRadioTuner::Band b)

{

    if(freqMin <= 87500000 && freqMax >= 108000000 && b == QRadioTuner::FM) {

        // FM 87.5 to 108.0 MHz, except Japan 76-90 MHz

        currentBand =  (QRadioTuner::Band)b;

        step = 100000; // 100kHz steps

        emit bandChanged(currentBand);

    } else if(freqMin <= 148500 && freqMax >= 283500 && b == QRadioTuner::LW) {

        // LW 148.5 to 283.5 kHz, 9kHz channel spacing (Europe, Africa, Asia)

        currentBand =  (QRadioTuner::Band)b;

        step = 1000; // 1kHz steps

        emit bandChanged(currentBand);

    } else if(freqMin <= 520000 && freqMax >= 1610000 && b == QRadioTuner::AM) {

        // AM 520 to 1610 kHz, 9 or 10kHz channel spacing, extended 1610 to 1710 kHz

        currentBand =  (QRadioTuner::Band)b;

        step = 1000; // 1kHz steps

        emit bandChanged(currentBand);

    } else if(freqMin <= 1711000 && freqMax >= 30000000 && b == QRadioTuner::SW) {

        // SW 1.711 to 30.0 MHz, divided into 15 bands. 5kHz channel spacing

        currentBand =  (QRadioTuner::Band)b;

        step = 500; // 500Hz steps

        emit bandChanged(currentBand);

    }

}

int V4LRadioControl::frequency() const

{

    return currentFreq;

}

int V4LRadioControl::frequencyStep(QRadioTuner::Band b) const

{

    int step = 0;

    if(b == QRadioTuner::FM)

        step = 100000; // 100kHz steps

    else if(b == QRadioTuner::LW)

        step = 1000; // 1kHz steps

    else if(b == QRadioTuner::AM)

        step = 1000; // 1kHz steps

    else if(b == QRadioTuner::SW)

        step = 500; // 500Hz steps

    return step;

}

QPair<int,int> V4LRadioControl::frequencyRange(QRadioTuner::Band b) const

{

    if(b == QRadioTuner::AM)

        return qMakePair<int,int>(520000,1710000);

    else if(b == QRadioTuner::FM)

        return qMakePair<int,int>(87500000,108000000);

    else if(b == QRadioTuner::SW)

        return qMakePair<int,int>(1711111,30000000);

    else if(b == QRadioTuner::LW)

        return qMakePair<int,int>(148500,283500);

    return qMakePair<int,int>(0,0);

}

void V4LRadioControl::setFrequency(int frequency)

{

    qint64 f = frequency;

    v4l2_frequency freq;

    if(frequency < freqMin)

        f = freqMax;

    if(frequency > freqMax)

        f = freqMin;

    if(fd > 0) {

        memset(&freq, 0, sizeof(freq));

        // Use the first tuner

        freq.tuner = 0;

        if (::ioctl(fd, VIDIOC_G_FREQUENCY, &freq) >= 0) {

            if(low) {

                // For low, freq in units of 62.5Hz, so convert from Hz to units.

                freq.frequency = (int)(f/62.5);

            } else {

                // For high, freq in units of 62.5kHz, so convert from Hz to units.

                freq.frequency = (int)(f/62500);

            }

            ::ioctl(fd, VIDIOC_S_FREQUENCY, &freq);

            currentFreq = f;

            emit frequencyChanged(currentFreq);

        }

    }

}

bool V4LRadioControl::isStereo() const

{

    return stereo;

}

QRadioTuner::StereoMode V4LRadioControl::stereoMode() const

{

    return QRadioTuner::Auto;

}

void V4LRadioControl::setStereoMode(QRadioTuner::StereoMode mode)

{

    bool stereo = true;

    if(mode == QRadioTuner::ForceMono)

        stereo = false;

    v4l2_tuner tuner;

    memset(&tuner, 0, sizeof(tuner));

    if (ioctl(fd, VIDIOC_G_TUNER, &tuner) >= 0) {

        if(stereo)

            tuner.audmode = V4L2_TUNER_MODE_STEREO;

        else

            tuner.audmode = V4L2_TUNER_MODE_MONO;

        if (ioctl(fd, VIDIOC_S_TUNER, &tuner) >= 0) {

            emit stereoStatusChanged(stereo);

        }

    }

}

int V4LRadioControl::signalStrength() const

{

    v4l2_tuner tuner;

    tuner.index = 0;

    if (ioctl(fd, VIDIOC_G_TUNER, &tuner) < 0 || tuner.type != V4L2_TUNER_RADIO)

        return 0;

    return tuner.signal*100/65535;

}

int  V4LRadioControl::vol(snd_hctl_elem_t *elem) const

{

    const QString card("hw:0");

    int err;

    snd_ctl_elem_id_t *id;

    snd_ctl_elem_info_t *info;

    snd_ctl_elem_value_t *control;

    snd_ctl_elem_id_alloca(&id);

    snd_ctl_elem_info_alloca(&info);

    snd_ctl_elem_value_alloca(&control);

    if ((err = snd_hctl_elem_info(elem, info)) < 0) {

        return 0;

    }

    snd_hctl_elem_get_id(elem, id);

    snd_hctl_elem_read(elem, control);

    return snd_ctl_elem_value_get_integer(control, 0);

}

int V4LRadioControl::volume() const

{

    const QString ctlName("Line DAC Playback Volume");

    const QString card("hw:0");

    int volume = 0;

    int err;

    static snd_ctl_t *handle = NULL;

    snd_ctl_elem_info_t *info;

    snd_ctl_elem_id_t *id;

    snd_ctl_elem_value_t *control;

    snd_ctl_elem_info_alloca(&info);

    snd_ctl_elem_id_alloca(&id);

    snd_ctl_elem_value_alloca(&control);

    snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);	/* MIXER */

    snd_ctl_elem_id_set_name(id, ctlName.toAscii());

    if ((err = snd_ctl_open(&handle, card.toAscii(), 0)) < 0) {

        return 0;

    }

    snd_ctl_elem_info_set_id(info, id);

    if ((err = snd_ctl_elem_info(handle, info)) < 0) {

        snd_ctl_close(handle);

        handle = NULL;

        return 0;

    }

    snd_ctl_elem_info_get_id(info, id);	/* FIXME: Remove it when hctl find works ok !!! */

    snd_ctl_elem_value_set_id(control, id);

    snd_ctl_close(handle);

    handle = NULL;

    snd_hctl_t *hctl;

    snd_hctl_elem_t *elem;

    if ((err = snd_hctl_open(&hctl, card.toAscii(), 0)) < 0) {

        return 0;

    }

    if ((err = snd_hctl_load(hctl)) < 0) {

        return 0;

    }

    elem = snd_hctl_find_elem(hctl, id);

    if (elem)

        volume = vol(elem);

    snd_hctl_close(hctl);

    return (volume/63.0) * 100;

}

void V4LRadioControl::setVolume(int volume)

{

    int vol = (volume / 100.0) * 63; // 63 is a headphone max setting

    callAmixer("Line DAC Playback Volume", QString().setNum(vol)+QString(",")+QString().setNum(vol));

}

bool V4LRadioControl::isMuted() const

{

    return muted;

}

void V4LRadioControl::setMuted(bool muted)

{

    struct v4l2_control vctrl;

    vctrl.id = V4L2_CID_AUDIO_MUTE;

    vctrl.value = muted ? 1 : 0;

    ioctl(fd, VIDIOC_S_CTRL, &vctrl);

}

void V4LRadioControl::setupHeadPhone()

{

    QMap<QString, QString> settings;

    settings["Jack Function"] = "Headset";

    settings["Left DAC_L1 Mixer HP Switch"] = "off";

    settings["Right DAC_R1 Mixer HP Switch"] = "off";

    settings["Line DAC Playback Switch"] = "on";

    settings["Line DAC Playback Volume"] = "63,63"; // Volume is set to 100%

    settings["HPCOM DAC Playback Switch"] = "off";

    settings["Left DAC_L1 Mixer HP Switch"] = "off";

    settings["Left DAC_L1 Mixer Line Switch"] = "on";

    settings["Right DAC_R1 Mixer HP Switch"] = "off";

    settings["Right DAC_R1 Mixer Line Switch"] = "on";

    settings["Speaker Function"] = "Off";

    settings["Input Select"] = "ADC";

    settings["Left PGA Mixer Line1L Switch"] = "off";

    settings["Right PGA Mixer Line1L Switch"] = "off";

    settings["Right PGA Mixer Line1R Switch"] = "off";

    settings["PGA Capture Volume"] = "0,0";

    settings["PGA Capture Switch"] = "on";

    settings["Left PGA Mixer Line2L Switch"] = "on";

    settings["Right PGA Mixer Line2R Switch"] = "on";

    QMapIterator<QString, QString> i(settings);

    while (i.hasNext()) {

        i.next();

        callAmixer(i.key(), i.value());

    }

}

void V4LRadioControl::callAmixer(const QString& target, const QString& value)

{

    int err;

    long tmp;

    unsigned int count;

    static snd_ctl_t *handle = NULL;

    QString card("hw:0");

    snd_ctl_elem_info_t *info;

    snd_ctl_elem_id_t *id;

    snd_ctl_elem_value_t *control;

    snd_ctl_elem_type_t type;

    snd_ctl_elem_info_alloca(&info);

    snd_ctl_elem_id_alloca(&id);

    snd_ctl_elem_value_alloca(&control);

    snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);	/* MIXER */

    // in amixer parse func

    // char target[64];

    // e.g. PGA CAPTure Switch

    snd_ctl_elem_id_set_name(id, target.toAscii());

    if (handle == NULL && (err = snd_ctl_open(&handle, card.toAscii(), 0)) < 0)

    {

        return;

    }

    snd_ctl_elem_info_set_id(info, id);

    if ((err = snd_ctl_elem_info(handle, info)) < 0)

    {

        snd_ctl_close(handle);

        handle = NULL;

        return;

    }

    snd_ctl_elem_info_get_id(info, id);	/* FIXME: Remove it when hctl find works ok !!! */

    type = snd_ctl_elem_info_get_type(info);

    count = snd_ctl_elem_info_get_count(info);

    snd_ctl_elem_value_set_id(control, id);

    tmp = 0;

    for (int idx = 0; idx < count && idx < 128; idx++)

    {

        switch (type)

        {

            case SND_CTL_ELEM_TYPE_BOOLEAN:

                qDebug() << "SND_CTL_ELEM_TYPE_BOOLEAN" << SND_CTL_ELEM_TYPE_BOOLEAN;

                if ((value == "on") ||(value == "1"))

                {

                    tmp = 1;

                }

                snd_ctl_elem_value_set_boolean(control, idx, tmp);

                break;

            case SND_CTL_ELEM_TYPE_ENUMERATED:

                tmp = getEnumItemIndex(handle, info, value);

                snd_ctl_elem_value_set_enumerated(control, idx, tmp);

                break;

            case SND_CTL_ELEM_TYPE_INTEGER:

                qDebug() << "SND_CTL_ELEM_TYPE_INTEGER" << SND_CTL_ELEM_TYPE_INTEGER;

                tmp = atoi(value.toAscii());

                if (tmp <  snd_ctl_elem_info_get_min(info))

                    tmp = snd_ctl_elem_info_get_min(info);

                else if (tmp > snd_ctl_elem_info_get_max(info))

                    tmp = snd_ctl_elem_info_get_max(info);

                snd_ctl_elem_value_set_integer(control, idx, tmp);

                break;

            default:

                break;

        }

    }

    if ((err = snd_ctl_elem_write(handle, control)) < 0) {

        snd_ctl_close(handle);

        handle = NULL;

        return;

    }

    snd_ctl_close(handle);

    handle = NULL;

}

int V4LRadioControl::getEnumItemIndex(snd_ctl_t *handle, snd_ctl_elem_info_t *info,

       const QString &value)

{

    int items, i;