Clean up file format and audio profile handling

Remove the ALAC file format as it is actually always
stored in an mp4 container. While the same is true for
AAC, keep the format, as it's often used with it's own
extension.

Rename ASF to WMV and add WMA as a file format as those
usually have different extensions.

Add WMA and WMV codecs, as the corresponding file formats make
little sense without supporting the codecs that are being used.

Clean up the gstreamer implementation and test that audio only
recording works for all combinations.

Change-Id: I7c76add8f02eba646741c6c2a870e8af9b9fc51b
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

15 files changed, 174 insertions, 72 deletions

diff --git a/examples/multimedia/audiorecorder/audiorecorder.cpp b/examples/multimedia/audiorecorder/audiorecorder.cpp
index f8437ba4d..af570429e 100644
--- a/examples/multimedia/audiorecorder/audiorecorder.cpp
+++ b/examples/multimedia/audiorecorder/audiorecorder.cpp
@@ -96,7 +96,7 @@ AudioRecorder::AudioRecorder()
     //containers
     ui->containerBox->addItem(tr("Default"), QVariant(QString()));
     for (auto &container : QMediaFormat().supportedFileFormats(QMediaFormat::Encode)) {
-        if (container < QMediaFormat::AAC) // ### Somewhat hacky, skip video formats
+        if (container < QMediaFormat::Mpeg4Audio) // ### Somewhat hacky, skip video formats
             continue;
         ui->containerBox->addItem(QMediaFormat::fileFormatDescription(container), QVariant::fromValue(container));
     }
diff --git a/examples/multimedia/spectrum/app/engine.cpp b/examples/multimedia/spectrum/app/engine.cpp
index 6d07a9817..2a6a50168 100644
--- a/examples/multimedia/spectrum/app/engine.cpp
+++ b/examples/multimedia/spectrum/app/engine.cpp
@@ -299,6 +299,8 @@ void Engine::suspend()
         case QAudioDevice::Output:
             m_audioOutput->suspend();
             break;
+        default:
+            break;
         }
         m_notifyTimer->stop();
     }
@@ -380,6 +382,8 @@ void Engine::audioNotify()
                 calculateSpectrum(spectrumPosition);
         }
         break;
+        default:
+            break;
     }
 }
 
@@ -401,6 +405,8 @@ void Engine::audioStateChanged(QAudio::State state)
             case QAudioDevice::Output:
                 error = m_audioOutput->error();
                 break;
+            default:
+                break;
             }
             if (QAudio::NoError != error) {
                 reset();
diff --git a/examples/multimediawidgets/camera/videosettings.cpp b/examples/multimediawidgets/camera/videosettings.cpp
index 03c4f74c1..858a18b22 100644
--- a/examples/multimediawidgets/camera/videosettings.cpp
+++ b/examples/multimediawidgets/camera/videosettings.cpp
@@ -159,6 +159,7 @@ void VideoSettings::applySettings()
     format.setAudioCodec(boxValue(ui->audioCodecBox).value<QMediaFormat::AudioCodec>());
     format.setVideoCodec(boxValue(ui->videoCodecBox).value<QMediaFormat::VideoCodec>());
 
+    mediaRecorder->setMediaFormat(format);
     mediaRecorder->setQuality(QMediaRecorder::Quality(ui->qualitySlider->value()));
     mediaRecorder->setAudioSampleRate(ui->audioSampleRateBox->value());
     mediaRecorder->setVideoResolution(boxValue(ui->videoResolutionBox).toSize());
diff --git a/src/multimedia/audio/qaudiodevice.cpp b/src/multimedia/audio/qaudiodevice.cpp
index bfba09e32..bc2bed906 100644
--- a/src/multimedia/audio/qaudiodevice.cpp
+++ b/src/multimedia/audio/qaudiodevice.cpp
@@ -276,7 +276,7 @@ QAudioDevice::QAudioDevice(QAudioDevicePrivate *p)
 */
 QAudioDevice::Mode QAudioDevice::mode() const
 {
-    return d->mode;
+    return d ? d->mode : Null;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -291,6 +291,9 @@ QDebug operator<<(QDebug dbg, QAudioDevice::Mode mode)
     case QAudioDevice::Output:
         dbg << "QAudioDevice::Output";
         break;
+    case QAudioDevice::Null:
+        dbg << "QAudioDevice::Null";
+        break;
     }
     return dbg;
 }
