tree 164fcbefa121ee2060e0c66520046a57173df3d7
parent e6e549b9e40d42dbb6a551ecaeb040c1e401f21a
author Vicente Olivert Riera <Vincent.Riera@imgtec.com> 1464278060 +0100
committer Thomas Petazzoni <thomas.petazzoni@free-electrons.com> 1464290332 +0200

ffmpeg: disable for mips64r2 and mips64r6

MIPS architecture detection is not accurate and is always detected as
mips64 even if we are using mips64r2 or mips64r6. Due to that, ffmpeg's
build system will pass the -mips64 flag which will conflict with the
-march option that our toolchain wrapper uses, and it will fail to build
showing errors like this one:

error: '-mips64' conflicts with the other architecture options, which
specify a mips64r2 processor

This problem has been already fixed upstream, but we would need to
backport 17 patches plus some changes in the ffmpeg.mk file. This is too
much, so better to just disable ffmpeg for mips64r2 and mips64r6 for the
upcoming Buildroot release.

This commit can be reverted in the next ffmpeg's version bump.

Fixes:

  http://autobuild.buildroot.net/results/7fd/7fd8187c0110cdcac622e667f4a81d2db84f11ef/

Signed-off-by: Vicente Olivert Riera <Vincent.Riera@imgtec.com>
Reviewed-by: Bernd Kuhls <bernd.kuhls@t-online.de>
Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
