How get all resolution of a webcam?

[Mahdi]

i think i find answer, i must use this code :

processFramesThread.pause();

videoCapture.release();
videoCapture.open(0);
videoCapture.set(cv::CAP_PROP_FRAME_WIDTH, width);
videoCapture.set(cv::CAP_PROP_FRAME_HEIGHT, height);

processFramesThread.resume();

But this takes about 10 seconds, in other apps it takes about 1 second, and it shows these 2 warnings, what’s wrong with me?

[ WARN:0] global F:.…\OpenCV\4.5.4\opencv\modules\videoio\src\cap_msmf.cpp (438) `anonymous-namespace’::SourceReaderCB::~SourceReaderCB terminating async callback

[ WARN:1] global F:.…\4.5.4\opencv\modules\videoio\src\cap_msmf.cpp (1022) CvCapture_MSMF::grabFrame videoio(MSMF): can’t grab frame. Error: -2147483638

My function to check frames :

void file_webcam::ProcessWebcamFrames(QString name)
{
    cv::Mat frame;
    QString fileName;
    QString currentTime;
    QLocale testLocale = QLocale(QLocale::English, QLocale::UnitedStates);
    //---
    double contrast;
    int brightness;
    //---
    // list of resolution standards in computer monitors
    // https://en.wikipedia.org/wiki/List_of_common_resolutions
    // https://en.wikipedia.org/wiki/Graphics_display_resolution
    QVector<QVector<int>> standardResolutions =
    {
        {160, 120},

        {192, 144},
        {256, 144},

        {240, 160},

        {320, 240},
        {360, 240},
        {384, 240},
        {400, 240},
        {432, 240},

        {480, 320},

        {480, 360},
        {640, 360},

        {600, 480},
        {640, 480},
        {720, 480},
        {768, 480},
        {800, 480},
        {854, 480},
        {960, 480},

        {675, 540},
        {960, 540},

        {720, 576},
        {768, 576},
        {1024, 576},

        {750, 600},
        {800, 600},
        {1024, 600},

        {960, 640},
        {1024, 640},
        {1136, 640},

        {960, 720},
        {1152, 720},
        {1280, 720},
        {1440, 720},

        {960, 768},
        {1024, 768},
        {1152, 768},
        {1280, 768},
        {1366, 768},

        {1280, 800},

        {1152, 864},
        {1280, 864},
        {1536, 864},

        {1200, 900},
        {1440, 900},
        {1600, 900},

        {1280, 960},
        {1440, 960},
        {1536, 960},

        {1280, 1024},
        {1600, 1024},

        {1400, 1050},
        {1680, 1050},

        {1440, 1080},
        {1920, 1080},
        {2160, 1080},
        {2280, 1080},
        {2560, 1080},

        {2048, 1152},

        {1500, 1200},
        {1600, 1200},
        {1920, 1200},

        {1920, 1280},
        {2048, 1280},

        {1920, 1440},
        {2160, 1440},
        {2304, 1440},
        {2560, 1440},
        {2880, 1440},
        {2960, 1440},
        {3040, 1440},
        {3120, 1440},
        {3200, 1440},
        {3440, 1440},
        {5120, 1440},

        {2048, 1536},

        {2400, 1600},
        {2560, 1600},
        {3840, 1600},

        {2880, 1620},

        {2880, 1800},
        {3200, 1800},

        {2560, 1920},
        {2880, 1920},
        {3072, 1920},

        {2560, 2048},
        {2732, 2048},
        {3200, 2048},

        {2880, 2160},
        {3240, 2160},
        {3840, 2160},
        {4320, 2160},
        {5120, 2160},

        {3200, 2400},
        {3840, 2400},

        {3840, 2560},
        {4096, 2560},

        {5120, 2880},
        {5760, 2880},

        {4096, 3072},

        {7680, 4320},
        {10240, 4320},
    };
    //QVector<QVector<int>> possibleResolutions(1000, QVector< int >(2));



    while(true)
    {
        ShowMessageOnStatusBar();

        if(videoCapture.isOpened())
        {
            // Find All Possible Webcam Resolutions [ only 1 time ]
            if(allPossibleResolutionsFinded == false)
            {
                for(int i = 0; i < standardResolutions.count(); i++)
                {
                    int w = standardResolutions[i][0];
                    int h = standardResolutions[i][1];

                    videoCapture.set(cv::CAP_PROP_FRAME_WIDTH, w);
                    videoCapture.set(cv::CAP_PROP_FRAME_HEIGHT, h);
                    int _w = videoCapture.get(cv::CAP_PROP_FRAME_WIDTH);
                    int _h = videoCapture.get(cv::CAP_PROP_FRAME_HEIGHT);

                    if(w == _w && h == _h)
                    {
                        QString item = QString("%1x%2").arg(w).arg(h);
                        ui->comboBox_PossibleResolutions->addItem(item);
                    }
                }

                qDebug() << "END!";

                allPossibleResolutionsFinded = true;
            }



            // read next frame
            videoCapture >> frame;
            if(frame.empty() == false)
            {
                // increase frame counter
                numberFramesAfterConnect++;



                // apply effects on frame
                contrast = (double)ui->horizontalSlider_Contrast->value() / 100.0; // 1 to 5
                brightness = ui->horizontalSlider_Brightness->value(); // -255 to 255
                frame.convertTo(frame, -1, contrast, brightness);



                // show frame
                cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB); // Qt reads in RGB whereas CV in BGR
                QImage image((uchar*)frame.data, frame.cols, frame.rows, frame.step, QImage::Format_RGB888); // Converts the CV image into Qt standard format
                ui->label_Image->setPixmap(QPixmap::fromImage(image)); // display the image in label that is created earlier



                // if start button pressed
                if(isStarted)
                {
                    // save frame as image
                    if(canSaveImageNow)
                    {
                        currentTime = testLocale.toString(QDateTime::currentDateTime(), "hh-mm-ss.zzz");
                        fileName = LastDirectoryPath_SaveImageVideo + "/" + QString::number(numberFramesAfterConnect) + ") " + currentTime + ".jpg";
                        image.save(fileName);

                        canSaveImageNow = false;
                    }

                    // save frame as video
                }
            }
        }
    }
}