camera-app

Merge lp:~fboucault/camera-app/resolution_options into lp:camera-app

resolution_options
Merge into trunk

Proposed by Florian Boucault on 2015-10-14

Status:

Superseded

Proposed branch:

lp:~fboucault/camera-app/resolution_options

Merge into:

lp:camera-app

Diff against target:

728 lines (+396/-50)

9 files modified

BottomEdgeIndicators.qml (+1/-1)
CameraApp/advancedcamerasettings.cpp (+125/-0)
CameraApp/advancedcamerasettings.h (+11/-0)
OptionButton.qml (+1/-1)
ViewFinderOverlay.qml (+170/-4)
ViewFinderView.qml (+15/-16)
tests/autopilot/camera_app/emulators/main_window.py (+20/-1)
tests/autopilot/camera_app/tests/test_capture.py (+6/-27)
tests/autopilot/camera_app/tests/test_zoom.py (+47/-0)

To merge this branch:

bzr merge lp:~fboucault/camera-app/resolution_options

High

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Needs Fixing on 2015-11-25
Bill Filler (community)		2015-10-14	Needs Fixing on 2015-11-19
Review via email: mp+274402@code.launchpad.net

This proposal has been superseded by a proposal from 2015-11-25.

Commit message

New option for the user to choose between the maximum resolution the sensor allows or the resolution that fits the screen.

Revision history for this message

Florian Boucault (fboucault) wrote on 2015-10-14:

Depends on https://code.launchpad.net/~fboucault/qtubuntu-camera/resolution_fixes/+merge/274404

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-10-14:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/camera-app-ci/435/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-10-15:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/camera-app-ci/436/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-10-15:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/camera-app-ci/437/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-11-05:

FAILED: Continuous integration, rev:589
http://jenkins.qa.ubuntu.com/job/camera-app-ci/448/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-amd64-ci/144/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/144/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-i386-ci/144/console
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/295
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-mako/952
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/780
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/24901

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/camera-app-ci/448/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-11-19:

FAILED: Continuous integration, rev:592
http://jenkins.qa.ubuntu.com/job/camera-app-ci/457/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-amd64-ci/153
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/153
        deb: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/153/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-i386-ci/153
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/311
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-touch/971
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/812
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/25247

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/camera-app-ci/457/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Bill Filler (bfiller) wrote on 2015-11-19:

Framework version needs to be 15.04.3 as the required qtubuntu-camera change is not in the current 15.04.2 version that is in ota8

review: Needs Fixing

lp:~fboucault/camera-app/resolution_options updated on 2015-11-19

598. By Florian Boucault on 2015-11-19: Bumping framework version required by the app.
599. By Florian Boucault on 2015-11-19: Reverted framework bumps
600. By Florian Boucault on 2015-11-19: Dynamically show/hide the resolution options depending on the presence of framework ubuntu-sdk-15.04.3 (OTA9)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-11-19:

FAILED: Continuous integration, rev:597
http://jenkins.qa.ubuntu.com/job/camera-app-ci/463/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-amd64-ci/159
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/159
        deb: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/159/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-i386-ci/159
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/317
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-touch/978
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/819
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/25291

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/camera-app-ci/463/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-11-20:

FAILED: Continuous integration, rev:600
http://jenkins.qa.ubuntu.com/job/camera-app-ci/465/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-amd64-ci/161
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/161
        deb: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/161/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-i386-ci/161
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/319
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-touch/980
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/821
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/25306

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/camera-app-ci/465/rebuild

review: Needs Fixing (continuous-integration)

lp:~fboucault/camera-app/resolution_options updated on 2015-11-20

601. By Florian Boucault on 2015-11-20: Add /usr/share/click/frameworks/ to apparmor read path so that available frameworks can be determined.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-11-20:

FAILED: Continuous integration, rev:601
http://jenkins.qa.ubuntu.com/job/camera-app-ci/466/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-amd64-ci/162
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/162
        deb: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/162/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-i386-ci/162
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/320
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-touch/981
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/822
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/25321

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/camera-app-ci/466/rebuild

review: Needs Fixing (continuous-integration)

lp:~fboucault/camera-app/resolution_options updated on 2015-11-25

602. By Florian Boucault on 2015-11-25: Merged with trunk

Revision history for this message

Florian Boucault (fboucault) wrote on 2015-11-25:

https://myapps.developer.ubuntu.com/dev/api/click-framework/ does not have 15.04.3 yet

