A question about uint 8 and uint 16 and uint 32 and uint 64

Hi!
What are the differences between uint 8 and uint 16 and uint 32 and uint 64???

thanks

The size of the unsigned int (uint):

uint8 - 8 bits (1 byte) - 0 .. 255 (0xFF) - unsigned char, uchar, byte
uint16 - 16 bits (2 bytes) - 0 .. 65535 (0xFFFF) - unsigned short, ushort, word
uint32 - 32 bits (4 bytes) - 0 .. 0xFFFFFFFF - unsigned int, unsigned long, ulong, dword
uint64 - 64 bits (8 bytes) - 0 .. 0xFFFFFFFFFFFFFFFF - unsigned long long, qword

Note that there aren't other sizes, like "uint12" and so on. Only 8, 16, 32, 64 and, sometimes, 128 (oword on 64-bit processors, certain compilers).

Hello
My system is 32 bits.but the following code does not work with qint32.why?
See the following section of code.
Note:qint64 Converted to qint32.The name of the program is Audio Output Example and Examples of Qt.

Code:

---

#include <QAudioDeviceInfo>
#include <QAudioOutput>
#include <QDebug>
#include <QVBoxLayout>
#include <qmath.h>
#include <qendian.h>
 
#include "audiooutput.h"
 
#define PUSH_MODE_LABEL "Enable push mode"
#define PULL_MODE_LABEL "Enable pull mode"
#define SUSPEND_LABEL   "Suspend playback"
#define RESUME_LABEL    "Resume playback"
#define VOLUME_LABEL    "Volume:"
 
const int DurationSeconds = 1;
const int ToneSampleRateHz = 600;
const int DataSampleRateHz = 44100;
const int BufferSize      = 32768;
 
 
Generator::Generator(const QAudioFormat &format,
                     qint32 durationUs,
                     int sampleRate,
                     QObject *parent)
    :   QIODevice(parent)
    ,   m_pos(0)
{
    generateData(format, durationUs, sampleRate);
}
 
Generator::~Generator()
{
 
}
 
void Generator::start()
{
    open(QIODevice::ReadOnly);
}
 
void Generator::stop()
{
    m_pos = 0;
    close();
}
 
void Generator::generateData(const QAudioFormat &format, qint32 durationUs, int sampleRate)
{
    const int channelBytes = format.sampleSize() / 8;
    const int sampleBytes = format.channelCount() * channelBytes;
 
    qint32 length = (format.sampleRate() * format.channelCount() * (format.sampleSize() / 8))
                        * durationUs / 100000;
 
    Q_ASSERT(length % sampleBytes == 0);
    Q_UNUSED(sampleBytes) // suppress warning in release builds
 
    m_buffer.resize(length);
    unsigned char *ptr = reinterpret_cast<unsigned char *>(m_buffer.data());
    int sampleIndex = 0;
 
    while (length) {
        const qreal x = qSin(2 * M_PI * sampleRate * qreal(sampleIndex % format.sampleRate()) / format.sampleRate());
        for (int i=0; i<format.channelCount(); ++i) {
            if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::UnSignedInt) {
                const quint8 value = static_cast<quint8>((1.0 + x) / 2 * 255);
                *reinterpret_cast<quint8*>(ptr) = value;
            } else if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::SignedInt) {
                const qint8 value = static_cast<qint8>(x * 127);
                *reinterpret_cast<quint8*>(ptr) = value;
            } else if (format.sampleSize() == 16 && format.sampleType() == QAudioFormat::UnSignedInt) {
                quint16 value = static_cast<quint16>((1.0 + x) / 2 * 65535);
                if (format.byteOrder() == QAudioFormat::LittleEndian)
                    qToLittleEndian<quint16>(value, ptr);
                else
                    qToBigEndian<quint16>(value, ptr);
            } else if (format.sampleSize() == 16 && format.sampleType() == QAudioFormat::SignedInt) {
                qint16 value = static_cast<qint16>(x * 32767);
                if (format.byteOrder() == QAudioFormat::LittleEndian)
                    qToLittleEndian<qint16>(value, ptr);
                else
                    qToBigEndian<qint16>(value, ptr);
            }
 
            ptr += channelBytes;
            length -= channelBytes;
        }
        ++sampleIndex;
    }
}
 
