hugin-devs team mailing list archive

[Roumano <roumano@xxxxxxxxx>]

nona version 2014.0.0.51ff237f209e

nona -g -z LZW -r ldr -m TIFF_m -o test  -i 0 -d ~/raw/pano/test.pto


nona: using graphics card: ATI Technologies Inc. AMD Radeon HD 7900 Series  
destStart=[2719, 862]
destEnd=[6263, 3092]
destSize=[(3544, 2230)]
srcSize=[(5200, 3462)]
srcBuffer=0x7f92f5e40010
srcAlphaBuffer=0x7f92f1851010
destBuffer=0x7f92f3107010
destAlphaBuffer=0x7f92f297d010
destGLInternalFormat=GL_RGBA16
destGLFormat=GL_RGB
destGLType=GL_UNSIGNED_SHORT
srcGLInternalFormat=GL_RGBA16
srcGLFormat=GL_RGB
srcGLType=GL_UNSIGNED_SHORT
srcAlphaGLType=GL_UNSIGNED_BYTE
destAlphaGLType=GL_UNSIGNED_BYTE

warparound=0
needsAtanWorkaround=1
maxTextureSize=16384
Source chunks:
    [(0, 0) to (5200, 3462) = (5200x3462)]
Dest chunks:
    [(0, 0) to (1772, 2230) = (1772x2230)]
    [(1772, 0) to (3544, 2230) = (1772x2230)]
Total GPU memory used: 455759320
Interpolator chunks:
    [(0, 0) to (4, 4) = (4x4)]