diff --git a/src/multimedia/audio/qaudiodevice.h b/src/multimedia/audio/qaudiodevice.h
index 367733c77..f414af88f 100644
--- a/src/multimedia/audio/qaudiodevice.h
+++ b/src/multimedia/audio/qaudiodevice.h
@@ -66,6 +66,7 @@ class Q_MULTIMEDIA_EXPORT QAudioDevice
     Q_PROPERTY(Mode mode READ mode CONSTANT)
 public:
     enum Mode {
+        Null,
         Input,
         Output
     };
diff --git a/src/multimedia/audio/qaudioinput.cpp b/src/multimedia/audio/qaudioinput.cpp
index 4d65aee3a..e257e8f3f 100644
--- a/src/multimedia/audio/qaudioinput.cpp
+++ b/src/multimedia/audio/qaudioinput.cpp
@@ -112,7 +112,7 @@ QAudioDevice QAudioInput::device() const
 
 void QAudioInput::setDevice(const QAudioDevice &device)
 {
-    if (device.mode() != QAudioDevice::Input)
+    if (device.mode() == QAudioDevice::Output)
         return;
     d->device = device;
     d->setAudioDevice(device);
diff --git a/src/multimedia/platform/darwin/qdarwinformatsinfo.mm b/src/multimedia/platform/darwin/qdarwinformatsinfo.mm
index afa1adf4a..9ba42c14b 100644
--- a/src/multimedia/platform/darwin/qdarwinformatsinfo.mm
+++ b/src/multimedia/platform/darwin/qdarwinformatsinfo.mm
@@ -47,7 +47,7 @@ static struct {
     const char *name;
     QMediaFormat::FileFormat value;
 } mediaContainerMap[] = {
-    { "video/x-ms-asf", QMediaFormat::ASF },
+    { "video/x-ms-asf", QMediaFormat::WMV },
     { "video/avi", QMediaFormat::AVI },
     { "video/x-matroska", QMediaFormat::Matroska },
     { "video/mp4", QMediaFormat::MPEG4 },
diff --git a/src/multimedia/platform/gstreamer/mediacapture/qgstreamermediaencoder.cpp b/src/multimedia/platform/gstreamer/mediacapture/qgstreamermediaencoder.cpp
index ee67ae55d..810709b64 100644
--- a/src/multimedia/platform/gstreamer/mediacapture/qgstreamermediaencoder.cpp
+++ b/src/multimedia/platform/gstreamer/mediacapture/qgstreamermediaencoder.cpp
@@ -238,20 +238,29 @@ static GstEncodingProfile *createAudioProfile(const QMediaEncoderSettings &setti
 static GstEncodingContainerProfile *createEncodingProfile(const QMediaEncoderSettings &settings)
 {
     auto *containerProfile = createContainerProfile(settings);
-    if (containerProfile) {
-        GstEncodingProfile *audioProfile = createAudioProfile(settings);
-        GstEncodingProfile *videoProfile = settings.videoCodec() != QMediaFormat::VideoCodec::Unspecified ? createVideoProfile(settings) : nullptr;
-//        qDebug() << "audio profile" << gst_caps_to_string(gst_encoding_profile_get_format(audioProfile));
-//        qDebug() << "video profile" << gst_caps_to_string(gst_encoding_profile_get_format(videoProfile));
-//        qDebug() << "conta profile" << gst_caps_to_string(gst_encoding_profile_get_format((GstEncodingProfile *)containerProfile));
-
-        if (videoProfile) {
-            if (!gst_encoding_container_profile_add_profile(containerProfile, videoProfile))
-                gst_encoding_profile_unref(videoProfile);
+    if (!containerProfile) {
+        qWarning() << "QGstreamerMediaEncoder: failed to create container profile!";
+        return nullptr;
+    }
+
+    GstEncodingProfile *audioProfile = createAudioProfile(settings);
+    GstEncodingProfile *videoProfile = nullptr;
+    if (settings.videoCodec() != QMediaFormat::VideoCodec::Unspecified)
+        videoProfile = createVideoProfile(settings);
+//    qDebug() << "audio profile" << (audioProfile ? gst_caps_to_string(gst_encoding_profile_get_format(audioProfile)) : "(null)");
+//    qDebug() << "video profile" << (videoProfile ? gst_caps_to_string(gst_encoding_profile_get_format(videoProfile)) : "(null)");
+//    qDebug() << "conta profile" << gst_caps_to_string(gst_encoding_profile_get_format((GstEncodingProfile *)containerProfile));
+
+    if (videoProfile) {
+        if (!gst_encoding_container_profile_add_profile(containerProfile, videoProfile)) {
+            qWarning() << "QGstreamerMediaEncoder: failed to add video profile!";
+            gst_encoding_profile_unref(videoProfile);
         }
-        if (audioProfile) {
-            if (!gst_encoding_container_profile_add_profile(containerProfile, audioProfile))
-                gst_encoding_profile_unref(audioProfile);
+    }
+    if (audioProfile) {
+        if (!gst_encoding_container_profile_add_profile(containerProfile, audioProfile)) {
+            qWarning() << "QGstreamerMediaEncoder: failed to add audio profile!";
+            gst_encoding_profile_unref(audioProfile);
         }
     }
 
@@ -356,11 +365,16 @@ void QGstreamerMediaEncoder::stop()
     heartbeat.stop();
 
     gstPipeline.setStateSync(GST_STATE_PAUSED);
-    audioSrcPad.unlinkPeer();
-    videoSrcPad.unlinkPeer();
-    m_session->releaseAudioPad(audioSrcPad);
-    m_session->releaseVideoPad(videoSrcPad);
-    audioSrcPad = videoSrcPad = {};
+    if (!audioSrcPad.isNull()) {
+        audioSrcPad.unlinkPeer();
+        m_session->releaseAudioPad(audioSrcPad);
+        audioSrcPad = {};
+    }
+    if (!videoSrcPad.isNull()) {
+        videoSrcPad.unlinkPeer();
+        m_session->releaseVideoPad(videoSrcPad);
+        videoSrcPad = {};
+    }
 
     gstPipeline.setState(GST_STATE_PLAYING);
     //with live sources it's necessary to send EOS even to pipeline
diff --git a/src/multimedia/platform/gstreamer/qgstreamerformatinfo.cpp b/src/multimedia/platform/gstreamer/qgstreamerformatinfo.cpp
index 4705848a4..1bf17ac89 100644
--- a/src/multimedia/platform/gstreamer/qgstreamerformatinfo.cpp
+++ b/src/multimedia/platform/gstreamer/qgstreamerformatinfo.cpp
@@ -52,7 +52,7 @@ QMediaFormat::AudioCodec QGstreamerFormatInfo::audioCodecForCaps(QGstStructure s
     name += 6;
     if (!strcmp(name, "mpeg")) {
         auto version = structure["mpegversion"].toInt();
-        if (0 && version == 1) {
+        if (version == 1) {
             auto layer = structure["layer"];
             if (!layer.isNull())
                 return QMediaFormat::AudioCodec::MP3;
@@ -75,6 +75,8 @@ QMediaFormat::AudioCodec QGstreamerFormatInfo::audioCodecForCaps(QGstStructure s
         return QMediaFormat::AudioCodec::Opus;
     } else if (!strcmp(name, "x-wav")) {
         return QMediaFormat::AudioCodec::Wave;
+    } else if (!strcmp(name, "x-wma")) {
+        return QMediaFormat::AudioCodec::WMA;
     }
     return QMediaFormat::AudioCodec::Unspecified;
 }
@@ -111,6 +113,8 @@ QMediaFormat::VideoCodec QGstreamerFormatInfo::videoCodecForCaps(QGstStructure s
         return QMediaFormat::VideoCodec::Theora;
     } else if (!strcmp(name, "x-jpeg")) {
         return QMediaFormat::VideoCodec::MotionJPEG;
+    } else if (!strcmp(name, "x-wmv")) {
+        return QMediaFormat::VideoCodec::WMV;
     }
     return QMediaFormat::VideoCodec::Unspecified;
 }
@@ -120,7 +124,7 @@ QMediaFormat::FileFormat QGstreamerFormatInfo::fileFormatForCaps(QGstStructure s
     const char *name = structure.name().data();
 
     if (!strcmp(name, "video/x-ms-asf")) {
-        return QMediaFormat::FileFormat::ASF;
+        return QMediaFormat::FileFormat::WMV;
     } else if (!strcmp(name, "video/x-msvideo")) {
         return QMediaFormat::FileFormat::AVI;
     } else if (!strcmp(name, "video/x-matroska")) {
@@ -195,10 +199,10 @@ static QPair<QList<QMediaFormat::AudioCodec>, QList<QMediaFormat::VideoCodec>> g
                 for (int i = 0; i < caps.size(); i++) {
                     QGstStructure structure = caps.at(i);
                     auto a = QGstreamerFormatInfo::audioCodecForCaps(structure);
-                    if (a != QMediaFormat::AudioCodec::Unspecified)
+                    if (a != QMediaFormat::AudioCodec::Unspecified && !audio.contains(a))
                         audio.append(a);
                     auto v = QGstreamerFormatInfo::videoCodecForCaps(structure);
-                    if (v != QMediaFormat::VideoCodec::Unspecified)
+                    if (v != QMediaFormat::VideoCodec::Unspecified && !video.contains(v))
                         video.append(v);
                 }
             }
@@ -271,9 +275,7 @@ QList<QGstreamerFormatInfo::CodecMap> QGstreamerFormatInfo::getMuxerList(bool de
                 }
                 if (acceptsRawAudio && fileFormats.size() == 1) {
                     switch (fileFormats.at(0)) {
-                    case QMediaFormat::AAC:
                     case QMediaFormat::Mpeg4Audio:
-                    case QMediaFormat::ALAC:
                     default:
                         break;
                     case QMediaFormat::MP3:
@@ -294,6 +296,10 @@ QList<QGstreamerFormatInfo::CodecMap> QGstreamerFormatInfo::getMuxerList(bool de
                 muxers.append({f, audioCodecs, videoCodecs});
                 if (f == QMediaFormat::MPEG4 && !fileFormats.contains(QMediaFormat::Mpeg4Audio)) {
                     muxers.append({QMediaFormat::Mpeg4Audio, audioCodecs, {}});
+                    if (audioCodecs.contains(QMediaFormat::AudioCodec::AAC))
+                        muxers.append({QMediaFormat::AAC, { QMediaFormat::AudioCodec::AAC }, {}});
+                } else if (f == QMediaFormat::WMV && !fileFormats.contains(QMediaFormat::WMA)) {
+                    muxers.append({QMediaFormat::WMA, audioCodecs, {}});
                 }
             }
         }
@@ -338,7 +344,21 @@ static QList<QImageCapture::FileFormat> getImageFormatList()
 }
 
 #if 0
-static void dumpMuxers(const QList<QGstreamerFormatsInfo::CodecMap> &muxerList)
+static void dumpAudioCodecs(const QList<QMediaFormat::AudioCodec> &codecList)
+{
+    qDebug() << "Audio codecs:";
+    for (const auto &c : codecList)
+        qDebug() << "            " << QMediaFormat::audioCodecName(c);
+}
+
+static void dumpVideoCodecs(const QList<QMediaFormat::VideoCodec> &codecList)
+{
+    qDebug() << "Video codecs:";
+    for (const auto &c : codecList)
+        qDebug() << "            " << QMediaFormat::videoCodecName(c);
+}
+
+static void dumpMuxers(const QList<QPlatformMediaFormatInfo::CodecMap> &muxerList)
 {
     for (const auto &m : muxerList) {
         qDebug() << "    " << QMediaFormat::fileFormatName(m.format);
@@ -360,7 +380,9 @@ QGstreamerFormatInfo::QGstreamerFormatInfo()
 
     codecs = getCodecsList(/*decode = */ false);
     encoders = getMuxerList(/* demuxer = */false, codecs.first, codecs.second);
-    //dumpMuxers(encoders);
+//    dumpAudioCodecs(codecs.first);
+//    dumpVideoCodecs(codecs.second);
+//    dumpMuxers(encoders);
 
     imageFormats = getImageFormatList();
 }
@@ -373,20 +395,19 @@ QGstMutableCaps QGstreamerFormatInfo::formatCaps(const QMediaFormat &f) const
     Q_ASSERT(format != QMediaFormat::UnspecifiedFormat);
 
     const char *capsForFormat[QMediaFormat::LastFileFormat + 1] = {
-        "video/x-ms-asf", // ASF
+        "video/x-ms-asf", // WMV
         "video/x-msvideo", // AVI
         "video/x-matroska", // Matroska
         "video/quicktime, variant=(string)iso", // MPEG4
         "video/ogg", // Ogg
         "video/quicktime", // QuickTime
         "video/webm", // WebM
-        "audio/mpeg, mpegversion=(int)4", // AAC
-        "audio/x-flac", // FLAC
+        "video/quicktime, variant=(string)iso", // Mpeg4Audio is the same is mp4...
+        "video/quicktime, variant=(string)iso", // AAC is also an MP4 container
+        "video/x-ms-asf", // WMA, same as WMV
         "audio/mpeg, mpegversion=(int)1, layer=(int)3", // MP3
-        "audio/mpeg, mpegversion=(int)4", // Mpeg4Audio
-        "audio/x-alac", // ALAC
+        "audio/x-flac", // FLAC
         "audio/x-wav" // Wave
-
     };
     return gst_caps_from_string(capsForFormat[format]);
 }
@@ -406,8 +427,9 @@ QGstMutableCaps QGstreamerFormatInfo::audioCaps(const QMediaFormat &f) const
         "audio/x-true-hd", // DolbyTrueHD
         "audio/x-opus", // Opus
         "audio/x-vorbis", // Vorbis
+        "audio/x-raw", // WAVE
+        "audio/x-wma", // WMA
         "audio/x-alac", // ALAC
-        "audio/x-wav", // WAVE
     };
     return gst_caps_from_string(capsForCodec[(int)codec]);
 }
@@ -428,6 +450,7 @@ QGstMutableCaps QGstreamerFormatInfo::videoCaps(const QMediaFormat &f) const
         "video/x-vp9", // VP9,
         "video/x-av1", // AV1,
         "video/x-theora", // Theora,
+        "audio/x-wmv", // WMV
         "video/x-jpeg", // MotionJPEG,
     };
     return gst_caps_from_string(capsForCodec[(int)codec]);
diff --git a/src/multimedia/platform/windows/common/qwindowsmultimediautils.cpp b/src/multimedia/platform/windows/common/qwindowsmultimediautils.cpp
index 688ed7947..9e6ee9343 100644
--- a/src/multimedia/platform/windows/common/qwindowsmultimediautils.cpp
+++ b/src/multimedia/platform/windows/common/qwindowsmultimediautils.cpp
@@ -93,11 +93,13 @@ GUID QWindowsMultimediaUtils::videoFormatForCodec(QMediaFormat::VideoCodec codec
         return MFVideoFormat_VP90;
     case QMediaFormat::VideoCodec::AV1:
         return MFVideoFormat_AV1;
+    case QMediaFormat::VideoCodec::WMV:
+        return MFVideoFormat_WMV3;
     case QMediaFormat::VideoCodec::MotionJPEG:
         return MFVideoFormat_MJPG;
+    default:
+        return MFVideoFormat_H264;
     }
-    // Use H264 as the default video codec
-    return MFVideoFormat_H264;
 }
 
 GUID QWindowsMultimediaUtils::audioFormatForCodec(QMediaFormat::AudioCodec codec)
@@ -121,9 +123,11 @@ GUID QWindowsMultimediaUtils::audioFormatForCodec(QMediaFormat::AudioCodec codec
         return MFAudioFormat_Dolby_AC3;
     case QMediaFormat::AudioCodec::EAC3:
         return MFAudioFormat_Dolby_DDPlus;
+    case QMediaFormat::AudioCodec::WMA:
+        return MFAudioFormat_WMAudioV9;
+    default:
+        return MFAudioFormat_AAC;
     }
-    // Use AAC as the default audio codec
-    return MFAudioFormat_AAC;
 }
 
 GUID QWindowsMultimediaUtils::containerForVideoFileFormat(QMediaFormat::FileFormat format)
@@ -131,12 +135,13 @@ GUID QWindowsMultimediaUtils::containerForVideoFileFormat(QMediaFormat::FileForm
     switch (format) {
     case QMediaFormat::FileFormat::MPEG4:
         return MFTranscodeContainerType_MPEG4;
-    case QMediaFormat::FileFormat::ASF:
+    case QMediaFormat::FileFormat::WMV:
         return MFTranscodeContainerType_ASF;
     case QMediaFormat::FileFormat::AVI:
         return MFTranscodeContainerType_AVI;
+    default:
+        return MFTranscodeContainerType_MPEG4;
     }
-    return MFTranscodeContainerType_MPEG4;
 }
 
 GUID QWindowsMultimediaUtils::containerForAudioFileFormat(QMediaFormat::FileFormat format)
@@ -148,14 +153,15 @@ GUID QWindowsMultimediaUtils::containerForAudioFileFormat(QMediaFormat::FileForm
         return MFTranscodeContainerType_ADTS;
     case QMediaFormat::FileFormat::Mpeg4Audio:
         return MFTranscodeContainerType_MPEG4;
-    case QMediaFormat::FileFormat::ALAC:
-        return MFTranscodeContainerType_MPEG4;
+    case QMediaFormat::FileFormat::WMA:
+        return MFTranscodeContainerType_ASF;
     case QMediaFormat::FileFormat::FLAC:
         return MFTranscodeContainerType_FLAC;
     case QMediaFormat::FileFormat::Wave:
         return MFTranscodeContainerType_WAVE;
+    default:
+        return MFTranscodeContainerType_MPEG4;
     }
-    return MFTranscodeContainerType_MPEG4;
 }
 
 QT_END_NAMESPACE
diff --git a/src/multimedia/platform/windows/qwindowsformatinfo.cpp b/src/multimedia/platform/windows/qwindowsformatinfo.cpp
index cda24d6eb..85c362b29 100644
--- a/src/multimedia/platform/windows/qwindowsformatinfo.cpp
+++ b/src/multimedia/platform/windows/qwindowsformatinfo.cpp
@@ -62,7 +62,13 @@ QWindowsFormatInfo::QWindowsFormatInfo()
           {} },
         { QMediaFormat::Mpeg4Audio,
           { QMediaFormat::AudioCodec::AAC },
-          {} }
+          {} },
+        { QMediaFormat::WMA,
+          { QMediaFormat::AudioCodec::WMA },
+          {} },
+        { QMediaFormat::WMV,
+          { QMediaFormat::AudioCodec::WMA },
+          { QMediaFormat::VideoCodec::WMV } }
     };
 
     encoders = {
@@ -77,7 +83,13 @@ QWindowsFormatInfo::QWindowsFormatInfo()
           {} },
         { QMediaFormat::Mpeg4Audio,
           { QMediaFormat::AudioCodec::AAC },
-          {} }
+          {} },
+        { QMediaFormat::WMA,
+          { QMediaFormat::AudioCodec::WMA },
+          {} },
+        { QMediaFormat::WMV,
+          { QMediaFormat::AudioCodec::WMA },
+          { QMediaFormat::VideoCodec::WMV } }
     };
 
     // ####