lp:~fboucault/camera-app/resolution_options updated on 2015-11-25

603. By Florian Boucault on 2015-11-25: Merged staging
604. By Florian Boucault on 2015-11-25: Reverted making the resolution options contingent on the presence of framework

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-11-25:

FAILED: Continuous integration, rev:602
http://jenkins.qa.ubuntu.com/job/camera-app-ci/475/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-amd64-ci/171
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/171
        deb: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-armhf-ci/171/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/camera-app-vivid-i386-ci/171
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/334
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-touch/995
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/840
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/25499

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/camera-app-ci/475/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Florian Boucault

Ubuntu Phablet Team

deaunapaul

 === modified file 'BottomEdgeIndicators.qml'
 --- BottomEdgeIndicators.qml	2015-10-22 12:21:14 +0000
 +++ BottomEdgeIndicators.qml	2015-11-25 17:47:09 +0000
@@ -84,7 +84,7 @@
                      id: indicatorIcon
                      anchors.fill: parent
                      color: "white"
--                    name: modelData && modelData.isToggle ? modelData.icon : modelData.get(model.selectedIndex).icon
++                    name: modelData && modelData.isToggle ? modelData.icon : (modelData.get(model.selectedIndex) ? modelData.get(model.selectedIndex).icon : "")
                      source: name ? "image://theme/%1".arg(name) : (modelData.iconSource || "")
                      visible: source != ""
+                 }
 === modified file 'CameraApp/advancedcamerasettings.cpp'
 --- CameraApp/advancedcamerasettings.cpp	2015-10-27 09:17:27 +0000
 +++ CameraApp/advancedcamerasettings.cpp	2015-11-25 17:47:09 +0000
@@ -26,6 +26,10 @@
  #include <QtMultimedia/QVideoDeviceSelectorControl>
  #include <QtMultimedia/QCameraFlashControl>
  #include <QtMultimedia/QCameraExposureControl>
++#include <QGuiApplication>
++#include <QScreen>
++
++#include <cmath>
  // Definition of this enum value is duplicated in qtubuntu-camera
  static const QCameraExposure::ExposureMode ExposureHdr = static_cast<QCameraExposure::ExposureMode>(QCameraExposure::ExposureModeVendor + 1);
@@ -222,6 +226,12 @@
          QObject::connect(m_cameraControl,
                           SIGNAL(captureModeChanged(QCamera::CaptureModes)),
                           this, SIGNAL(resolutionChanged()));
++        QObject::connect(m_cameraControl,
++                         SIGNAL(captureModeChanged(QCamera::CaptureModes)),
++                         this, SIGNAL(maximumResolutionChanged()));
++        QObject::connect(m_cameraControl,
++                         SIGNAL(captureModeChanged(QCamera::CaptureModes)),
++                         this, SIGNAL(fittingResolutionChanged()));
+     }
      m_cameraFlashControl = flashControlFromCamera(m_camera);
@@ -237,6 +247,8 @@
      m_videoEncoderControl = videoEncoderControlFromCamera(m_camera);
      Q_EMIT resolutionChanged();
++    Q_EMIT maximumResolutionChanged();
++    Q_EMIT fittingResolutionChanged();
      Q_EMIT hasFlashChanged();
      Q_EMIT hasHdrChanged();
      Q_EMIT hdrEnabledChanged();
@@ -260,6 +272,8 @@
+         }
          Q_EMIT activeCameraIndexChanged();
          Q_EMIT resolutionChanged();
++        Q_EMIT maximumResolutionChanged();
++        Q_EMIT fittingResolutionChanged();
          Q_EMIT hasFlashChanged();
          Q_EMIT videoSupportedResolutionsChanged();
+     }
@@ -277,6 +291,117 @@
      return QSize();
