Attachment #6491 for bug #31772

View | Details | Raw Unified | Return to bug 31772
Collapse All | Expand All

Lines 33-39 Link Here

(-)beta.wily/content/common/gpu/media/gpu_video_decode_accelerator.cc (-3 / +7 lines)
33	#include "content/common/gpu/media/dxva_video_decode_accelerator.h"	33	#include "content/common/gpu/media/dxva_video_decode_accelerator.h"
34	#elif defined(OS_MACOSX)	34	#elif defined(OS_MACOSX)
35	#include "content/common/gpu/media/vt_video_decode_accelerator.h"	35	#include "content/common/gpu/media/vt_video_decode_accelerator.h"
36	#elif defined(OS_CHROMEOS)	36	#elif defined(OS_CHROMEOS) \|\| defined(OS_LINUX)
37	#if defined(USE_V4L2_CODEC)	37	#if defined(USE_V4L2_CODEC)
38	#include "content/common/gpu/media/v4l2_device.h"	38	#include "content/common/gpu/media/v4l2_device.h"
39	#include "content/common/gpu/media/v4l2_slice_video_decode_accelerator.h"	39	#include "content/common/gpu/media/v4l2_slice_video_decode_accelerator.h"
Lines 164-170 GpuVideoDecodeAccelerator::GetSupportedP Link Here
164	// can be initialized by corresponding VDA successfully.	164	// can be initialized by corresponding VDA successfully.
165	#if defined(OS_WIN)	165	#if defined(OS_WIN)
166	profiles = DXVAVideoDecodeAccelerator::GetSupportedProfiles();	166	profiles = DXVAVideoDecodeAccelerator::GetSupportedProfiles();
167	#elif defined(OS_CHROMEOS)	167	#elif defined(OS_CHROMEOS) \|\| defined(OS_LINUX)
168	media::VideoDecodeAccelerator::SupportedProfiles vda_profiles;	168	media::VideoDecodeAccelerator::SupportedProfiles vda_profiles;
169	#if defined(USE_V4L2_CODEC)	169	#if defined(USE_V4L2_CODEC)
170	vda_profiles = V4L2VideoDecodeAccelerator::GetSupportedProfiles();	170	vda_profiles = V4L2VideoDecodeAccelerator::GetSupportedProfiles();
Lines 346-351 void GpuVideoDecodeAccelerator::Initiali Link Here
346	}	346	}
347	#endif	347	#endif
348		348
		349	VLOG(1) << "Initializing GPU video decode accelerator.";
		350