diff --git a/src/multimedia/qmediaformat.cpp b/src/multimedia/qmediaformat.cpp
index ca9fc0cd3..18bc4621d 100644
--- a/src/multimedia/qmediaformat.cpp
+++ b/src/multimedia/qmediaformat.cpp
@@ -49,7 +49,7 @@ namespace {
 const char *mimeTypeForFormat[QMediaFormat::LastFileFormat + 2] =
 {
     "",
-    "video/x-ms-asf",
+    "video/x-ms-wmv",
     "video/x-msvideo",
     "video/x-matroska",
     "video/mp4",
@@ -57,11 +57,11 @@ const char *mimeTypeForFormat[QMediaFormat::LastFileFormat + 2] =
     "video/quicktime",
     "video/webm",
     // Audio Formats
+    "audio/mp4",
     "audio/aac",
+    "audio/x-ms-wma",
     "audio/flac",
     "audio/mpeg",
-    "audio/mp4",
-    "audio/alac",
     "audio/wav",
 };
 
@@ -71,7 +71,7 @@ constexpr QMediaFormat::FileFormat videoFormatPriorityList[] =
     QMediaFormat::QuickTime,
     QMediaFormat::AVI,
     QMediaFormat::WebM,
-    QMediaFormat::ASF,
+    QMediaFormat::WMV,
     QMediaFormat::Matroska,
     QMediaFormat::Ogg,
     QMediaFormat::UnspecifiedFormat
@@ -79,11 +79,10 @@ constexpr QMediaFormat::FileFormat videoFormatPriorityList[] =
 
 constexpr QMediaFormat::FileFormat audioFormatPriorityList[] =
 {
-    QMediaFormat::AAC,
-    QMediaFormat::MP3,
     QMediaFormat::Mpeg4Audio,
+    QMediaFormat::MP3,
+    QMediaFormat::WMA,
     QMediaFormat::FLAC,
-    QMediaFormat::ALAC,
     QMediaFormat::Wave,
     QMediaFormat::UnspecifiedFormat
 };
@@ -96,6 +95,7 @@ constexpr QMediaFormat::AudioCodec audioPriorityList[] =
     QMediaFormat::AudioCodec::Opus,
     QMediaFormat::AudioCodec::EAC3,
     QMediaFormat::AudioCodec::DolbyTrueHD,
+    QMediaFormat::AudioCodec::WMA,
     QMediaFormat::AudioCodec::FLAC,
     QMediaFormat::AudioCodec::Vorbis,
     QMediaFormat::AudioCodec::Wave,
@@ -109,6 +109,7 @@ constexpr QMediaFormat::VideoCodec videoPriorityList[] =
     QMediaFormat::VideoCodec::H264,
     QMediaFormat::VideoCodec::AV1,
     QMediaFormat::VideoCodec::VP8,
+    QMediaFormat::VideoCodec::WMV,
     QMediaFormat::VideoCodec::Theora,
     QMediaFormat::VideoCodec::MPEG4,
     QMediaFormat::VideoCodec::MPEG2,
@@ -303,7 +304,7 @@ QString QMediaFormat::fileFormatName(QMediaFormat::FileFormat c)
 {
     constexpr const char *descriptions[QMediaFormat::LastFileFormat + 2] = {
         "Unspecified",
-        "ASF",
+        "WMV",
         "AVI",
         "Matroska",
         "MPEG-4",
@@ -311,11 +312,11 @@ QString QMediaFormat::fileFormatName(QMediaFormat::FileFormat c)
         "QuickTime",
         "WebM",
         // Audio Formats
+        "MPEG-4 Audio",
         "AAC",
-        "FLAC",
+        "WMA",
         "MP3",
-        "MPEG-4 Audio",
-        "ALAC",
+        "FLAC",
         "Wave"
     };
     return QString::fromUtf8(descriptions[int(c) + 1]);
@@ -334,6 +335,7 @@ QString QMediaFormat::audioCodecName(QMediaFormat::AudioCodec c)
         "Opus",
         "Vorbis",
         "Wave",
+        "WMA",
         "ALAC",
     };
     return QString::fromUtf8(descriptions[int(c) + 1]);
@@ -352,6 +354,7 @@ QString QMediaFormat::videoCodecName(QMediaFormat::VideoCodec c)
         "VP9",
         "AV1",
         "Theora",
+        "WMV",
         "MotionJPEG"
     };
     return QString::fromUtf8(descriptions[int(c) + 1]);