qint32 Generator::readData(char *data, qint32 len)
{
    qint32 total = 0;
    while (len - total > 0) {
        const qint32 chunk = qMin((m_buffer.size() - m_pos), len - total);
        memcpy(data + total, m_buffer.constData() + m_pos, chunk);
        m_pos = (m_pos + chunk) % m_buffer.size();
        total += chunk;
    }
    return total;
}
 
qint32 Generator::writeData(const char *data, qint32 len)
{
    Q_UNUSED(data);
    Q_UNUSED(len);
 
    return 0;
}
 
qint32 Generator::bytesAvailable() const
{
    return m_buffer.size() + QIODevice::bytesAvailable();
}
 
AudioTest::AudioTest()
    :   m_pullTimer(new QTimer(this))
    ,   m_modeButton(0)
    ,   m_suspendResumeButton(0)
    ,   m_deviceBox(0)
    ,   m_device(QAudioDeviceInfo::defaultOutputDevice())
    ,   m_generator(0)
    ,   m_audioOutput(0)
    ,   m_output(0)
    ,   m_buffer(BufferSize, 0)
{
    initializeWindow();
    initializeAudio();
}
 
void AudioTest::initializeWindow()
{
    QScopedPointer<QWidget> window(new QWidget);
    QScopedPointer<QVBoxLayout> layout(new QVBoxLayout);
 
    m_deviceBox = new QComboBox(this);
    foreach (const QAudioDeviceInfo &deviceInfo, QAudioDeviceInfo::availableDevices(QAudio::AudioOutput))
        m_deviceBox->addItem(deviceInfo.deviceName(), qVariantFromValue(deviceInfo));
    connect(m_deviceBox,SIGNAL(activated(int)),SLOT(deviceChanged(int)));
    layout->addWidget(m_deviceBox);
 
    m_modeButton = new QPushButton(this);
    m_modeButton->setText(tr(PUSH_MODE_LABEL));
    connect(m_modeButton, SIGNAL(clicked()), SLOT(toggleMode()));
    layout->addWidget(m_modeButton);
 
    m_suspendResumeButton = new QPushButton(this);
    m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
    connect(m_suspendResumeButton, SIGNAL(clicked()), SLOT(toggleSuspendResume()));
    layout->addWidget(m_suspendResumeButton);
 
    QHBoxLayout *volumeBox = new QHBoxLayout;
    m_volumeLabel = new QLabel;
    m_volumeLabel->setText(tr(VOLUME_LABEL));
    m_volumeSlider = new QSlider(Qt::Horizontal);
    m_volumeSlider->setMinimum(0);
    m_volumeSlider->setMaximum(100);
    m_volumeSlider->setSingleStep(10);
    connect(m_volumeSlider, SIGNAL(valueChanged(int)), this, SLOT(volumeChanged(int)));
    volumeBox->addWidget(m_volumeLabel);
    volumeBox->addWidget(m_volumeSlider);
    layout->addLayout(volumeBox);
 
    window->setLayout(layout.data());
    layout.take(); // ownership transferred
 
    setCentralWidget(window.data());
    QWidget *const windowPtr = window.take(); // ownership transferred
    windowPtr->show();
}
 
void AudioTest::initializeAudio()
{
    connect(m_pullTimer, SIGNAL(timeout()), SLOT(pullTimerExpired()));
 
    m_pullMode = true;
 
    m_format.setSampleRate(DataSampleRateHz);
    m_format.setChannelCount(1);
    m_format.setSampleSize(16);
    m_format.setCodec("audio/pcm");
    m_format.setByteOrder(QAudioFormat::LittleEndian);
    m_format.setSampleType(QAudioFormat::SignedInt);
 
    QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
    if (!info.isFormatSupported(m_format)) {
        qWarning() << "Default format not supported - trying to use nearest";
        m_format = info.nearestFormat(m_format);
    }
 
    m_generator = new Generator(m_format, DurationSeconds*1000000, ToneSampleRateHz, this);
 
    createAudioOutput();
}
 
void AudioTest::createAudioOutput()
{
    delete m_audioOutput;
    m_audioOutput = 0;
    m_audioOutput = new QAudioOutput(m_device, m_format, this);
    connect(m_audioOutput, SIGNAL(notify()), SLOT(notified()));
    connect(m_audioOutput, SIGNAL(stateChanged(QAudio::State)), SLOT(handleStateChanged(QAudio::State)));
    m_generator->start();
    m_audioOutput->start(m_generator);
    m_volumeSlider->setValue(int(m_audioOutput->volume()*100.0f));
}
 
AudioTest::~AudioTest()
{
 
}
 