349	// Array of Create..VDA() function pointers, maybe applicable to the current	351	// Array of Create..VDA() function pointers, maybe applicable to the current
350	// platform. This list is ordered by priority of use and it should be the	352	// platform. This list is ordered by priority of use and it should be the
351	// same as the order of querying supported profiles of VDAs.	353	// same as the order of querying supported profiles of VDAs.
Lines 444-450 void GpuVideoDecodeAccelerator::BindImag Link Here
444	scoped_ptr<media::VideoDecodeAccelerator>	446	scoped_ptr<media::VideoDecodeAccelerator>
445	GpuVideoDecodeAccelerator::CreateVaapiVDA() {	447	GpuVideoDecodeAccelerator::CreateVaapiVDA() {
446	scoped_ptr<media::VideoDecodeAccelerator> decoder;	448	scoped_ptr<media::VideoDecodeAccelerator> decoder;
447	#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)	449	VLOG(1) << "About to create new VAAPI video decode accelerator.";
		450	#if (defined(OS_CHROMEOS) \|\| defined(OS_LINUX)) && defined(ARCH_CPU_X86_FAMILY)
		451	VLOG(1) << "Creating new VAAPI video decode accelerator.";
448	decoder.reset(new VaapiVideoDecodeAccelerator(	452	decoder.reset(new VaapiVideoDecodeAccelerator(
449	make_context_current_, base::Bind(&GpuVideoDecodeAccelerator::BindImage,	453	make_context_current_, base::Bind(&GpuVideoDecodeAccelerator::BindImage,
450	base::Unretained(this))));	454	base::Unretained(this))));

Lines 878-884 Link Here

(-)beta.wily/content/content_common.gypi (-2 / +2 lines)
878	},	878	},
879	],	879	],
880	}],	880	}],
881	['chromeos==1', {	881	['chromeos==1 or desktop_linux==1', {
882	'sources': [	882	'sources': [
883	'common/gpu/media/accelerated_video_decoder.h',	883	'common/gpu/media/accelerated_video_decoder.h',
884	'common/gpu/media/gpu_arc_video_service.cc',	884	'common/gpu/media/gpu_arc_video_service.cc',
Lines 936-942 Link Here
936	'common/gpu/media/tegra_v4l2_device.h',	936	'common/gpu/media/tegra_v4l2_device.h',
937	],	937	],
938	}],	938	}],
939	['target_arch != "arm" and chromeos == 1', {	939	['target_arch != "arm" and (chromeos == 1 or desktop_linux == 1)', {
940	'dependencies': [	940	'dependencies': [
941	'../media/media.gyp:media',	941	'../media/media.gyp:media',
942	'../third_party/libyuv/libyuv.gyp:libyuv',	942	'../third_party/libyuv/libyuv.gyp:libyuv',

Lines 38-44 Link Here

(-)beta.wily/content/content_gpu.gypi (-1 / +1 lines)
38	],	38	],
39	},	39	},
40	}],	40	}],
41	['target_arch!="arm" and chromeos == 1', {	41	['target_arch!="arm" and (chromeos == 1 or desktop_linux == 1)', {
42	'include_dirs': [	42	'include_dirs': [
43	'<(DEPTH)/third_party/libva',	43	'<(DEPTH)/third_party/libva',
44	],	44	],

Lines 1757-1763 Link Here

(-)beta.wily/content/content_tests.gypi (-1 / +1 lines)
1757	},	1757	},
1758	]	1758	]
1759	}],	1759	}],
1760	['chromeos==1 and target_arch != "arm"', {	1760	['(chromeos==1 or desktop_linux==1) and target_arch != "arm"', {
1761	'targets': [	1761	'targets': [
1762	{	1762	{
1763	'target_name': 'vaapi_jpeg_decoder_unittest',	1763	'target_name': 'vaapi_jpeg_decoder_unittest',

Lines 944-950 const char kDisableWebAudio[] Link Here

(-)beta.wily/content/public/common/content_switches.cc (+2 lines)
944	#if defined(OS_CHROMEOS)	944	#if defined(OS_CHROMEOS)
945	// Disables panel fitting (used for mirror mode).	945	// Disables panel fitting (used for mirror mode).
946	const char kDisablePanelFitting[] = "disable-panel-fitting";	946	const char kDisablePanelFitting[] = "disable-panel-fitting";
		947	#endif
947		948
		949	#if defined(OS_CHROMEOS) \|\| defined(OS_LINUX)
948	// Disables VA-API accelerated video encode.	950	// Disables VA-API accelerated video encode.
949	const char kDisableVaapiAcceleratedVideoEncode[] =	951	const char kDisableVaapiAcceleratedVideoEncode[] =
950	"disable-vaapi-accelerated-video-encode";	952	"disable-vaapi-accelerated-video-encode";

Lines 277-282 CONTENT_EXPORT extern const char kDisabl Link Here

(-)beta.wily/content/public/common/content_switches.h (+2 lines)
277		277
278	#if defined(OS_CHROMEOS)	278	#if defined(OS_CHROMEOS)
279	CONTENT_EXPORT extern const char kDisablePanelFitting[];	279	CONTENT_EXPORT extern const char kDisablePanelFitting[];
		280	#endif
		281	#if defined(OS_CHROMEOS) \|\| defined(OS_LINUX)
280	CONTENT_EXPORT extern const char kDisableVaapiAcceleratedVideoEncode[];	282	CONTENT_EXPORT extern const char kDisableVaapiAcceleratedVideoEncode[];
281	#endif	283	#endif
282		284

Lines 783-789 Link Here

(-)beta.wily/media/media.gyp (-2 / +2 lines)
783	],	783	],
784	}],	784	}],
785	# For VaapiVideoEncodeAccelerator.	785	# For VaapiVideoEncodeAccelerator.
786	['target_arch != "arm" and chromeos == 1', {	786	['target_arch != "arm" and (chromeos == 1 or desktop_linux == 1)', {
787	'sources': [	787	'sources': [
788	'filters/h264_bitstream_buffer.cc',	788	'filters/h264_bitstream_buffer.cc',
789	'filters/h264_bitstream_buffer.h',	789	'filters/h264_bitstream_buffer.h',
Lines 1417-1423 Link Here
1417	'cdm/cdm_adapter_unittest.cc',	1417	'cdm/cdm_adapter_unittest.cc',
1418	],	1418	],
1419	}],	1419	}],
1420	['target_arch != "arm" and chromeos == 1 and use_x11 == 1', {	1420	['target_arch != "arm" and (chromeos == 1 or desktop_linux == 1) and use_x11 == 1', {
1421	'sources': [	1421	'sources': [
1422	'filters/h264_bitstream_buffer_unittest.cc',	1422	'filters/h264_bitstream_buffer_unittest.cc',
1423	],	1423	],




      ]
    },
    {
      "id": 48,
      "description": "Accelerated video decode is unavailable on Linux",
      "cr_bugs": [137247],
      "os": {
        "type": "linux"
      },
      "features": [
        "accelerated_video_decode"
      ]
    },
    {
      "id": 49,
      "description": "NVidia GeForce GT 650M can cause the system to hang with flash 3D",
      "cr_bugs": [140175],

Lines 22-27 Link Here

(-)beta.wily/content/common/sandbox_linux/bpf_gpu_policy_linux.cc (-19 / +42 lines)
22	#include "base/macros.h"	22	#include "base/macros.h"
23	#include "base/memory/scoped_ptr.h"	23	#include "base/memory/scoped_ptr.h"
24	#include "build/build_config.h"	24	#include "build/build_config.h"
		25	// Auto-generated for dlopen libva libraries
		26	#include "content/common/gpu/media/va_stubs.h"
25	#include "content/common/sandbox_linux/sandbox_bpf_base_policy_linux.h"	27	#include "content/common/sandbox_linux/sandbox_bpf_base_policy_linux.h"
26	#include "content/common/sandbox_linux/sandbox_seccomp_bpf_linux.h"	28	#include "content/common/sandbox_linux/sandbox_seccomp_bpf_linux.h"
27	#include "content/common/set_process_title.h"	29	#include "content/common/set_process_title.h"
Lines 32-37 Link Here
32	#include "sandbox/linux/syscall_broker/broker_file_permission.h"	34	#include "sandbox/linux/syscall_broker/broker_file_permission.h"
33	#include "sandbox/linux/syscall_broker/broker_process.h"	35	#include "sandbox/linux/syscall_broker/broker_process.h"
34	#include "sandbox/linux/system_headers/linux_syscalls.h"	36	#include "sandbox/linux/system_headers/linux_syscalls.h"
		37	#include "third_party/libva/va/va.h"
		38	#include "third_party/libva/va/va_x11.h"
35		39
36	using sandbox::arch_seccomp_data;	40	using sandbox::arch_seccomp_data;
37	using sandbox::bpf_dsl::Allow;	41	using sandbox::bpf_dsl::Allow;
Lines 41-46 using sandbox::syscall_broker::BrokerFil Link Here
41	using sandbox::syscall_broker::BrokerProcess;	45	using sandbox::syscall_broker::BrokerProcess;
42	using sandbox::SyscallSets;	46	using sandbox::SyscallSets;
43		47
		48	using content_common_gpu_media::kModuleVa;
		49	using content_common_gpu_media::kModuleVa_x11;
		50	using content_common_gpu_media::InitializeStubs;
		51	using content_common_gpu_media::StubPathMap;
		52
44	namespace content {	53	namespace content {
45		54
46	namespace {	55	namespace {
Lines 95-101 inline bool UseLibV4L2() { Link Here
95		104
96	bool IsAcceleratedVaapiVideoEncodeEnabled() {	105	bool IsAcceleratedVaapiVideoEncodeEnabled() {
97	bool accelerated_encode_enabled = false;	106	bool accelerated_encode_enabled = false;
98	#if defined(OS_CHROMEOS)	107	#if defined(OS_CHROMEOS) \|\| defined(OS_LINUX)
99	const base::CommandLine& command_line =	108	const base::CommandLine& command_line =
100	*base::CommandLine::ForCurrentProcess();	109	*base::CommandLine::ForCurrentProcess();
101	accelerated_encode_enabled =	110	accelerated_encode_enabled =
Lines 300-326 bool GpuProcessPolicy::PreSandboxHook() Link Here
300	// inside the sandbox, so preload them now.	309	// inside the sandbox, so preload them now.
301	if (IsAcceleratedVaapiVideoEncodeEnabled() \|\|	310	if (IsAcceleratedVaapiVideoEncodeEnabled() \|\|
302	IsAcceleratedVideoDecodeEnabled()) {	311	IsAcceleratedVideoDecodeEnabled()) {
303	const char* I965DrvVideoPath = NULL;	312	VLOG(1) << "Attempting to enable hardware video acceleration.";
304	const char* I965HybridDrvVideoPath = NULL;	313	StubPathMap paths;
		314	paths[kModuleVa].push_back("libva.so.1");
		315	paths[kModuleVa_x11].push_back("libva-x11.so.1");
		316	if (!InitializeStubs(paths)) {
		317	VLOG(1) << "Failed to initialize stubs";
		318	return false;
		319	}
305		320
306	if (IsArchitectureX86_64()) {	321	// libva drivers won't get loaded even above two libraries get dlopened.
307	I965DrvVideoPath = "/usr/lib64/va/drivers/i965_drv_video.so";	322	// Thus, libva calls will fail after post sandbox stage.
308	I965HybridDrvVideoPath = "/usr/lib64/va/drivers/hybrid_drv_video.so";	323	//
309	} else if (IsArchitectureI386()) {	324	// To get the va driver loaded before sandboxing, upstream simply dlopen
310	I965DrvVideoPath = "/usr/lib/va/drivers/i965_drv_video.so";	325	// the hard-coded va driver path because ChromeOS is the only platform
		326	// that Google want to support libva.
		327	//
		328	// While generic linux distros ship va driver as anywhere they want.
		329	// Fortunately, the va driver will be loadded when vaInitialize() get
		330	// called.
		331	// So the following code is to call vaInitialize() before sandboxing.
		332	Display* x_display = XOpenDisplay(NULL);
		333	VADisplay va_display = vaGetDisplay(x_display);
		334	if (!vaDisplayIsValid(va_display)) {
		335	VLOG(1) << "Failed to call vaGetDisplay()";
		336	return false;
311	}	337	}
312		338
313	dlopen(I965DrvVideoPath, RTLD_NOW\|RTLD_GLOBAL\|RTLD_NODELETE);	339	int major_version, minor_version;
314	if (I965HybridDrvVideoPath)	340	if (vaInitialize(va_display, &major_version, &minor_version)
315	dlopen(I965HybridDrvVideoPath, RTLD_NOW\|RTLD_GLOBAL\|RTLD_NODELETE);	341	!= VA_STATUS_SUCCESS) {
316	dlopen("libva.so.1", RTLD_NOW\|RTLD_GLOBAL\|RTLD_NODELETE);	342	VLOG(1) << "Failed to call vaInitialize()";
317	#if defined(USE_OZONE)	343	return false;
318	dlopen("libva-drm.so.1", RTLD_NOW\|RTLD_GLOBAL\|RTLD_NODELETE);	344	}
319	#elif defined(USE_X11)	345	} // end of IsAcceleratedVaapiVideoEncodeEnabled() \|\| IsAcceleratedVideoDecodeEnabled()
320	dlopen("libva-x11.so.1", RTLD_NOW\|RTLD_GLOBAL\|RTLD_NODELETE);	346	} // end of IsArchitectureX86_64() \|\| IsArchitectureI386()
321	#endif
322	}
323	}
324		347
325	return true;	348	return true;
326	}	349	}

Lines 1017-1023 const FeatureEntry kFeatureEntries[] = { Link Here

(-)beta.wily/chrome/browser/about_flags.cc (-1 / +1 lines)
1017	"disable-accelerated-video-decode",	1017	"disable-accelerated-video-decode",
1018	IDS_FLAGS_DISABLE_ACCELERATED_VIDEO_DECODE_NAME,	1018	IDS_FLAGS_DISABLE_ACCELERATED_VIDEO_DECODE_NAME,
1019	IDS_FLAGS_DISABLE_ACCELERATED_VIDEO_DECODE_DESCRIPTION,	1019	IDS_FLAGS_DISABLE_ACCELERATED_VIDEO_DECODE_DESCRIPTION,
1020	kOsMac \| kOsWin \| kOsCrOS,	1020	kOsAll,
1021	SINGLE_VALUE_TYPE(switches::kDisableAcceleratedVideoDecode),	1021	SINGLE_VALUE_TYPE(switches::kDisableAcceleratedVideoDecode),
1022	},	1022	},
1023	#if defined(USE_ASH)	1023	#if defined(USE_ASH)

Lines 186-192 scoped_refptr<VaapiWrapper> VaapiWrapper Link Here

(-)beta.wily/content/common/gpu/media/vaapi_wrapper.cc (-9 / +11 lines)
186	VAProfile va_profile,	186	VAProfile va_profile,
187	const base::Closure& report_error_to_uma_cb) {	187	const base::Closure& report_error_to_uma_cb) {
188	if (!profile_infos_.Get().IsProfileSupported(mode, va_profile)) {	188	if (!profile_infos_.Get().IsProfileSupported(mode, va_profile)) {
189	DVLOG(1) << "Unsupported va_profile: " << va_profile;	189	VLOG(1) << "Unsupported va_profile: " << va_profile;
190	return nullptr;	190	return nullptr;
191	}	191	}
192		192
Lines 345-359 VaapiWrapper::GetSupportedProfileInfosFo Link Here
345	bool VaapiWrapper::VaInitialize(const base::Closure& report_error_to_uma_cb) {	345	bool VaapiWrapper::VaInitialize(const base::Closure& report_error_to_uma_cb) {
346	static bool vaapi_functions_initialized = PostSandboxInitialization();	346	static bool vaapi_functions_initialized = PostSandboxInitialization();
347	if (!vaapi_functions_initialized) {	347	if (!vaapi_functions_initialized) {
348	bool running_on_chromeos = false;	348	bool error_level_logging = false;
349	#if defined(OS_CHROMEOS)	349	#if defined(OS_LINUX)
		350	error_level_logging = true;
		351	#elif defined(OS_CHROMEOS)
350	// When chrome runs on linux with chromeos=1, do not log error message	352	// When chrome runs on linux with chromeos=1, do not log error message
351	// without VAAPI libraries.	353	// without VAAPI libraries.
352	running_on_chromeos = base::SysInfo::IsRunningOnChromeOS();	354	error_level_logging = base::SysInfo::IsRunningOnChromeOS();
353	#endif	355	#endif
354	static const char kErrorMsg[] = "Failed to initialize VAAPI libs";	356	static const char kErrorMsg[] = "Failed to initialize VAAPI libs";
355	if (running_on_chromeos)	357	if (error_level_logging)
356	LOG(ERROR) << kErrorMsg;	358	VLOG(1) << kErrorMsg;
357	else	359	else
358	DVLOG(1) << kErrorMsg;	360	DVLOG(1) << kErrorMsg;
359	return false;	361	return false;
Lines 424-430 bool VaapiWrapper::IsEntrypointSupported Link Here
424	if (std::find(supported_entrypoints.begin(),	426	if (std::find(supported_entrypoints.begin(),
425	supported_entrypoints.end(),	427	supported_entrypoints.end(),
426	entrypoint) == supported_entrypoints.end()) {	428	entrypoint) == supported_entrypoints.end()) {
427	DVLOG(1) << "Unsupported entrypoint";	429	VLOG(1) << "Unsupported entrypoint";
428	return false;	430	return false;
429	}	431	}
430	return true;	432	return true;
Lines 448-455 bool VaapiWrapper::AreAttribsSupported_L Link Here
448	if (attribs[i].type != required_attribs[i].type \|\|	450	if (attribs[i].type != required_attribs[i].type \|\|
449	(attribs[i].value & required_attribs[i].value) !=	451	(attribs[i].value & required_attribs[i].value) !=
450	required_attribs[i].value) {	452	required_attribs[i].value) {
451	DVLOG(1) << "Unsupported value " << required_attribs[i].value	453	VLOG(1) << "Unsupported value " << required_attribs[i].value
452	<< " for attribute type " << required_attribs[i].type;	454	<< " for attribute type " << required_attribs[i].type;
453	return false;	455	return false;
454	}	456	}
455	}	457	}





  base::AutoLock auto_lock(lock_);
  DCHECK_EQ(state_, kUninitialized);
  VLOG(1) << "Initializing VAVDA, profile: " << profile;

#if defined(USE_X11)
  if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL) {
    VLOG(1) << "HW video decode acceleration not available without "
                "DesktopGL (GLX).";
    return false;
  }
#elif defined(USE_OZONE)
  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
    VLOG(1) << "HW video decode acceleration not available without "
             << "EGLGLES2.";
    return false;
  }

      VaapiWrapper::kDecode, profile, base::Bind(&ReportToUMA, VAAPI_ERROR));

  if (!vaapi_wrapper_.get()) {
    VLOG(1) << "Failed initializing VAAPI for profile " << profile;
    return false;
  }


    vp9_accelerator_.reset(new VaapiVP9Accelerator(this, vaapi_wrapper_.get()));
    decoder_.reset(new VP9Decoder(vp9_accelerator_.get()));
  } else {
    VLOG(1) << "Unsupported profile " << profile;
    return false;
  }


Lines 76-82 Link Here

(-)beta.wily/content/gpu/gpu_main.cc (-2 / +2 lines)
76	#include "content/common/sandbox_mac.h"	76	#include "content/common/sandbox_mac.h"
77	#endif	77	#endif
78		78
79	#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)	79	#if (defined(OS_CHROMEOS) \|\| defined(OS_LINUX)) && defined(ARCH_CPU_X86_FAMILY)
80	#include "content/common/gpu/media/vaapi_wrapper.h"	80	#include "content/common/gpu/media/vaapi_wrapper.h"
81	#endif	81	#endif
82		82
Lines 247-253 int GpuMain(const MainFunctionParams& pa Link Here
247	GetGpuInfoFromCommandLine(gpu_info, command_line);	247	GetGpuInfoFromCommandLine(gpu_info, command_line);
248	gpu_info.in_process_gpu = false;	248	gpu_info.in_process_gpu = false;
249		249
250	#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)	250	#if (defined(OS_CHROMEOS) \|\| defined(OS_LINUX)) && defined(ARCH_CPU_X86_FAMILY)
251	VaapiWrapper::PreSandboxInitialization();	251	VaapiWrapper::PreSandboxInitialization();
252	#endif	252	#endif
253		253

Lines 698-705 bool CommandBufferProxyImpl::ProduceFron Link Here

(-)beta.wily/content/common/gpu/client/command_buffer_proxy_impl.cc (+2 lines)
698		698
699	scoped_ptr<media::VideoDecodeAccelerator>	699	scoped_ptr<media::VideoDecodeAccelerator>
700	CommandBufferProxyImpl::CreateVideoDecoder() {	700	CommandBufferProxyImpl::CreateVideoDecoder() {
		701	TRACE_EVENT0("gpu", "CommandBufferProxyImpl::CreateVideoDecoder");
701	if (!channel_)	702	if (!channel_)
702	return scoped_ptr<media::VideoDecodeAccelerator>();	703	return scoped_ptr<media::VideoDecodeAccelerator>();
		704	VLOG(1) << "About to create GpuVideoDecodeAcceleratorHost.";
703	return scoped_ptr<media::VideoDecodeAccelerator>(	705	return scoped_ptr<media::VideoDecodeAccelerator>(
704	new GpuVideoDecodeAcceleratorHost(channel_, this));	706	new GpuVideoDecodeAcceleratorHost(channel_, this));
705	}	707	}

Return to bug 31772

Lines 481-497 const char kSoftwareRenderingListJson[] Link Here

(-)beta.wily/gpu/config/software_rendering_list_json.cc (-11 lines)
481	]	481	]
482	},	482	},
483	{	483	{
484	"id": 48,
485	"description": "Accelerated video decode is unavailable on Linux",
486	"cr_bugs": [137247],
487	"os": {
488	"type": "linux"
489	},
490	"features": [
491	"accelerated_video_decode"
492	]
493	},
494	{
495	"id": 49,	484	"id": 49,
496	"description": "NVidia GeForce GT 650M can cause the system to hang with flash 3D",	485	"description": "NVidia GeForce GT 650M can cause the system to hang with flash 3D",
497	"cr_bugs": [140175],	486	"cr_bugs": [140175],

Lines 334-350 bool VaapiVideoDecodeAccelerator::Initia Link Here

(-)beta.wily/content/common/gpu/media/vaapi_video_decode_accelerator.cc (-5 / +5 lines)
334		334
335	base::AutoLock auto_lock(lock_);	335	base::AutoLock auto_lock(lock_);
336	DCHECK_EQ(state_, kUninitialized);	336	DCHECK_EQ(state_, kUninitialized);
337	DVLOG(2) << "Initializing VAVDA, profile: " << profile;	337	VLOG(1) << "Initializing VAVDA, profile: " << profile;
338		338
339	#if defined(USE_X11)	339	#if defined(USE_X11)
340	if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL) {	340	if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL) {
341	DVLOG(1) << "HW video decode acceleration not available without "	341	VLOG(1) << "HW video decode acceleration not available without "
342	"DesktopGL (GLX).";	342	"DesktopGL (GLX).";
343	return false;	343	return false;
344	}	344	}
345	#elif defined(USE_OZONE)	345	#elif defined(USE_OZONE)
346	if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {	346	if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
347	DVLOG(1) << "HW video decode acceleration not available without "	347	VLOG(1) << "HW video decode acceleration not available without "
348	<< "EGLGLES2.";	348	<< "EGLGLES2.";
349	return false;	349	return false;
350	}	350	}
Lines 354-360 bool VaapiVideoDecodeAccelerator::Initia Link Here
354	VaapiWrapper::kDecode, profile, base::Bind(&ReportToUMA, VAAPI_ERROR));	354	VaapiWrapper::kDecode, profile, base::Bind(&ReportToUMA, VAAPI_ERROR));
355		355
356	if (!vaapi_wrapper_.get()) {	356	if (!vaapi_wrapper_.get()) {
357	DVLOG(1) << "Failed initializing VAAPI for profile " << profile;	357	VLOG(1) << "Failed initializing VAAPI for profile " << profile;
358	return false;	358	return false;
359	}	359	}
360		360
Lines 371-377 bool VaapiVideoDecodeAccelerator::Initia Link Here
371	vp9_accelerator_.reset(new VaapiVP9Accelerator(this, vaapi_wrapper_.get()));	371	vp9_accelerator_.reset(new VaapiVP9Accelerator(this, vaapi_wrapper_.get()));
372	decoder_.reset(new VP9Decoder(vp9_accelerator_.get()));	372	decoder_.reset(new VP9Decoder(vp9_accelerator_.get()));
373	} else {	373	} else {
374	DLOG(ERROR) << "Unsupported profile " << profile;	374	VLOG(1) << "Unsupported profile " << profile;
375	return false;	375	return false;
376	}	376	}
377		377