Hugin

nona GPU for remapping : seg fault

Bug #1362170 reported by Roumano on 2014-08-27

This bug affects 1 person

Affects		Status	Importance	Assigned to	Milestone
	Hugin	Fix Released	Undecided	Unassigned	Hugin 2016.0beta1

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

Tags:

Revision history for this message

tmodes (tmodes) wrote on 2014-08-30:

Save your project and run the same command as in the log:
nona -g -z LZW -r ldr -m TIFF_m -o test -i 0 /tmp/huginpto_L9TZUg
Replace the temporary filename with the path and name of your saved project file:
nona -g -z LZW -r ldr -m TIFF_m -o test -i 0 project.pto

Add additional the switch -d:
nona -g -z LZW -r ldr -m TIFF_m -o test -i 0 -d /tmp/huginpto_L9TZUg
This will print more details.

PS: OpenCL has nothing to do with OpenGL. So this information is not helpful.

Revision history for this message

Roumano (roumano-k) wrote on 2014-08-31:

Download full text (11.3 KiB)

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);
    }

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

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

// 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

Revision history for this message

tmodes (tmodes) wrote on 2014-08-31:

I can't see anything strange in the output. It seems the image is remapped on the GPU, but crashing when saving the image to disc.

Could you post your pto file (with images)? So I could try if I can reproduce the crash.

Revision history for this message

Roumano (roumano-k) wrote on 2014-09-01:

Hi,

I put them here :
http://roumano.com/temp/nona.zip
i hope it's will help but not sure at all ...

Regards

Revision history for this message

tmodes (tmodes) wrote on 2014-09-04:

Thanks for test files.
I can reproduce the issue. It happens only on Linux, not on Windows.
I will have a look on it, but I can't promise anything.

Changed in hugin:
status:	New → Confirmed

Revision history for this message

tmodes (tmodes) wrote on 2014-09-04:

One step further. The crash seems to be related to a bug in freeglut3, the library nona is using for GPU support: see http://sourceforge.net/p/freeglut/bugs/206/

There is no release with the bug.
I have yet not found a workaround.

Revision history for this message

Roumano (roumano-k) wrote on 2014-09-04:

A patch it's available on the bug http://sourceforge.net/p/freeglut/bugs/206/ :

+
+ /* This forces AMD Catalyst drivers to initialize and register a shutdown
+ * function, which must be done before our own call to atexit to prevent
+ * a crash if glutMainLoop is not called or is not exited cleanly.
+ * (http://sourceforge.net/p/freeglut/bugs/206/)
+ */
+ glXQueryExtensionsString( fgDisplay.pDisplay.Display,
+ DefaultScreen( fgDisplay.pDisplay.Display ));

It"s "only" 2line of modificationn, it's impossible to use this patch ?

Revision history for this message

tmodes (tmodes) wrote on 2014-09-04:

The patch applies to the freeglut source (it is accessing some internal variables which are not accessible from outside.). So would apply the patch to the freeglut sources and recompile freeglut and install the new compiled freeglut.

PS: There is a second bug report with a similar problem. But noone from the freeglut team responded to it: http://sourceforge.net/p/freeglut/bugs/201/

Revision history for this message

tmodes (tmodes) wrote on 2014-09-05:

I was able to port the patch to Hugin source code base. Unfortunately it does not help. I still get the seg fault. So I assume there is another glitch in freeglut (see bug 201).

Revision history for this message

tmodes (tmodes) wrote on 2015-06-22:

#10

Hugin does not use freeglut any more (only default branch). This hopefully fixes also this segfault.

Changed in hugin:
status:	Confirmed → Fix Committed

tmodes (tmodes) on 2016-01-23

Changed in hugin:
milestone:	none → 2016.0beta1
status:	Fix Committed → Fix Released

Report a bug

This report contains Public information

Everyone can see this information.

You are

Subscribing...

Edit bug mail

Other bug subscribers

Remote bug watches

Bug watches keep track of this bug in other bug trackers.