인텔 계열에서 컴피즈 작동 안되는 문제

안녕하세요 리눅스 처음 쓰는 초짜입니다.
사용중인 버전은 민트 7이고…

구글링을 통해
mkdir -p ~/.config/compiz/ && echo SKIP_CHECKS=yes >> ~/.config/compiz/compiz-manager
이렇게 하면 인텔에서도 컴피즈가 작동한다고 하길래 해봤더니 되더군요.
근데 한번 컴피즈를 껐다가 켜니 갑자기 작동이 안되더라구요. -_-;
저 명령어 다시 넣어봐도 안되고… 리붓 로그오프 해봐도 안됩니다.

왜 되던게 갑자기 안되죠? 해결방법이 없을까요?
한번 Mintupdate이 깔라는거 다 깔았는데 그 뒤 생긴 문제인 거 같기도 하고…

*내용 추가
sudo gedit /usr/bin/compiz 명령어 사용해서 intel 카드 블랙리스트 주석처리 해도 안되네요… _-;

**내용 추가
혹시 몰라 컴피즈 설정 파일 내용을 올려봅니다.

[quote:4zw8zc81]#!/bin/sh

COMPIZ_BIN_PATH="/usr/local/bin/" # For window decorators and compiz
PLUGIN_PATH="/usr/local/lib/compiz/"
GLXINFO="/usr/bin/glxinfo"
KWIN="/usr/bin/kwin"
METACITY="/usr/bin/metacity"
XFWM="/usr/bin/xfwm"
COMPIZ_NAME="compiz" # Final name for compiz (compiz.real)

For Xgl LD_PRELOAD

LIBGL_NVIDIA="/usr/lib/nvidia/libGL.so.1.2.xlibmesa"
LIBGL_FGLRX="/usr/lib/fglrx/libGL.so.1.2.xlibmesa"

Minimum amount of memory (in kilo bytes) that nVidia cards need

to be allowed to start

Set to 262144 to require 256MB

NVIDIA_MEMORY="65536" # 64MB
NVIDIA_SETTINGS="nvidia-settings" # Assume it’s in the path by default

For detecting what driver is in use, the + is for one or more /'s

XORG_DRIVER_PATH="/usr/lib/xorg/modules/drivers/+"
FALLBACKWM="xterm"
if [ x"$KDE_FULL_SESSION" = x"true" ]; then
FALLBACKWM="${KWIN}";
elif [ x"$GNOME_DESKTOP_SESSION_ID" != x"" ]; then
FALLBACKWM="${METACITY}"
elif xprop -root _DT_SAVE_MODE | grep ’ = "xfce4"$’ >/dev/null 2>&1; then
FALLBACKWM="${XFWM}"
fi

FALLBACKWM_OPTIONS="–replace $@"

Driver whitelist

WHITELIST="nvidia intel ati radeon i810 fglrx"

blacklist based on the pci ids

See http://wiki.compiz-fusion.org/Hardware/Blacklist for details

#T=" 1002:5954 1002:5854 1002:5955" # ati rs480
#T="$T 1002:4153" # ATI Rv350
#T="$T 8086:2982 8086:2992 8086:29a2 8086:2a02 8086:2a12" # intel 965
#T="$T 8086:2e02 " # Intel Eaglelake
#T="$T 8086:3577 8086:2562 " # Intel 830MG, 845G (LP: #259385)
BLACKLIST_PCIIDS="$T"
unset T

COMPIZ_OPTIONS="–ignore-desktop-hints --replace"
COMPIZ_PLUGINS="core"
ENV=""

Use emerald by default if it exist

USE_EMERALD="yes"

No indirect by default

INDIRECT="no"

Default X.org log if xset q doesn’t reveal it

XORG_DEFAULT_LOG="/var/log/Xorg.0.log"

Set to yes to enable verbose

VERBOSE="yes"

Echos the arguments if verbose

verbose()
{
if [ "x$VERBOSE" = "xyes" ]; then
printf "$*"
fi
}

abort script and run fallback windowmanager

abort_with_fallback_wm()
{
if [ "x$SKIP_CHECKS" = "xyes" ]; then
verbose "SKIP_CHECKS is yes, so continuing despite problems.\n"
return 0;
fi

if [ "x$CM_DRY" = "xyes" ]; then
	verbose "Dry run failed: Problems detected with 3D support.'n"
	exit 1;
fi

verbose "aborting and using fallback: $FALLBACKWM \n"

if [ -x $FALLBACKWM ]; then
	exec $FALLBACKWM $FALLBACKWM_OPTIONS
else
	printf "no $FALLBACKWM found, exiting\n"
	exit 1
fi

}