#version 110
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect SrcTexture;
float sinh(in float x) { return (exp(x) - exp(-x)) / 2.0; }
float cosh(in float x) { return (exp(x) + exp(-x)) / 2.0; }
float atan2_xge0(const in float y, const in float x) {
    if (abs(y) > x) {
        return sign(y) * (1.5707963267948965580 - atan(x, abs(y)));
    } else {
        return atan(y, x);
    }
}
float atan2_safe(const in float y, const in float x) {
    if (x >= 0.0) return atan2_xge0(y, x);
    else return (sign(y) * 3.1415926535897931160) - atan2_xge0(y, -x);
}
float atan_safe(const in float yx) {
    if (abs(yx) > 1.0) {
        return sign(yx) * (1.5707963267948965580 - atan(1.0/abs(yx)));
    } else {
        return atan(yx);
    }
}
void main(void)
{
    float discardA = 1.0;
    float discardB = 0.0;
    vec2 src = gl_TexCoord[0].st;
    src -= vec2(3220.0000000000000000, 1610.0000000000000000);

    // erect_pano(2975.6840327762110974)
    src.t = 2975.6840327762110974 * atan_safe(src.t / 2975.6840327762110974);

    // rotate_erect(9348.3870967741931963, -1350.3225806451612243)
    {
        src.s += -1350.3225806451612243;
        float w = (abs(src.s) > 9348.3870967741931963) ? 1.0 : 0.0;
        float n = (src.s < 0.0) ? 0.5 : -0.5;
        src.s += w * -18696.774193548386393 * ceil(src.s / 18696.774193548386393 + n);
    }

    // sphere_tp_erect(2975.6840327762110974)
    {
        float phi = src.s / 2975.6840327762110974;
        float theta = -src.t / 2975.6840327762110974 + 1.5707963267948965580;
        if (theta < 0.0) {
            theta = -theta;
            phi += 3.1415926535897931160;
        }
        if (theta > 3.1415926535897931160) {
            theta = 3.1415926535897931160 - (theta - 3.1415926535897931160);
            phi += 3.1415926535897931160;
        }
        float s = sin(theta);
        vec2 v = vec2(s * sin(phi), cos(theta));
        float r = length(v);
        theta = 2975.6840327762110974 * atan2_safe(r, s * cos(phi));
        src = v * (theta / r);
    }

    // persp_sphere(2975.6840327762110974)
    {
        mat3 m = mat3(0.99971408939535111315, 0.023855460075879894588, -0.0016298739190327593985,
                      -0.023911074095988301552, 0.99738888563214511684, -0.068144488794355015382,
                      0.0000000000000000000, 0.068163977598405450786, 0.99767413124625226040);
        float r = length(src);
        float theta = r / 2975.6840327762110974;
        float s = 0.0;
        if (r != 0.0) s = sin(theta) / r;
        vec3 v = vec3(s * src.s, s * src.t, cos(theta));
        vec3 u = v * m;
        r = length(u.st);
        theta = 0.0;
        if (r != 0.0) theta = 2975.6840327762110974 * atan2_safe(r, u.p) / r;
        src = theta * u.st;
    }

    // rect_sphere_tp(2975.6840327762110974)
    {
        float r = length(src);
        float theta = r / 2975.6840327762110974;
        float rho = 0.0;
        if (theta >= 1.5707963267948965580) rho = 1.6e16;
        else if (theta == 0.0) rho = 1.0;
        else rho = tan(theta) / theta;
        src *= rho;
    }

    // resize(1.3699592566685530048, 1.3699592566685530048)
    src *= vec2(1.3699592566685530048, 1.3699592566685530048);

    // radial(1.0429548248967042134, -0.043442402841601203412, 0.00056606295488714102656, -7.8485009990147399728e-05, 1731.0000000000000000, 10.201688571490457491)
    {
        float r = length(src) / 1731.0000000000000000;
        float scale = 1000.0; 
        if (r < 10.201688571490457491) {
            scale = ((-7.8485009990147399728e-05 * r + 0.00056606295488714102656) * r + -0.043442402841601203412) * r + 1.0429548248967042134;
        }
        src *= scale;
    }

    // vert(-194.77123258848499177)
    src.t += -194.77123258848499177;

    // horiz(55.943272105493100810)
    src.s += 55.943272105493100810;

    src += vec2(2597.5000000000000000, 1730.5000000000000000);

    src = src * discardA + vec2(-1000.0, -1000.0) * discardB;
    gl_FragColor = vec4(src.s, 0.0, 0.0, src.t);
}
#version 110
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect CoordTexture;
uniform sampler2DRect SrcTexture;
uniform sampler2DRect AccumTexture;
uniform vec2 SrcUL;
uniform vec2 SrcLR;
uniform vec2 KernelUL;
uniform vec2 KernelWH;
float w(const in float i, const in float f) {
    float A = -0.75000000000000000000;
    float c = abs(i - 1.0);
    float m = (i > 1.0) ? -1.0 : 1.0;
    float p = c + m * f;
    if (i == 1.0 || i == 2.0) {
        return (( A + 2.0 )*p - ( A + 3.0 ))*p*p + 1.0;
    } else {
        return (( A * p - 5.0 * A ) * p + 8.0 * A ) * p - 4.0 * A;
    }
}
void main(void)
{
    vec2 src = texture2DRect(CoordTexture, gl_TexCoord[0].st).sq;
    vec4 accum = texture2DRect(AccumTexture, gl_TexCoord[0].st);

    src -= SrcUL;
    vec2 t = floor(src) + -0.50000000000000000000;
    vec2 f = fract(src);
    vec2 k = vec2(0.0, 0.0);

    for (float ky = 0.0; ky < 4.0000000000000000000; ky += 1.0) {
        k.t = ky + KernelUL.t;
        float wy = w(k.t, f.t);
        for (float kx = 0.0; kx < 4.0000000000000000000; kx += 1.0) {
            k.s = kx + KernelUL.s;
            float wx = w(k.s, f.s);
            vec2 ix = t + k;
            vec4 sp = texture2DRect(SrcTexture, ix);
            float weight = wx * wy * sp.a;
            accum += sp * weight;
        }
    }

    gl_FragColor = accum;
}