void AudioTest::deviceChanged(int index)
{
    m_pullTimer->stop();
    m_generator->stop();
    m_audioOutput->stop();
    m_audioOutput->disconnect(this);
    m_device = m_deviceBox->itemData(index).value<QAudioDeviceInfo>();
    createAudioOutput();
}
 
void AudioTest::volumeChanged(int value)
{
    if (m_audioOutput)
        m_audioOutput->setVolume(qreal(value/100.0f));
}
 
void AudioTest::notified()
{
    qWarning() << "bytesFree = " << m_audioOutput->bytesFree()
               << ", " << "elapsedUSecs = " << m_audioOutput->elapsedUSecs()
               << ", " << "processedUSecs = " << m_audioOutput->processedUSecs();
}
 
void AudioTest::pullTimerExpired()
{
    if (m_audioOutput && m_audioOutput->state() != QAudio::StoppedState) {
        int chunks = m_audioOutput->bytesFree()/m_audioOutput->periodSize();
        while (chunks) {
           const qint32 len = m_generator->read(m_buffer.data(), m_audioOutput->periodSize());
           if (len)
               m_output->write(m_buffer.data(), len);
           if (len != m_audioOutput->periodSize())
               break;
           --chunks;
        }
    }
}
 
void AudioTest::toggleMode()
{
    m_pullTimer->stop();
    m_audioOutput->stop();
 
    if (m_pullMode) {
        m_modeButton->setText(tr(PULL_MODE_LABEL));
        m_output = m_audioOutput->start();
        m_pullMode = false;
        m_pullTimer->start(20);
    } else {
        m_modeButton->setText(tr(PUSH_MODE_LABEL));
        m_pullMode = true;
        m_audioOutput->start(m_generator);
    }
 
    m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
}
 
void AudioTest::toggleSuspendResume()
{
    if (m_audioOutput->state() == QAudio::SuspendedState) {
        qWarning() << "status: Suspended, resume()";
        m_audioOutput->resume();
        m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
    } else if (m_audioOutput->state() == QAudio::ActiveState) {
        qWarning() << "status: Active, suspend()";
        m_audioOutput->suspend();
        m_suspendResumeButton->setText(tr(RESUME_LABEL));
    } else if (m_audioOutput->state() == QAudio::StoppedState) {
        qWarning() << "status: Stopped, resume()";
        m_audioOutput->resume();
        m_suspendResumeButton->setText(tr(SUSPEND_LABEL));
    } else if (m_audioOutput->state() == QAudio::IdleState) {
        qWarning() << "status: IdleState";
    }
}
 
void AudioTest::handleStateChanged(QAudio::State state)
{
    qWarning() << "state = " << state;
}

---

A qint32 can hold much smaller numbers than a qint64... They may not be directly interchangeable without other changes to the maths. However, we are not gong to disassemble your entire program to determine what you have done to the original example or guess what "does not work" about it. "Does not work" is not a useful description of the problem, a symptom of a problem, the location of a problem, or the desired behaviour.

(1) If you have replaced qint64 by qint32 then why have you done it? A 32-bit CPU can process 64-bit integers, too. Your (32-bit) Qt will take care for 64-bit arithmetic. No need for replacing qint64 by qint32.
(2) As to possible errors: Check line 193. I guess "duration" was a 64-bit integer. Because a 32-bit int can hold 4*10e9 at most, the "new Generator" will fail whenever duration > 4000 sec.

Quote:

---

Originally Posted by Radek

Because a 32-bit int can hold 4*10e9 at most, the "new Generator" will fail whenever duration > 4000 sec.

---

It is a signed integer so even only half of that.

Quote:

---

A 32-bit CPU can process 64-bit integers

---

Not wrong???

Why should it be wrong? It's only a question of a bit of programming (multiple precision arithmetics).

My system is 32-bit.
64-bit applications will not run on my system.

So in the above code, why should we use qint64?

Quote:

---

Originally Posted by rezas1000

My system is 32-bit.
64-bit applications will not run on my system.

So in the above code, why should we use qint64?

---

quint64 is just a datatype (mapping to unsigned long long or something similar), it has nothing to do with the width of the address or data bus which is what makes a system "32 bit" or "64 bit". The processor can handle 32 bit as well as 64 bit datatypes and maybe even 128 bit types as well, it is just a matter of efficiency of processing such data.

Exactly!

A "double" for example is always 64 bit, it is specified that way https://en.wikipedia.org/wiki/Double_precision

Cheers,
_