Check if we run with the Software Rasterizer, this happens e.g.

when a second screen session is opened via f-u-a on intel

check_software_rasterizer()
{
verbose "Checking for Software Rasterizer: "
if glxinfo 2> /dev/null | egrep -q ‘^OpenGL renderer string: Software Rasterizer’ ; then
verbose "present. \n";
return 0;
else
verbose "Not present. \n"
return 1;
fi

}

Check for non power of two texture support

check_npot_texture()
{
verbose "Checking for non power of two support: "
if glxinfo 2> /dev/null | egrep -q ‘(GL_ARB_texture_non_power_of_two|GL_NV_texture_rectangle|GL_EXT_texture_rectangle|GL_ARB_texture_rectangle)’ ; then
verbose "present. \n";
return 0;
else
verbose "Not present. \n"
return 1;
fi

}

Check for presence of FBConfig

check_fbconfig()
{
verbose "Checking for FBConfig: "
if [ "$INDIRECT" = "yes" ]; then
$GLXINFO -i | grep -q GLX.*fbconfig
FB=$?
else
$GLXINFO | grep -q GLX.*fbconfig
FB=$?
fi

if [ $FB = "0" ]; then
	unset FB
	verbose "present. \n"
	return 0;
else
	unset FB
	verbose "not present. \n"
	return 1;
fi

}

Check for TFP

check_tfp()
{
verbose "Checking for texture_from_pixmap: "
if [ $($GLXINFO 2>/dev/null | grep -c GLX_EXT_texture_from_pixmap) -gt 2 ] ; then
verbose "present. \n"
return 0;
else
verbose "not present. \n"
if [ "$INDIRECT" = "yes" ]; then
unset LIBGL_ALWAYS_INDIRECT
INDIRECT="no"
return 1;
else
verbose "Trying again with indirect rendering:\n";
INDIRECT="yes"
export LIBGL_ALWAYS_INDIRECT=1
check_tfp;
return $?
fi
fi
}

Check wether the composite extension is present

check_composite()
{
verbose "Checking for Composite extension: "
if xdpyinfo -queryExtensions | grep -q Composite ; then
verbose "present. \n";
return 0;
else
verbose "not present. \n";
return 1;
fi
}

Detects if Xgl is running

check_xgl()
{
verbose "Checking for Xgl: "
if xvinfo | grep -q Xgl ; then
verbose "present. \n"
return 0;
else
verbose "not present. \n"
return 1;
fi
}

Check if the nVidia card has enough video ram to make sense