+ }
++QSize AdvancedCameraSettings::imageCaptureResolution() const
++{
++    if (m_imageEncoderControl != 0) {
++        return m_imageEncoderControl->imageSettings().resolution();
++    }
++
++    return QSize();
++}
++
++QSize AdvancedCameraSettings::videoRecorderResolution() const
++{
++    if (m_videoEncoderControl != 0) {
++        return m_videoEncoderControl->videoSettings().resolution();
++    }
++
++    return QSize();
++}
++
++QSize AdvancedCameraSettings::maximumResolution() const
++{
++    if (m_imageEncoderControl) {
++        QList<QSize> sizes = m_imageEncoderControl->supportedResolutions(
++                                       m_imageEncoderControl->imageSettings());
++
++        QSize maximumSize;
++        long maximumPixels = 0;
++
++        QList<QSize>::const_iterator it = sizes.begin();
++        while (it != sizes.end()) {
++            const long pixels = ((long)((*it).width())) * ((long)((*it).height()));
++            if (pixels > maximumPixels) {
++                maximumSize = *it;
++                maximumPixels = pixels;
++            }
++            ++it;
++        }
++
++        return maximumSize;
++    }
++
++    return QSize();
++}
++
++float AdvancedCameraSettings::getScreenAspectRatio() const
++{
++    float screenAspectRatio;
++    QScreen *screen = QGuiApplication::primaryScreen();
++    Q_ASSERT(!screen);
++    const int kScreenWidth = screen->geometry().width();
++    const int kScreenHeight = screen->geometry().height();
++    Q_ASSERT(kScreenWidth > 0 && kScreenHeight > 0);
++
++    screenAspectRatio = (kScreenWidth > kScreenHeight) ?
++        ((float)kScreenWidth / (float)kScreenHeight) : ((float)kScreenHeight / (float)kScreenWidth);
++
++    return screenAspectRatio;
++}
++
++QSize AdvancedCameraSettings::fittingResolution() const
++{
++    QList<float> prioritizedAspectRatios;
++    prioritizedAspectRatios.append(getScreenAspectRatio());
++    const float backAspectRatios[4] = { 16.0f/9.0f, 3.0f/2.0f, 4.0f/3.0f, 5.0f/4.0f };
++    for (int i=0; i<4; ++i) {
++        if (!prioritizedAspectRatios.contains(backAspectRatios[i])) {
++            prioritizedAspectRatios.append(backAspectRatios[i]);
++        }
++    }
++
++    if (m_imageEncoderControl) {
++        QList<QSize> sizes = m_imageEncoderControl->supportedResolutions(
++                                       m_imageEncoderControl->imageSettings());
++
++        QSize optimalSize;
++        long optimalPixels = 0;
++
++        if (!sizes.empty()) {
++            float aspectRatio;
++
++            // Loop over all reported camera resolutions until we find the highest
++            // one that matches the current prioritized aspect ratio. If it doesn't
++            // find one on the current aspect ration, it selects the next ratio and
++            // tries again.
++            QList<float>::const_iterator ratioIt = prioritizedAspectRatios.begin();
++            while (ratioIt != prioritizedAspectRatios.end()) {
++                // Don't update the aspect ratio when using this function for finding
++                // the optimal thumbnail size as it will affect the preview window size
++                aspectRatio = (*ratioIt);
++
++                QList<QSize>::const_iterator it = sizes.begin();
++                while (it != sizes.end()) {
++                    const float ratio = (float)(*it).width() / (float)(*it).height();
++                    const long pixels = ((long)((*it).width())) * ((long)((*it).height()));
++                    const float EPSILON = 0.02;
++                    if (fabs(ratio - aspectRatio) < EPSILON && pixels > optimalPixels) {
++                        optimalSize = *it;
++                        optimalPixels = pixels;
++                    }
++                    ++it;
++                }
++                if (optimalPixels > 0) break;
++                ++ratioIt;
++            }
++        }
++
++        return optimalSize;
++    }
++
++    return QSize();
++}
++
  QStringList AdvancedCameraSettings::videoSupportedResolutions() const