#version 120
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect NormTexture;
uniform sampler2DRect CoordTexture;
uniform sampler2DRect InvLutTexture;
uniform sampler2DRect DestLutTexture;
void main(void)
{
    // Normalization
    vec4 n = texture2DRect(NormTexture, gl_TexCoord[0].st);
    vec4 p = vec4(0.0, 0.0, 0.0, 0.0);
    if (n.a >= 0.2) p = n / n.a;

    // Photometric
    // invLutSize = 1024.0000000000000000
    // pixelMax = 65535.000000000000000
    // destLutSize = 1024.0000000000000000
    // destExposure = 6.7287591143856949902e-05
    // srcExposure = 6.2988153004380474133e-05
    // whiteBalanceRed = 1.0000000000000000000
    // whiteBalanceBlue = 1.0000000000000000000
    p.rgb = p.rgb * 1023.0000000000000000;
    vec2 invR = texture2DRect(InvLutTexture, vec2(p.r, 0.0)).sq;
    vec2 invG = texture2DRect(InvLutTexture, vec2(p.g, 0.0)).sq;
    vec2 invB = texture2DRect(InvLutTexture, vec2(p.b, 0.0)).sq;
    vec3 invX = vec3(invR.x, invG.x, invB.x);
    vec3 invY = vec3(invR.y, invG.y, invB.y);
    vec3 invA = fract(p.rgb);
    p.rgb = mix(invX, invY, invA);
    // VigCorrMode=VIGCORR_RADIAL
    float vig = 1.0;
    {
        vec2 vigCorrCenter = vec2(2597.5000000000000000, 1730.5000000000000000);
        float radiusScale=0.00032032259660654335701;
        float radialVigCorrCoeff0 = 1.0000000000000000000;
        float radialVigCorrCoeff1 = -0.40315108769259400123;
        float radialVigCorrCoeff2 = 0.46929248738107898209;
        float radialVigCorrCoeff3 = -0.33239440559684202414;
        vec2 src = texture2DRect(CoordTexture, gl_TexCoord[0].st).sq;
        vec2 d = src - vigCorrCenter;
        d *= radiusScale;
        vig = radialVigCorrCoeff0;
        float r2 = dot(d, d);
        float r = r2;
        vig += radialVigCorrCoeff1 * r;
        r *= r2;
        vig += radialVigCorrCoeff2 * r;
        r *= r2;
        vig += radialVigCorrCoeff3 * r;
    }
    vec3 exposure_whitebalance = vec3(1.0682578855610749269, 1.0682578855610749269, 1.0682578855610749269);
    p.rgb = (p.rgb * exposure_whitebalance) / vig;
    p.rgb = p.rgb * 1023.0000000000000000;
    vec2 destR = texture2DRect(DestLutTexture, vec2(p.r, 0.0)).sq;
    vec2 destG = texture2DRect(DestLutTexture, vec2(p.g, 0.0)).sq;
    vec2 destB = texture2DRect(DestLutTexture, vec2(p.b, 0.0)).sq;
    vec3 destX = vec3(destR.x, destG.x, destB.x);
    vec3 destY = vec3(destR.y, destG.y, destB.y);
    vec3 destA = fract(p.rgb);
    p.rgb = mix(destX, destY, destA);

    gl_FragColor = p;
}

gpu shader program compile time = 0.063
gpu shader texture/framebuffer setup time = 0.009
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] coord image render time = 0.005
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] source chunk=[(0, 0) to (5200, 3462) = (5200x3462)] src upload = 0.081
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] source chunk=[(0, 0) to (5200, 3462) = (5200x3462)] src alpha upload = 0.007
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] source chunk=[(0, 0) to (5200, 3462) = (5200x3462)] src+alpha render = 0.005
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] source chunk=[(0, 0) to (5200, 3462) = (5200x3462)] interpolation chunk=[(0, 0) to (4, 4) = (4x4)] setup = 0
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] source chunk=[(0, 0) to (5200, 3462) = (5200x3462)] interpolation chunk=[(0, 0) to (4, 4) = (4x4)] render = 0.005
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] normalization setup = 0
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] normalization render = 0.001
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] dest rgb disassembly setup = 0
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] dest rgb disassembly render = 0.003
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] rgb readback = 0.039
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] dest alpha disassembly setup = 0
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] dest alpha disassembly render = 0.001
gpu dest chunk=[(0, 0) to (1772, 2230) = (1772x2230)] alpha readback = 0.009
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] coord image render time = 0.001
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] source chunk=[(0, 0) to (5200, 3462) = (5200x3462)] interpolation chunk=[(0, 0) to (4, 4) = (4x4)] setup = 0
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] source chunk=[(0, 0) to (5200, 3462) = (5200x3462)] interpolation chunk=[(0, 0) to (4, 4) = (4x4)] render = 0.005
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] normalization setup = 0
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] normalization render = 0.001
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] dest rgb disassembly setup = 0
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] dest rgb disassembly render = 0.001
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] rgb readback = 0.025
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] dest alpha disassembly setup = 0.001
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] dest alpha disassembly render = 0.001
gpu dest chunk=[(1772, 0) to (3544, 2230) = (1772x2230)] alpha readback = 0.008
gpu destruct time = 0
gpu total time = 0.273
Erreur de segmentation

-- 
You received this bug notification because you are a member of Hugin
Developers, which is subscribed to Hugin.
https://bugs.launchpad.net/bugs/1362170

Title:
  nona GPU for remapping : seg fault

Status in Hugin - Panorama Tools GUI:
  New