check_nvidia_memory()
{
if [ ! -x "$NVIDIA_SETTINGS" ]; then
return 0
fi

MEM=$(${NVIDIA_SETTINGS} -q VideoRam | egrep Attribute\ \'VideoRam\'\ .*: | cut -d: -f3 | sed 's/[^0-9]//g')
if [ $MEM -lt $NVIDIA_MEMORY ]; then
	verbose "Less than ${NVIDIA_MEMORY}kb of memory and nVidia";
	return 1;
fi
return 0;

}

Check for existence if NV-GLX

check_nvidia()
{
if [ ! -z $NVIDIA_INTERNAL_TEST ]; then
return $NVIDIA_INTERNAL_TEST;
fi
verbose "Checking for nVidia: "
if xdpyinfo | grep -q NV-GLX ; then
verbose "present. \n"
NVIDIA_INTERNAL_TEST=0
return 0;
else
verbose "not present. \n"
NVIDIA_INTERNAL_TEST=1
return 1;
fi
}

Check if the max texture size is large enough compared to the resolution

check_texture_size()
{
# Check how many screens we’ve got and iterate over them
N=$(xdpyinfo | grep -i "number of screens" | sed 's/.[^0-9]//g’)
for i in $(seq 1 $N); do
verbose "Checking screen $i"
TEXTURE_LIMIT=$(glxinfo -l | grep GL_MAX_TEXTURE_SIZE | sed -n "$i s/^.
=[^0-9]//g p")
RESOLUTION=$(xdpyinfo | grep -i dimensions: | sed -n -e "$i s/^ *dimensions: ([0-9]x[0-9]) pixels./\1/ p")
VRES=$(echo $RESOLUTION | sed ‘s/.x//')
HRES=$(echo $RESOLUTION | sed 's/x.
//’)
verbose "Comparing resolution ($RESOLUTION) to maximum 3D texture size ($TEXTURE_LIMIT): ";
if [ $VRES -gt $TEXTURE_LIMIT ] || [ $HRES -gt $TEXTURE_LIMIT ]; then
verbose "Failed.\n"
return 1;
fi
verbose "Passed.\n"
done
return 0
}

check driver whitelist

running_under_whitelisted_driver()
{
LOG=$(xset q|grep "Log file"|awk ‘{print $3}’)
if [ "$LOG" = "" ]; then
verbose "xset q doesn’t reveal the location of the log file. Using fallback $XORG_DEFAULT_LOG \n"
LOG=$XORG_DEFAULT_LOG;
fi
if [ -z "$LOG" ];then
verbose "AIEEEEH, no Log file found \n"
verbose "$(xset q) \n"
return 0
fi
for DRV in ${WHITELIST}; do
if egrep -q "Loading ${XORG_DRIVER_PATH}${DRV}_drv.so" $LOG &&
! egrep -q "Unloading ${XORG_DRIVER_PATH}${DRV}_drv.so" $LOG;
then
return 0
fi
done
verbose "No whitelisted driver found\n"
return 1
}

check pciid blacklist

have_blacklisted_pciid()
{
OUTPUT=$(lspci -n)
for ID in ${BLACKLIST_PCIIDS}; do
if echo "$OUTPUT" | egrep -q "$ID"; then
verbose "Blacklisted PCIID ‘$ID’ found \n"
return 0
fi
done
OUTPUT=$(lspci -vn | grep -i VGA)
verbose "Detected PCI ID for VGA: $OUTPUT\n"
return 1
}

build_env()
{
if check_nvidia; then
ENV="__GL_YIELD=NOTHING "
fi
if [ "$INDIRECT" = "yes" ]; then
ENV="$ENV LIBGL_ALWAYS_INDIRECT=1 "
fi
if check_xgl; then
if [ -f ${LIBGL_NVIDIA} ]; then
ENV="$ENV LD_PRELOAD=${LIBGL_NVIDIA}"
verbose "Enabling Xgl with nVidia drivers…\n"
fi
if [ -f ${LIBGL_FGLRX} ]; then
ENV="$ENV LD_PRELOAD=${LIBGL_FGLRX}"
verbose "Enabling Xgl with fglrx ATi drivers…\n"
fi
fi

ENV="$ENV FROM_WRAPPER=yes"

if [ -n "$ENV" ]; then
	export $ENV
fi

}

build_args()
{
if [ "x$INDIRECT" = "xyes" ]; then
COMPIZ_OPTIONS="$COMPIZ_OPTIONS --indirect-rendering "
fi
if [ ! -z "$DESKTOP_AUTOSTART_ID" ]; then
COMPIZ_OPTIONS="$COMPIZ_OPTIONS --sm-client-id $DESKTOP_AUTOSTART_ID"
fi
if check_nvidia; then
if [ "x$INDIRECT" != "xyes" ]; then
COMPIZ_OPTIONS="$COMPIZ_OPTIONS --loose-binding"
fi
fi
}

####################

Execution begins here.

Read configuration from XDG paths

if [ -z "$XDG_CONFIG_DIRS" ]; then
test -f /etc/xdg/compiz/compiz-manager && . /etc/xdg/compiz/compiz-manager
for f in /etc/xdg/compiz/compiz-manager.d/; do
test -e $f && . $f
done
else
OLD_IFS=$IFS
IFS=:
for CONFIG_DIR in $XDG_CONFIG_DIRS
do
test -f $CONFIG_DIR/compiz/compiz-manager && . $CONFIG_DIR/compiz/compiz-manager
for f in $CONFIG_DIRS/compiz/compiz-manager.d/
; do
test -e $f && . $f
done
done
IFS=$OLD_IFS
unset OLD_IFS
fi

if [ -z "$XDG_CONFIG_HOME" ]; then
test -f $HOME/.config/compiz/compiz-manager && . $HOME/.config/compiz/compiz-manager
else
test -f $XDG_CONFIG_HOME/compiz/compiz-manager && . $XDG_CONFIG_HOME/compiz/compiz-manager
fi

Don’t use compiz when running the failsafe session

if [ "x$GNOME_DESKTOP_SESSION_ID" = "xFailsafe" ]; then
abort_with_fallback_wm
fi

if [ "x$LIBGL_ALWAYS_INDIRECT" = "x1" ]; then
INDIRECT="yes";
fi

if we run under Xgl, we can skip some tests here

if ! check_xgl; then
# if vesa or vga are in use, do not even try glxinfo (LP#119341)
if ! running_under_whitelisted_driver || have_blacklisted_pciid; then
abort_with_fallback_wm
fi
# check if we have the required bits to run compiz and if not,
# fallback
if ! check_tfp || ! check_npot_texture || ! check_composite || ! check_texture_size; then
abort_with_fallback_wm
fi

# check if we run with software rasterizer and if so, bail out
if check_software_rasterizer; then
	verbose "Software rasterizer detected, aborting"
	abort_with_fallback_wm
fi

if check_nvidia && ! check_nvidia_memory; then
	abort_with_fallback_wm
fi

if ! check_fbconfig; then
	abort_with_fallback_wm
fi

fi

load the ccp plugin if present and fallback to plain gconf if not

if [ -f ${PLUGIN_PATH}libccp.so ]; then
COMPIZ_PLUGINS="$COMPIZ_PLUGINS ccp"
elif [ -f ${PLUGIN_PATH}libgconf.so ]; then
COMPIZ_PLUGINS="$COMPIZ_PLUGINS glib gconf"
fi

enable gnomecompat if we run under gnome

if [ x"$GNOME_DESKTOP_SESSION_ID" != x"" ] && [ ! -e ~/.compiz-gnomecompat ]; then
verbose "running under gnome seesion, checking for gnomecompat\n"
if ! gconftool -g /apps/compiz/general/allscreens/options/active_plugins|grep -q gnomecompat; then
verbose "adding missing gnomecompat\n"
V=$(gconftool -g /apps/compiz/general/allscreens/options/active_plugins|sed s/mousepoll,/mousepoll,gnomecompat,/)
if ! echo $V|grep -q gnomecompat; then
verbose "can not add gnomecompat, reseting\n"
gconftool --unset /apps/compiz/general/allscreens/options/active_plugins
else
gconftool -s /apps/compiz/general/allscreens/options/active_plugins --type list --list-type=string $V
fi
touch ~/.compiz-gnomecompat
fi
fi

get environment

build_env
build_args

if [ "x$CM_DRY" = "xyes" ]; then
verbose "Dry run finished: everything should work with regards to Compiz and 3D.\n"
verbose "Execute: ${COMPIZ_BIN_PATH}${COMPIZ_NAME} $COMPIZ_OPTIONS "$@" $COMPIZ_PLUGINS \n"
exit 0;
fi

${COMPIZ_BIN_PATH}${COMPIZ_NAME} $COMPIZ_OPTIONS "$@" $COMPIZ_PLUGINS || exec $FALLBACKWM $FALLBACKWM_OPTIONS[/quote:4zw8zc81]

ubuntu 포럼오셔서… 민트를… 무섭군요…
우분투에는 9.04에서 intel gpu는 compiz가 잘안되는게 유명한 문제입니다.

원래 인텔칩은 우분투 라이브 상태서도 컴피즈가 되는게 거의 인데…
요즘 커널 업 후 인탤이 3D 안되네 되네 말이 많습니다.

컴피즈를 사용하려면 3D 렌더링 가속이 되는 상태여야 하는데
그놈 터미널서
lspci | grep -i -e Display -e VGA 해서 그래픽 카드칩 확인 하시고
glxinfo | grep "direct rendering" 하여 direct rendering: Yes 가 나오는 지 확인 바랍니다.

터미널서 compiz --replace 하면 어떤 메세지 나오는 지요 ?

[quote:3bka1d17]원래 인텔칩은 우분투 라이브 상태서도 컴피즈가 되는게 거의 인데…
요즘 커널 업 후 인탤이 3D 안되네 되네 말이 많습니다.

컴피즈를 사용하려면 3D 렌더링 가속이 되는 상태여야 하는데
그놈 터미널서
lspci | grep -i -e Display -e VGA 해서 그래픽 카드칩 확인 하시고
glxinfo | grep "direct rendering" 하여 direct rendering: Yes 가 나오는 지 확인 바랍니다.

터미널서 compiz --replace 하면 어떤 메세지 나오는 지요 ?[/quote:3bka1d17]
dexter@dexter-laptop ~ $ lspci | grep -i -e Display -e VGA
00:02.0 VGA compatible controller: Intel Corporation Mobile GM965/GL960 Integrated Graphics Controller (rev 0c)
00:02.1 Display controller: Intel Corporation Mobile GM965/GL960 Integrated Graphics Controller (rev 0c)
dexter@dexter-laptop ~ $ glxinfo | grep "direct rendering"
direct rendering: Yes
dexter@dexter-laptop ~ $ compiz --replace

저 명령어를 치니 시스템이 급속도로 느려져서 결국 리붓해야만 했습니다.;