@@ -361,7 +364,7 @@ QString QMediaFormat::fileFormatDescription(QMediaFormat::FileFormat c)
 {
     constexpr const char *descriptions[QMediaFormat::LastFileFormat + 2] = {
         "Unspecified File Format",
-        "Windows Media Format",
+        "Windows Media Video",
         "Audio Video Interleave",
         "Matroska Multimedia Container",
         "MPEG-4 Video Container",
@@ -369,11 +372,11 @@ QString QMediaFormat::fileFormatDescription(QMediaFormat::FileFormat c)
         "QuickTime Container",
         "WebM",
         // Audio Formats
-        "Advanced Audio Codec (AAC)",
-        "Free Lossless Audio Codec (FLAC)",
+        "MPEG-4 Audio",
+        "AAC",
+        "Windows Media Audio",
         "MP3",
-        "MPEG-4 Audio Container",
-        "Apple Lossless Audio Codec (ALAC)",
+        "Free Lossless Audio Codec (FLAC)",
         "Wave File"
     };
     return QString::fromUtf8(descriptions[int(c) + 1]);
@@ -392,6 +395,7 @@ QString QMediaFormat::audioCodecDescription(QMediaFormat::AudioCodec c)
         "Opus",
         "Vorbis",
         "Wave",
+        "Windows Media Audio",
         "Apple Lossless Audio Codec (ALAC)",
     };
     return QString::fromUtf8(descriptions[int(c) + 1]);