Bug description:
  If i activate the  GPU for remapping, it's always crash :

  
  ===========================================================================
  ***************  Panorama makefile generated by Hugin       ***************
  ===========================================================================
  System information
  ===========================================================================
  Operating system: GNU/Linux
  Release: 3.14.14-gentoo
  Kernel version: #1 SMP Thu Aug 14 21:23:51 CEST 2014
  Machine: x86_64
  Disc usage
  Sys. de fichiers Taille Utilisé Dispo Uti% Monté sur
  /dev/sda2           23G     19G  3,1G  86% /
  devtmpfs           3,9G       0  3,9G   0% /dev
  tmpfs              3,9G    320K  3,9G   1% /dev/shm
  tmpfs              3,9G    1,1M  3,9G   1% /run
  tmpfs              3,9G       0  3,9G   0% /sys/fs/cgroup
  tmpfs              3,9G    2,1M  3,9G   1% /tmp
  /dev/sda3          212G    173G   28G  87% /home
  /dev/sdb2          816G    677G   98G  88% /Backup
  /dev/sdc2          241G    136G   93G  60% /home/roumano/Musique
  /dev/sdc3          1,3T    1,2T   17G  99% /home/roumano/Vidéos
  tmpfs              796M     52K  796M   1% /run/user/500
  Memory usage
               total       used       free     shared    buffers     cached
  Mem:          7956       5647       2308         28        117        820
  -/+ buffers/cache:       4710       3245
  Swap:         3906       1775       2130
  ===========================================================================
  Output options
  ===========================================================================
  Hugin Version: 2014.0.0.51ff237f209e
  Project file: /tmp/huginpto_L9TZUg
  Output prefix: test
  Projection: Cylindrical (1)
  Field of view: 124 x 57
  Canvas dimensions: 6491 x 3246
  Crop area: (235,872) - (6306,3122)
  Output exposure value: 13.82
  Output stacks minimum overlap: 0.700
  Output layers maximum Ev difference: 0.50
  Selected outputs
  Normal panorama
  * Blended panorama
  Using GPU for remapping
  ===========================================================================
  Input images
  ===========================================================================
  Number of images in project file: 3
  Number of active images: 3
  Image 0: /home/roumano/raw/pano/2014-08-06--17.48.49.CR2.tif
  Image 0: Size 5196x3462, Exposure: 13.95
  Image 1: /home/roumano/raw/pano/2014-08-06--17.48.51.CR2.tif
  Image 1: Size 5196x3462, Exposure: 13.80
  Image 2: /home/roumano/raw/pano/2014-08-06--17.48.53.CR2.tif
  Image 2: Size 5196x3462, Exposure: 13.72
  ===========================================================================
  Testing programs
  ===========================================================================
  Checking nona...[OK]
  Checking enblend...[OK]
  Checking enfuse...[OK]
  Checking hugin_hdrmerge...[OK]
  Checking exiftool...[OK]
  ===========================================================================
  Stitching panorama
  ===========================================================================
  nona -g  -z LZW -r ldr -m TIFF_m -o test -i 0 /tmp/huginpto_L9TZUg
  nona: using graphics card: ATI Technologies Inc. AMD Radeon HD 7900 Series  
  make: *** [test0000.tif] Erreur de segmentation
  make: *** Suppression du fichier « test0000.tif »

  
  My card it's a ATI 7950 ( lspci : AMD/ATI] Tahiti PRO [Radeon HD 7950/8950 OEM / R9 280] )
  Driver used : ati-drivers-14.6_beta1
  on another exemple, OpenCL on my computer is working great (much faster than via the pcu ) via darktable
  Debug information from darktable :  ( if it's can help ) 
  [opencl_init] device 0 `Tahiti' supports image sizes of 16384 x 16384
  [opencl_init] device 0 `Tahiti' allows GPU memory allocations of up to 1024MB
  [opencl_init] device 0: Tahiti 
       GLOBAL_MEM_SIZE:          2392MB
       MAX_WORK_GROUP_SIZE:      256
       MAX_WORK_ITEM_DIMENSIONS: 3
       MAX_WORK_ITEM_SIZES:      [ 256 256 256 ]
       DRIVER_VERSION:           1526.3 (VM)
       DEVICE_VERSION:           OpenCL 1.2 AMD-APP (1526.3)

  Don't known how to provide more information :
  - I have recompiled higin with debug information (no more information in the GUI)
  - don't known how to test nona from the commande line

To manage notifications about this bug go to:
https://bugs.launchpad.net/hugin/+bug/1362170/+subscriptions