+ {
      if (m_videoEncoderControl) {
 === modified file 'CameraApp/advancedcamerasettings.h'
 --- CameraApp/advancedcamerasettings.h	2014-12-08 19:12:52 +0000
 +++ CameraApp/advancedcamerasettings.h	2015-11-25 17:47:09 +0000
@@ -40,6 +40,10 @@
      Q_PROPERTY (int activeCameraIndex READ activeCameraIndex WRITE setActiveCameraIndex
                  NOTIFY activeCameraIndexChanged)
      Q_PROPERTY (QSize resolution READ resolution NOTIFY resolutionChanged)
++    Q_PROPERTY (QSize imageCaptureResolution READ imageCaptureResolution)
++    Q_PROPERTY (QSize videoRecorderResolution READ videoRecorderResolution)
++    Q_PROPERTY (QSize maximumResolution READ maximumResolution NOTIFY maximumResolutionChanged)
++    Q_PROPERTY (QSize fittingResolution READ fittingResolution NOTIFY fittingResolutionChanged)
      Q_PROPERTY (QStringList videoSupportedResolutions READ videoSupportedResolutions NOTIFY videoSupportedResolutionsChanged)
      Q_PROPERTY (bool hasFlash READ hasFlash NOTIFY hasFlashChanged)
      Q_PROPERTY (bool hdrEnabled READ hdrEnabled WRITE setHdrEnabled NOTIFY hdrEnabledChanged)
@@ -53,6 +57,11 @@
      void setCamera(QObject* camera);
      void setActiveCameraIndex(int index);
      QSize resolution() const;
++    QSize imageCaptureResolution() const;
++    QSize videoRecorderResolution() const;
++    QSize maximumResolution() const;
++    QSize fittingResolution() const;
++    float getScreenAspectRatio() const;
      QStringList videoSupportedResolutions() const;
      bool hasFlash() const;
      bool hasHdr() const;
@@ -66,6 +75,8 @@
      void cameraChanged();
      void activeCameraIndexChanged();
      void resolutionChanged();
++    void maximumResolutionChanged();
++    void fittingResolutionChanged();
      void hasFlashChanged();
      void hasHdrChanged();
      void hdrEnabledChanged();
 === modified file 'OptionButton.qml'
 --- OptionButton.qml	2015-10-22 12:21:14 +0000
 +++ OptionButton.qml	2015-11-25 17:47:09 +0000
@@ -23,7 +23,7 @@
      property var model
      property string settingsProperty: model.settingsProperty
--    iconName: model.isToggle || !model.get(model.selectedIndex).icon ? model.icon : model.get(model.selectedIndex).icon
++    iconName: !model.get(model.selectedIndex).icon ? model.icon : model.get(model.selectedIndex).icon
      iconSource: (model && model.iconSource) ? model.iconSource : ""
      on: model.isToggle ? model.get(model.selectedIndex).value : true
      enabled: model.available
 === modified file 'ViewFinderOverlay.qml'
 --- ViewFinderOverlay.qml	2015-10-22 12:21:14 +0000
 +++ ViewFinderOverlay.qml	2015-11-25 17:47:09 +0000
@@ -50,6 +50,13 @@
          property bool gridEnabled: false
          property bool preferRemovableStorage: false
          property string videoResolution: "1920x1080"
++        property bool playShutterSound: true
++        // FIXME: stores the resolution selected for 2 cameras. Instead it should:
++        //  - support any number of cameras
++        //  - not rely on the camera index but on Camera.deviceId
++        // Ref.: http://doc.qt.io/qt-5/qml-qtmultimedia-camera.html#deviceId-prop
++        property string photoResolution0
++        property string photoResolution1
          onFlashModeChanged: if (flashMode != Camera.FlashOff) hdrEnabled = false;
          onHdrEnabledChanged: if (hdrEnabled) flashMode = Camera.FlashOff
@@ -87,12 +94,83 @@
          value: settings.videoResolution
+     }
++    Binding {
++        target: camera.imageCapture
++        property: "resolution"
++        value: settings["photoResolution" + camera.advanced.activeCameraIndex]
++    }
++
++    Connections {
++        target: camera.imageCapture
++        onResolutionChanged: {
++            // FIXME: this is a necessary workaround because:
++            // - Neither camera.viewfinder.resolution nor camera.advanced.resolution
++            //   emit a changed signal when the underlying AalViewfinderSettingsControl's
++            //   resolution changes
++            // - we know that qtubuntu-camera changes the resolution of the
++            //   viewfinder automatically when the capture resolution is set
++            // - we need camera.viewfinder.resolution to hold the right
++            //   value
++            camera.viewfinder.resolution = camera.advanced.resolution;
++        }
++    }
++
++    Connections {
++        target: camera.videoRecorder
++        onResolutionChanged: {
++            // FIXME: see workaround setting camera.viewfinder.resolution above
++            camera.viewfinder.resolution = camera.advanced.resolution;
++        }
++    }
++
++    Connections {
++        target: camera
++        onCaptureModeChanged: {
++            // FIXME: see workaround setting camera.viewfinder.resolution above
++            camera.viewfinder.resolution = camera.advanced.resolution;
++        }
++    }
++
      function resolutionToLabel(resolution) {
          // takes in a resolution string (e.g. "1920x1080") and returns a nicer
          // form of it for display in the UI: "1080p"
          return resolution.split("x").pop() + "p";
+     }
++    function sizeToString(size) {
++        return size.width + "x" + size.height;
++    }
++
++    function stringToSize(resolution) {
++        var r = resolution.split("x");
++        return Qt.size(r[0], r[1]);
++    }
++
++    function sizeToAspectRatio(size) {
++        var ratio = Math.max(size.width, size.height) / Math.min(size.width, size.height);
++        var maxDenominator = 12;
++        var epsilon;
++        var numerator;
++        var denominator;
++        var bestDenominator;
++        var bestEpsilon = 10000;
++        for (denominator = 2; denominator <= maxDenominator; denominator++) {
++            numerator = ratio * denominator;
++            epsilon = Math.abs(Math.round(numerator) - numerator);
++            if (epsilon < bestEpsilon) {
++                bestEpsilon = epsilon;
++                bestDenominator = denominator;
++            }
++        }
++        numerator = Math.round(ratio * bestDenominator);
++        return "%1:%2".arg(numerator).arg(bestDenominator);
++    }
++
++    function sizeToMegapixels(size) {
++        var megapixels = (size.width * size.height) / 1000000;
++        return parseFloat(megapixels.toFixed(1))
++    }
++
      function updateVideoResolutionOptions() {
          // Clear and refill videoResolutionOptionsModel with available resolutions
          // Try to only display well known resolutions: 1080p, 720p and 480p
@@ -110,25 +188,71 @@
+         }
          // If resolution setting chosen is not supported select the highest available resolution
--        if (supported.indexOf(settings.videoResolution) == -1) {
++        if (supported.length > 0 && supported.indexOf(settings.videoResolution) == -1) {
              settings.videoResolution = supported[supported.length - 1];
+         }
+     }
++    function updatePhotoResolutionOptions() {
++        // Clear and refill photoResolutionOptionsModel with available resolutions
++        photoResolutionOptionsModel.clear();
++
++        var optionMaximum = {"icon": "",
++                             "label": "%1 (%2MP)".arg(sizeToAspectRatio(camera.advanced.maximumResolution))
++                                                 .arg(sizeToMegapixels(camera.advanced.maximumResolution)),
++                             "value": sizeToString(camera.advanced.maximumResolution)};
++
++        var optionFitting = {"icon": "",
++                             "label": "%1 (%2MP)".arg(sizeToAspectRatio(camera.advanced.fittingResolution))
++                                                 .arg(sizeToMegapixels(camera.advanced.fittingResolution)),
++                             "value": sizeToString(camera.advanced.fittingResolution)};
++
++        photoResolutionOptionsModel.insert(0, optionMaximum);
++        if (camera.advanced.fittingResolution != camera.advanced.maximumResolution) {
++            photoResolutionOptionsModel.insert(1, optionFitting);
++        }
++
++        var photoResolution = settings["photoResolution" + camera.advanced.activeCameraIndex];
++        // If resolution setting chosen is not supported select the fitting resolution
++        if (photoResolution != optionFitting.value &&
++            photoResolution != optionMaximum.value) {
++            settings["photoResolution" + camera.advanced.activeCameraIndex] = optionFitting.value;
++        }
++    }
++
      Component.onCompleted: {
++        camera.cameraState = Camera.LoadedState;
          updateVideoResolutionOptions();
++        updatePhotoResolutionOptions();
++        // FIXME: see workaround setting camera.viewfinder.resolution above
++        camera.viewfinder.resolution = camera.advanced.resolution;
++        camera.cameraState = Camera.ActiveState;
+     }
      Connections {
          target: camera.advanced
          onVideoSupportedResolutionsChanged: updateVideoResolutionOptions();
++        onFittingResolutionChanged: updatePhotoResolutionOptions();
++        onMaximumResolutionChanged: updatePhotoResolutionOptions();
+     }
      Connections {
          target: camera.advanced
          onActiveCameraIndexChanged: {
++            var hasPhotoResolutionSetting = (settings["photoResolution" + camera.advanced.activeCameraIndex] != "")
++            // FIXME: use camera.advanced.imageCaptureResolution instead of camera.imageCapture.resolution
++            // because the latter is not updated when the backend changes the resolution
++            settings["photoResolution" + camera.advanced.activeCameraIndex] = sizeToString(camera.advanced.imageCaptureResolution);
++            settings.videoResolution = sizeToString(camera.advanced.videoRecorderResolution);
++            updatePhotoResolutionOptions();
              updateVideoResolutionOptions();
--            camera.videoRecorder.resolution = settings.videoResolution;
++            // FIXME: see workaround setting camera.viewfinder.resolution above
++            camera.viewfinder.resolution = camera.advanced.resolution;
++
++            // If no resolution has ever been chosen, select the one that fits the screen
++            if (!hasPhotoResolutionSetting) {
++                settings["photoResolution" + camera.advanced.activeCameraIndex] = sizeToString(camera.advanced.fittingResolution);
++            }
+         }
+     }
@@ -280,7 +404,7 @@
                      property bool isToggle: true
                      property int selectedIndex: bottomEdge.indexForValue(hdrOptionsModel, settings.hdrEnabled)
                      property bool available: camera.advanced.hasHdr
--                    property bool visible: true
++                    property bool visible: camera.captureMode === Camera.CaptureStillImage
                      property bool showInIndicators: true
                      ListElement {
@@ -404,6 +528,41 @@
                      property bool available: true
                      property bool visible: camera.captureMode == Camera.CaptureVideo
                      property bool showInIndicators: false
++                },
++                ListModel {
++                    id: shutterSoundOptionsModel
++
++                    property string settingsProperty: "playShutterSound"
++                    property string icon: ""
++                    property string label: ""
++                    property bool isToggle: true
++                    property int selectedIndex: bottomEdge.indexForValue(shutterSoundOptionsModel, settings.playShutterSound)
++                    property bool available: true
++                    property bool visible: camera.captureMode === Camera.CaptureStillImage
++                    property bool showInIndicators: false
++
++                    ListElement {
++                        icon: "audio-volume-high"
++                        label: QT_TR_NOOP("On")
++                        value: true
++                    }
++                    ListElement {
++                        icon: "audio-volume-muted"
++                        label: QT_TR_NOOP("Off")
++                        value: false
++                    }
++                },
++                ListModel {
++                    id: photoResolutionOptionsModel
++
++                    property string settingsProperty: "photoResolution" + camera.advanced.activeCameraIndex
++                    property string icon: ""
++                    property string label: sizeToAspectRatio(stringToSize(settings[settingsProperty]))
++                    property bool isToggle: false
++                    property int selectedIndex: bottomEdge.indexForValue(photoResolutionOptionsModel, settings[settingsProperty])
++                    property bool available: true
++                    property bool visible: camera.captureMode == Camera.CaptureStillImage
++                    property bool showInIndicators: false
+                 }
+             ]
@@ -571,18 +730,25 @@
          function completeSwitch() {
              viewFinderSwitcherAnimation.restart();
              camera.switchInProgress = false;
++            zoomControl.value = camera.currentZoom;
+         }
          function changeRecordMode() {
              if (camera.captureMode == Camera.CaptureVideo) camera.videoRecorder.stop()
              camera.captureMode = (camera.captureMode == Camera.CaptureVideo) ? Camera.CaptureStillImage : Camera.CaptureVideo
++            zoomControl.value = camera.currentZoom
++        }
++
++        Connections {
++            target: Qt.application
++            onActiveChanged: if (active) zoomControl.value = camera.currentZoom
+         }
          Timer {
              id: shootingTimer
              repeat: true
              triggeredOnStart: true
--
++
              property int remainingSecs: 0
              onTriggered: {
 === modified file 'ViewFinderView.qml'
 --- ViewFinderView.qml	2015-11-16 15:54:25 +0000
 +++ ViewFinderView.qml	2015-11-25 17:47:09 +0000
@@ -36,6 +36,7 @@
      Camera {
          id: camera
          captureMode: Camera.CaptureStillImage
++        cameraState: Camera.UnloadedState
          StateSaver.properties: "captureMode"
          function manualFocus(x, y) {
@@ -67,10 +68,6 @@
              StateSaver.properties: "activeCameraIndex"
+         }
--        Component.onCompleted: {
--            camera.start();
--        }
--
          /* Use only digital zoom for now as it's what phone cameras mostly use.
                 TODO: if optical zoom is available, maximumZoom should be the combined
                 range of optical and digital zoom and currentZoom should adjust the two
@@ -121,12 +118,14 @@
          target: Qt.application
          onActiveChanged: {
              if (Qt.application.active) {
--                camera.start()
++                if (camera.cameraState == Camera.LoadedState) {
++                    camera.cameraState = Camera.ActiveState;
++                }
              } else if (!application.desktopMode) {
                  if (camera.videoRecorder.recorderState == CameraRecorder.RecordingState) {
                      camera.videoRecorder.stop();
+                 }
--                camera.stop()
++                camera.cameraState = Camera.LoadedState;
+             }
+         }
+     }
@@ -250,16 +249,16 @@
                  axis.x: 0; axis.y: 1; axis.z: 0
                  angle: application.desktopMode ? 180 : 0
+             }
--
--            ViewFinderGeometry {
--                id: viewFinderGeometry
--                anchors.centerIn: parent
--
--                cameraResolution: camera.advanced.resolution
--                viewFinderHeight: viewFinder.height
--                viewFinderWidth: viewFinder.width
--                viewFinderOrientation: viewFinder.orientation
--            }
++        }
++
++        ViewFinderGeometry {
++            id: viewFinderGeometry
++            anchors.centerIn: parent
++
++            cameraResolution: camera.viewfinder.resolution
++            viewFinderHeight: viewFinder.height
++            viewFinderWidth: viewFinder.width
++            viewFinderOrientation: viewFinder.orientation
+         }
          Item {
 === modified file 'tests/autopilot/camera_app/emulators/main_window.py'
 --- tests/autopilot/camera_app/emulators/main_window.py	2015-11-20 15:01:02 +0000
 +++ tests/autopilot/camera_app/emulators/main_window.py	2015-11-25 17:47:09 +0000
@@ -7,7 +7,7 @@
  from camera_app.emulators.panel import Panel
  from autopilot.matchers import Eventually
--from testtools.matchers import Equals
++from testtools.matchers import Equals, NotEquals
  class MainWindow(object):
@@ -163,3 +163,22 @@
              tx, ty, (tx + view_switcher.width // 2), ty, rate=1)
          viewfinder = self.get_viewfinder()
          testCase.assertThat(viewfinder.inView, Eventually(Equals(True)))
++
++    def switch_cameras(self):
++        # Swap cameras and wait for camera to settle
++        shoot_button = self.get_exposure_button()
++        swap_camera_button = self.get_swap_camera_button()
++        self.app.pointing_device.move_to_object(swap_camera_button)
++        self.app.pointing_device.click()
++        shoot_button.enabled.wait_for(True)
++
++    def switch_recording_mode(self):
++        record_control = self.get_record_control()
++
++        # Wait for the camera overlay to be loaded
++        record_control.enabled.wait_for(True)
++        record_control.width.wait_for(NotEquals(0))
++        record_control.height.wait_for(NotEquals(0))
++
++        self.app.pointing_device.move_to_object(record_control)
++        self.app.pointing_device.click()
 === modified file 'tests/autopilot/camera_app/tests/test_capture.py'
 --- tests/autopilot/camera_app/tests/test_capture.py	2015-10-05 13:14:12 +0000
 +++ tests/autopilot/camera_app/tests/test_capture.py	2015-11-25 17:47:09 +0000
@@ -90,13 +90,11 @@
          """
          # Get all the elements
--        record_control = self.main_window.get_record_control()
          stop_watch = self.main_window.get_stop_watch()
          exposure_button = self.main_window.get_exposure_button()
          # Click the record button to toggle photo/video mode
--        self.pointing_device.move_to_object(record_control)
--        self.pointing_device.click()
++        self.main_window.switch_recording_mode()
          # Before recording the stop watch should read zero recording time
          # and not be visible anyway.
@@ -137,8 +135,7 @@
          # Now stop the video and go back to picture mode and check if
          # everything resets itself to previous states
          self.pointing_device.click()
--        self.pointing_device.move_to_object(record_control)
--        self.pointing_device.click()
++        self.main_window.switch_recording_mode()
          self.assertThat(stop_watch.opacity, Eventually(Equals(0.0)))
@@ -268,7 +265,7 @@
      """Test recording videos at a set resolution and switching cameras"""
      def test_video_resolution_setting_switching_cameras(self):
          # switch to video recording and empty video folder
--        self.switch_to_video_recording()
++        self.main_window.switch_recording_mode()
          self.delete_all_videos()
          # select the first resolution for the current camera
@@ -277,14 +274,14 @@
          self.set_video_resolution(initial_resolution)
          # switch cameras and select the last resolution for the current camera
--        self.switch_cameras()
++        self.main_window.switch_cameras()
          resolutions = self.get_available_video_resolutions()
          expected_resolution = resolutions[-1]
          self.assertThat(expected_resolution, NotEquals(initial_resolution))
          self.set_video_resolution(expected_resolution)
          # switch back to the initial camera and record a video
--        self.switch_cameras()
++        self.main_window.switch_cameras()
          self.record_video(2)
          video_file = self.get_first_video()
          height = self.read_video_height(video_file)
@@ -292,17 +289,9 @@
              expected_resolution)
          self.assertThat(height, Equals(expected_height))
--    def switch_cameras(self):
--        # Swap cameras and wait for camera to settle
--        shoot_button = self.main_window.get_exposure_button()
--        swap_camera_button = self.main_window.get_swap_camera_button()
--        self.pointing_device.move_to_object(swap_camera_button)
--        self.pointing_device.click()
--        self.assertThat(shoot_button.enabled, Eventually(Equals(True)))
--
      """Test recording videos at various resolutions"""
      def test_video_resolution_setting(self):
--        self.switch_to_video_recording()
++        self.main_window.switch_recording_mode()
          resolutions = self.get_available_video_resolutions()
          for resolution_label in resolutions:
@@ -316,16 +305,6 @@
              self.assertThat(height, Equals(expected_height))
              self.dismiss_first_photo_hint()
--    def switch_to_video_recording(self):
--        record_control = self.main_window.get_record_control()
--        # Wait for the camera overlay to be loaded
--        self.assertThat(record_control.enabled, Eventually(Equals(True)))
--        self.assertThat(record_control.width, Eventually(NotEquals(0)))
--        self.assertThat(record_control.height, Eventually(NotEquals(0)))
--
--        self.pointing_device.move_to_object(record_control)
--        self.pointing_device.click()
--
      def get_available_video_resolutions(self):
          # open bottom edge
          bottom_edge = self.main_window.get_bottom_edge()
 === modified file 'tests/autopilot/camera_app/tests/test_zoom.py'
 --- tests/autopilot/camera_app/tests/test_zoom.py	2015-04-29 15:56:44 +0000
 +++ tests/autopilot/camera_app/tests/test_zoom.py	2015-11-25 17:47:09 +0000
@@ -68,3 +68,50 @@
          self.pointing_device.drag(tx, ty, (tx - zoom_control.width), ty)
          self.assertThat(zoom_control.value, Eventually(Equals(1.0)))
++
++    """Tests zoom is reset to minimum on camera switch"""
++    def test_zoom_reset_on_camera_change(self):
++        zoom_control = self.main_window.get_zoom_control()
++        zoom_slider = self.main_window.get_zoom_slider()
++
++        self.activate_zoom()
++        x, y, w, h = zoom_slider.globalRect
++        tx = x + (w // 2)
++        ty = y + (h // 2)
++        self.pointing_device.drag(tx, ty, (tx + zoom_control.width), ty)
++        self.assertThat(
++            zoom_control.value, Eventually(Equals(zoom_control.maximumValue)))
++
++        self.main_window.switch_cameras()
++        self.assertThat(
++            zoom_control.value, Eventually(Equals(zoom_control.minimumValue)))
++
++        self.activate_zoom()
++        self.pointing_device.drag(tx, ty, (tx + zoom_control.width), ty)
++        self.assertThat(
++            zoom_control.value, Eventually(Equals(zoom_control.maximumValue)))
++
++        self.main_window.switch_cameras()
++        self.assertThat(
++            zoom_control.value, Eventually(Equals(zoom_control.minimumValue)))
++
++    """Tests zoom is reset to minimum on recording mode switch"""
++    def test_zoom_reset_on_recording_mode_change(self):
++        zoom_control = self.main_window.get_zoom_control()
++        zoom_slider = self.main_window.get_zoom_slider()
++
++        self.activate_zoom()
++        x, y, w, h = zoom_slider.globalRect
++        tx = x + (w // 2)
++        ty = y + (h // 2)
++        self.pointing_device.drag(tx, ty, (tx + zoom_control.width), ty)
++        self.assertThat(
++            zoom_control.value, Eventually(Equals(zoom_control.maximumValue)))
++
++        self.main_window.switch_recording_mode()
++        self.assertThat(
++            zoom_control.value, Eventually(Equals(zoom_control.minimumValue)))
++
++        # Ideally we should test the same thing when switching back to photo
++        # mode, however due to http://pad.lv/1191088 zooming when recording
++        # video is disabled, so adding that test is pointless until fixed.

camera-app

Merge lp:~fboucault/camera-app/resolution_options into lp:camera-app

Commit message

Description of the change

Unmerged revisions

Preview Diff

Subscribers