@@ -410,6 +414,7 @@ QString QMediaFormat::videoCodecDescription(QMediaFormat::VideoCodec c)
         "VP9",
         "AV1",
         "Theora",
+        "Windows Media Video",
         "MotionJPEG"
     };
     return QString::fromUtf8(descriptions[int(c) + 1]);
@@ -434,6 +439,11 @@ void QMediaFormat::resolveForEncoding(ResolveFlags flags)
 {
     const bool requiresVideo = (flags & ResolveFlags::RequiresVideo) != 0;
 
+    if (!requiresVideo)
+        video = VideoCodec::Unspecified;
+
+    // need to adjust the format. Priority is given first to file format, then video codec, then audio codec
+
     QMediaFormat nullFormat;
     auto supportedFormats = nullFormat.supportedFileFormats(QMediaFormat::Encode);
     auto supportedAudioCodecs = nullFormat.supportedAudioCodecs(QMediaFormat::Encode);
@@ -464,7 +474,7 @@ void QMediaFormat::resolveForEncoding(ResolveFlags flags)
         fmt = QMediaFormat::UnspecifiedFormat;
     if (!supportedAudioCodecs.contains(audio))
         audio = QMediaFormat::AudioCodec::Unspecified;
-    if ((flags == NoFlags) || !supportedVideoCodecs.contains(video))
+    if (!requiresVideo || !supportedVideoCodecs.contains(video))
         video = QMediaFormat::VideoCodec::Unspecified;
 
     if (requiresVideo) {
@@ -482,8 +492,10 @@ void QMediaFormat::resolveForEncoding(ResolveFlags flags)
     if (fmt == QMediaFormat::UnspecifiedFormat)
         fmt = bestSupportedFileFormat();
     // still nothing? Give up
-    if (fmt == QMediaFormat::UnspecifiedFormat)
+    if (fmt == QMediaFormat::UnspecifiedFormat) {
+        *this = {};
         return;
+    }
 
     // find a working video codec
     if (requiresVideo) {
diff --git a/src/multimedia/qmediaformat.h b/src/multimedia/qmediaformat.h
index d3d3d68a2..d3631ea42 100644
--- a/src/multimedia/qmediaformat.h
+++ b/src/multimedia/qmediaformat.h
@@ -62,19 +62,19 @@ public:
     enum FileFormat {
         UnspecifiedFormat = -1,
         // Video Formats
-        ASF,
+        WMV,
         AVI,
         Matroska,
         MPEG4,
         Ogg,
         QuickTime,
         WebM,
-        // Audio Formats
+        // Audio Only Formats
+        Mpeg4Audio,
         AAC,
-        FLAC,
+        WMA,
         MP3,
-        Mpeg4Audio,
-        ALAC,
+        FLAC,
         Wave,
         LastFileFormat = Wave
     };
@@ -91,6 +91,7 @@ public:
         Opus,
         Vorbis,
         Wave,
+        WMA,
         ALAC,
         LastAudioCodec = ALAC
     };
@@ -107,6 +108,7 @@ public:
         VP9,
         AV1,
         Theora,
+        WMV,
         MotionJPEG,
         LastVideoCodec = MotionJPEG
     };
diff --git a/tests/auto/unit/multimedia/qmediaformat/tst_qmediaformat.cpp b/tests/auto/unit/multimedia/qmediaformat/tst_qmediaformat.cpp
index b7a31d300..b3d45e727 100644
--- a/tests/auto/unit/multimedia/qmediaformat/tst_qmediaformat.cpp
+++ b/tests/auto/unit/multimedia/qmediaformat/tst_qmediaformat.cpp
@@ -43,6 +43,7 @@ void tst_QMediaFormat::testResolveForEncoding()
     QMediaFormat format;
 
     auto hasVideoCodecs = !format.supportedVideoCodecs(QMediaFormat::Encode).isEmpty();
+    bool hasWav = format.supportedFileFormats(QMediaFormat::Encode).contains(QMediaFormat::Wave);
 
     // Resolve codecs for audio only stream
     format.resolveForEncoding(QMediaFormat::NoFlags);
@@ -62,6 +63,27 @@ void tst_QMediaFormat::testResolveForEncoding()
     // Resolve again for audio only stream
     format.resolveForEncoding(QMediaFormat::NoFlags);
     QVERIFY(format.videoCodec() == QMediaFormat::VideoCodec::Unspecified);
+
+    // check some specific conditions
+    if (hasWav) {
+        QMediaFormat f(QMediaFormat::Mpeg4Audio);
+        if (!f.supportedAudioCodecs(QMediaFormat::Encode).contains(QMediaFormat::AudioCodec::Wave)) {
+            qDebug() << "testing!";
+            format.setFileFormat(QMediaFormat::Mpeg4Audio);
+            format.setAudioCodec(QMediaFormat::AudioCodec::Wave);
+            format.resolveForEncoding(QMediaFormat::NoFlags);
+            QVERIFY(format.fileFormat() == QMediaFormat::Mpeg4Audio);
+            QVERIFY(format.audioCodec() != QMediaFormat::AudioCodec::Wave);
+
+            format = {};
+            format.setFileFormat(QMediaFormat::Wave);
+            format.setAudioCodec(QMediaFormat::AudioCodec::AAC);
+            format.resolveForEncoding(QMediaFormat::NoFlags);
+            QVERIFY(format.fileFormat() == QMediaFormat::Wave);
+            QVERIFY(format.audioCodec() == QMediaFormat::AudioCodec::Wave);
+        }
+    }
+
 }
 
 QTEST_MAIN(tst_QMediaFormat)
diff --git a/tests/auto/unit/multimedia/qmediarecorder/tst_qmediarecorder.cpp b/tests/auto/unit/multimedia/qmediarecorder/tst_qmediarecorder.cpp
index ed7b90234..c91728169 100644
--- a/tests/auto/unit/multimedia/qmediarecorder/tst_qmediarecorder.cpp
+++ b/tests/auto/unit/multimedia/qmediarecorder/tst_qmediarecorder.cpp
@@ -317,7 +317,7 @@ void tst_QMediaRecorder::testAudioSettings()
     QCOMPARE(recorder.audioSampleRate(), -1);
 
     QMediaFormat format;
-    format.setFileFormat(QMediaFormat::AAC);
+    format.setFileFormat(QMediaFormat::FLAC);
     recorder.setMediaFormat(format);
     QCOMPARE(recorder.mediaFormat(), format);