Discussion:
[PATCH 0/2 v3][libva-intel-driver] report unsupported profile
(too old to reply)
Daniel Charles
2016-11-10 23:08:18 UTC
Permalink
This is a re-send of patch 1/2 and a new patch that modifies the current
unittests to properly test the unsupported profile condition.

As mentioned in the commit messages, UNSUPPORTED_PROFILE will be returned
when a queried profile is not supported by any entrypoint.

If squashing the patches is preferred, let me know and I'll resubmit.

v2: do not change the checks for specific h/w, i.e. IS_SKL as it will
change the purpose of the test

v3: fix the config tests for all components available so far using the same
purpose as the original test.


Daniel Charles (2):
i965_validate_config: return unsupported profile
i965_test_config: return properly unsupported profile

src/i965_drv_video.c | 49 +++++++++++++++++++++-----
test/i965_avcd_config_test.cpp | 71 +++++++++++++++++++++++++++++--------
test/i965_avce_config_test.cpp | 78 ++++++++++++++++++++++++++++++++++-------
test/i965_jpegd_config_test.cpp | 29 +++++++++++++--
test/i965_jpege_config_test.cpp | 29 ++++++++++++---
5 files changed, 214 insertions(+), 42 deletions(-)
--
2.5.5
Daniel Charles
2016-11-10 23:08:19 UTC
Permalink
When all the profiles are not supported return
VA_STATUS_ERROR_UNSUPPORTED_PROFILE instead of
VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT.

Also change the style on the code modified to be common
on all cases

Signed-off-by: Daniel Charles <***@intel.com>
---
src/i965_drv_video.c | 49 ++++++++++++++++++++++++++++++++++++++++---------
1 file changed, 40 insertions(+), 9 deletions(-)

diff --git a/src/i965_drv_video.c b/src/i965_drv_video.c
index 7f2146e..e17c295 100644
--- a/src/i965_drv_video.c
+++ b/src/i965_drv_video.c
@@ -711,6 +711,8 @@ i965_validate_config(VADriverContextP ctx, VAProfile profile,
if ((HAS_MPEG2_DECODING(i965) && entrypoint == VAEntrypointVLD) ||
(HAS_MPEG2_ENCODING(i965) && entrypoint == VAEntrypointEncSlice)) {
va_status = VA_STATUS_SUCCESS;
+ } else if (!HAS_MPEG2_DECODING(i965) && !HAS_MPEG2_ENCODING(i965)){
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
} else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
}
@@ -723,6 +725,9 @@ i965_validate_config(VADriverContextP ctx, VAProfile profile,
(HAS_H264_ENCODING(i965) && entrypoint == VAEntrypointEncSlice) ||
(HAS_LP_H264_ENCODING(i965) && entrypoint == VAEntrypointEncSliceLP)) {
va_status = VA_STATUS_SUCCESS;
+ } else if (!HAS_H264_DECODING(i965) && !HAS_H264_ENCODING(i965) &&
+ !HAS_LP_H264_ENCODING(i965)){
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
} else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
}
@@ -733,6 +738,8 @@ i965_validate_config(VADriverContextP ctx, VAProfile profile,
case VAProfileVC1Advanced:
if (HAS_VC1_DECODING(i965) && entrypoint == VAEntrypointVLD) {
va_status = VA_STATUS_SUCCESS;
+ } else if (!HAS_VC1_DECODING(i965)) {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
} else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
}
@@ -741,6 +748,8 @@ i965_validate_config(VADriverContextP ctx, VAProfile profile,
case VAProfileNone:
if (HAS_VPP(i965) && VAEntrypointVideoProc == entrypoint) {
va_status = VA_STATUS_SUCCESS;
+ } else if (!HAS_VPP(i965)){
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
} else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
}
@@ -750,6 +759,8 @@ i965_validate_config(VADriverContextP ctx, VAProfile profile,
if ((HAS_JPEG_DECODING(i965) && entrypoint == VAEntrypointVLD) ||
(HAS_JPEG_ENCODING(i965) && entrypoint == VAEntrypointEncPicture)) {
va_status = VA_STATUS_SUCCESS;
+ } else if (!HAS_JPEG_DECODING(i965) && !HAS_JPEG_ENCODING(i965)){
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
} else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
}
@@ -759,6 +770,8 @@ i965_validate_config(VADriverContextP ctx, VAProfile profile,
if ((HAS_VP8_DECODING(i965) && entrypoint == VAEntrypointVLD) ||
(HAS_VP8_ENCODING(i965) && entrypoint == VAEntrypointEncSlice)) {
va_status = VA_STATUS_SUCCESS;
+ } else if (!HAS_VP8_DECODING(i965) && !HAS_VP8_ENCODING(i965)){
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
} else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
}
@@ -768,8 +781,12 @@ i965_validate_config(VADriverContextP ctx, VAProfile profile,
case VAProfileH264StereoHigh:
if ((HAS_H264_MVC_DECODING_PROFILE(i965, profile) &&
entrypoint == VAEntrypointVLD) ||
- (HAS_H264_MVC_ENCODING(i965) && entrypoint == VAEntrypointEncSlice)) {
+ (HAS_H264_MVC_ENCODING(i965) &&
+ entrypoint == VAEntrypointEncSlice)) {
va_status = VA_STATUS_SUCCESS;
+ } else if(!HAS_H264_MVC_DECODING_PROFILE(i965, profile) &&
+ !HAS_H264_MVC_ENCODING(i965)) {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
} else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
}
@@ -778,32 +795,46 @@ i965_validate_config(VADriverContextP ctx, VAProfile profile,

case VAProfileHEVCMain:
if ((HAS_HEVC_DECODING(i965) && (entrypoint == VAEntrypointVLD))||
- (HAS_HEVC_ENCODING(i965) && (entrypoint == VAEntrypointEncSlice)))
+ (HAS_HEVC_ENCODING(i965) && (entrypoint == VAEntrypointEncSlice))) {
va_status = VA_STATUS_SUCCESS;
- else
+ } else if (!HAS_HEVC_DECODING(i965) && !HAS_HEVC_ENCODING(i965)) {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+ } else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }

break;

case VAProfileHEVCMain10:
if ((HAS_HEVC10_DECODING(i965) && (entrypoint == VAEntrypointVLD))||
- (HAS_HEVC10_ENCODING(i965) && (entrypoint == VAEntrypointEncSlice)))
+ (HAS_HEVC10_ENCODING(i965) &&
+ (entrypoint == VAEntrypointEncSlice))) {
va_status = VA_STATUS_SUCCESS;
- else
+ } else if (!HAS_HEVC10_DECODING(i965) && !HAS_HEVC10_ENCODING(i965)) {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+ } else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }

break;

case VAProfileVP9Profile0:
case VAProfileVP9Profile2:
- if ((HAS_VP9_DECODING_PROFILE(i965, profile)) && (entrypoint == VAEntrypointVLD))
+ if ((HAS_VP9_DECODING_PROFILE(i965, profile)) &&
+ (entrypoint == VAEntrypointVLD)) {
va_status = VA_STATUS_SUCCESS;
- else if ((HAS_VP9_ENCODING(i965)) && (entrypoint == VAEntrypointEncSlice))
+ } else if ((HAS_VP9_ENCODING(i965)) &&
+ (entrypoint == VAEntrypointEncSlice)) {
va_status = VA_STATUS_SUCCESS;
- else if ((profile == VAProfileVP9Profile0) && i965->wrapper_pdrvctx)
+ } else if (profile == VAProfileVP9Profile0 && i965->wrapper_pdrvctx) {
va_status = VA_STATUS_SUCCESS;
- else
+ } else if(!HAS_VP9_DECODING_PROFILE(i965, profile) &&
+ !HAS_VP9_ENCODING(i965) && !i965->wrapper_pdrvctx) {
+ va_status = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+ } else {
va_status = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ }
+
break;

default:
--
2.5.5
Daniel Charles
2016-11-10 23:08:20 UTC
Permalink
jpege/jpegd and avce/avcd config tests to check against all supported
entrypoints for a profile. UNSUPPORTED_PROFILE is expected
when no entrypoints are available for a given profile, else
expect UNSUPPORTED_ENTRYPOINT.

Signed-off-by: Daniel Charles <***@intel.com>
---
test/i965_avcd_config_test.cpp | 71 +++++++++++++++++++++++++++++--------
test/i965_avce_config_test.cpp | 78 ++++++++++++++++++++++++++++++++++-------
test/i965_jpegd_config_test.cpp | 29 +++++++++++++--
test/i965_jpege_config_test.cpp | 29 ++++++++++++---
4 files changed, 174 insertions(+), 33 deletions(-)

diff --git a/test/i965_avcd_config_test.cpp b/test/i965_avcd_config_test.cpp
index 851e86e..8bc5e3c 100644
--- a/test/i965_avcd_config_test.cpp
+++ b/test/i965_avcd_config_test.cpp
@@ -27,6 +27,46 @@
namespace AVC {
namespace Decode {

+VAStatus ProfileNotSupported()
+{
+ return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+}
+
+VAStatus EntrypointNotSupported()
+{
+ return VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+}
+
+// H264*NotSupported functions report properly if profile is not supported or
+// only entrypoint is not supported
+VAStatus H264NotSupported()
+{
+ I965TestEnvironment *env(I965TestEnvironment::instance());
+ EXPECT_PTR(env);
+
+ struct i965_driver_data *i965(*env);
+ EXPECT_PTR(i965);
+
+ if (!HAS_H264_ENCODING(i965)
+ && !HAS_LP_H264_ENCODING(i965))
+ return ProfileNotSupported();
+
+ return EntrypointNotSupported();
+}
+
+VAStatus H264MVCNotSupported()
+{
+ I965TestEnvironment *env(I965TestEnvironment::instance());
+ EXPECT_PTR(env);
+
+ struct i965_driver_data *i965(*env);
+ EXPECT_PTR(i965);
+
+ if (!HAS_H264_MVC_ENCODING(i965))
+ return ProfileNotSupported();
+
+ return EntrypointNotSupported();
+}
VAStatus HasDecodeSupport()
{
I965TestEnvironment *env(I965TestEnvironment::instance());
@@ -35,11 +75,13 @@ VAStatus HasDecodeSupport()
struct i965_driver_data *i965(*env);
EXPECT_PTR(i965);

- return HAS_H264_DECODING(i965) ? VA_STATUS_SUCCESS :
- VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ if (HAS_H264_DECODING(i965))
+ return VA_STATUS_SUCCESS;
+
+ return H264NotSupported();
}

-VAStatus HasMVCDecodeSupport(const VAProfile& profile)
+VAStatus HasMVCDecodeSupport()
{
I965TestEnvironment *env(I965TestEnvironment::instance());
EXPECT_PTR(env);
@@ -47,22 +89,23 @@ VAStatus HasMVCDecodeSupport(const VAProfile& profile)
struct i965_driver_data *i965(*env);
EXPECT_PTR(i965);

- return HAS_H264_MVC_DECODING_PROFILE(i965, profile) ? VA_STATUS_SUCCESS :
- VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ if (HAS_H264_MVC_DECODING(i965))
+ return VA_STATUS_SUCCESS;
+
+ return H264MVCNotSupported();
}

static const std::vector<ConfigTestInput> inputs = {
- {VAProfileH264Baseline, VAEntrypointVLD,
- []{return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;}},
+ { VAProfileH264Baseline, VAEntrypointVLD, &ProfileNotSupported },

- {VAProfileH264ConstrainedBaseline, VAEntrypointVLD, &HasDecodeSupport},
- {VAProfileH264Main, VAEntrypointVLD, &HasDecodeSupport},
- {VAProfileH264High, VAEntrypointVLD, &HasDecodeSupport},
+ { VAProfileH264ConstrainedBaseline, VAEntrypointVLD, &HasDecodeSupport },
+ { VAProfileH264Main, VAEntrypointVLD, &HasDecodeSupport },
+ { VAProfileH264High, VAEntrypointVLD, &HasDecodeSupport },

- {VAProfileH264MultiviewHigh, VAEntrypointVLD,
- std::bind(&HasMVCDecodeSupport, VAProfileH264MultiviewHigh)},
- {VAProfileH264StereoHigh, VAEntrypointVLD,
- std::bind(&HasMVCDecodeSupport, VAProfileH264StereoHigh)},
+ { VAProfileH264MultiviewHigh, VAEntrypointVLD,
+ &HasMVCDecodeSupport },
+ { VAProfileH264StereoHigh, VAEntrypointVLD,
+ &HasMVCDecodeSupport },
};

INSTANTIATE_TEST_CASE_P(
diff --git a/test/i965_avce_config_test.cpp b/test/i965_avce_config_test.cpp
index b30abbc..4830af9 100644
--- a/test/i965_avce_config_test.cpp
+++ b/test/i965_avce_config_test.cpp
@@ -37,6 +37,52 @@ VAStatus EntrypointNotSupported()
return VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
}

+//H264*NotSupported functions report properly if profile is not supported or
+//only entrypoint is not supported
+VAStatus H264NotSupported()
+{
+ I965TestEnvironment *env(I965TestEnvironment::instance());
+ EXPECT_PTR(env);
+
+ struct i965_driver_data *i965(*env);
+ EXPECT_PTR(i965);
+
+ if (!HAS_H264_DECODING(i965)
+ && !HAS_LP_H264_ENCODING(i965))
+ return ProfileNotSupported();
+
+ return EntrypointNotSupported();
+}
+
+VAStatus H264LPNotSupported()
+{
+ I965TestEnvironment *env(I965TestEnvironment::instance());
+ EXPECT_PTR(env);
+
+ struct i965_driver_data *i965(*env);
+ EXPECT_PTR(i965);
+
+ if (!HAS_H264_DECODING(i965)
+ && !HAS_H264_ENCODING(i965))
+ return ProfileNotSupported();
+
+ return EntrypointNotSupported();
+}
+
+VAStatus H264MVCNotSupported()
+{
+ I965TestEnvironment *env(I965TestEnvironment::instance());
+ EXPECT_PTR(env);
+
+ struct i965_driver_data *i965(*env);
+ EXPECT_PTR(i965);
+
+ if (!HAS_H264_MVC_DECODING(i965))
+ return ProfileNotSupported();
+
+ return EntrypointNotSupported();
+}
+
VAStatus HasEncodeSupport()
{
I965TestEnvironment *env(I965TestEnvironment::instance());
@@ -45,8 +91,10 @@ VAStatus HasEncodeSupport()
struct i965_driver_data *i965(*env);
EXPECT_PTR(i965);

- return HAS_H264_ENCODING(i965) ? VA_STATUS_SUCCESS :
- EntrypointNotSupported();
+ if (HAS_H264_ENCODING(i965))
+ return VA_STATUS_SUCCESS;
+
+ return H264NotSupported();
}

VAStatus HasLPEncodeSupport()
@@ -60,8 +108,10 @@ VAStatus HasLPEncodeSupport()
if (IS_SKL(i965->intel.device_info))
return VA_STATUS_SUCCESS;

- return HAS_LP_H264_ENCODING(i965) ? VA_STATUS_SUCCESS :
- EntrypointNotSupported();
+ if (HAS_LP_H264_ENCODING(i965))
+ return VA_STATUS_SUCCESS;
+
+ return H264LPNotSupported();
}

VAStatus HasMVCEncodeSupport()
@@ -72,8 +122,10 @@ VAStatus HasMVCEncodeSupport()
struct i965_driver_data *i965(*env);
EXPECT_PTR(i965);

- return HAS_H264_MVC_ENCODING(i965) ? VA_STATUS_SUCCESS :
- EntrypointNotSupported();
+ if (HAS_H264_MVC_ENCODING(i965))
+ return VA_STATUS_SUCCESS;
+
+ return H264MVCNotSupported();
}

static const std::vector<ConfigTestInput> inputs = {
@@ -83,23 +135,23 @@ static const std::vector<ConfigTestInput> inputs = {

{VAProfileH264ConstrainedBaseline, VAEntrypointEncSlice, &HasEncodeSupport},
{VAProfileH264ConstrainedBaseline, VAEntrypointEncSliceLP, &HasLPEncodeSupport},
- {VAProfileH264ConstrainedBaseline, VAEntrypointEncPicture, &EntrypointNotSupported},
+ {VAProfileH264ConstrainedBaseline, VAEntrypointEncPicture, &H264NotSupported},

{VAProfileH264Main, VAEntrypointEncSlice, &HasEncodeSupport},
{VAProfileH264Main, VAEntrypointEncSliceLP, &HasLPEncodeSupport},
- {VAProfileH264Main, VAEntrypointEncPicture, &EntrypointNotSupported},
+ {VAProfileH264Main, VAEntrypointEncPicture, &H264NotSupported},

{VAProfileH264High, VAEntrypointEncSlice, &HasEncodeSupport},
{VAProfileH264High, VAEntrypointEncSliceLP, &HasLPEncodeSupport},
- {VAProfileH264High, VAEntrypointEncPicture, &EntrypointNotSupported},
+ {VAProfileH264High, VAEntrypointEncPicture, &H264NotSupported},

{VAProfileH264MultiviewHigh, VAEntrypointEncSlice, &HasMVCEncodeSupport},
- {VAProfileH264MultiviewHigh, VAEntrypointEncSliceLP, &EntrypointNotSupported},
- {VAProfileH264MultiviewHigh, VAEntrypointEncPicture, &EntrypointNotSupported},
+ {VAProfileH264MultiviewHigh, VAEntrypointEncSliceLP, &H264MVCNotSupported},
+ {VAProfileH264MultiviewHigh, VAEntrypointEncPicture, &H264MVCNotSupported},

{VAProfileH264StereoHigh, VAEntrypointEncSlice, &HasMVCEncodeSupport},
- {VAProfileH264StereoHigh, VAEntrypointEncSliceLP, &EntrypointNotSupported},
- {VAProfileH264StereoHigh, VAEntrypointEncPicture, &EntrypointNotSupported},
+ {VAProfileH264StereoHigh, VAEntrypointEncSliceLP, &H264MVCNotSupported},
+ {VAProfileH264StereoHigh, VAEntrypointEncPicture, &H264MVCNotSupported},
};

INSTANTIATE_TEST_CASE_P(
diff --git a/test/i965_jpegd_config_test.cpp b/test/i965_jpegd_config_test.cpp
index 4e2216c..371b827 100644
--- a/test/i965_jpegd_config_test.cpp
+++ b/test/i965_jpegd_config_test.cpp
@@ -26,6 +26,29 @@

namespace JPEG {
namespace Decode {
+VAStatus ProfileNotSupported()
+{
+ return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+}
+
+VAStatus EntrypointNotSupported()
+{
+ return VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+}
+
+VAStatus NotSupported()
+{
+ I965TestEnvironment *env(I965TestEnvironment::instance());
+ EXPECT_PTR(env);
+
+ struct i965_driver_data *i965(*env);
+ EXPECT_PTR(i965);
+
+ if (!HAS_JPEG_ENCODING(i965))
+ return ProfileNotSupported();
+
+ return EntrypointNotSupported();
+}

VAStatus HasDecodeSupport()
{
@@ -35,8 +58,10 @@ VAStatus HasDecodeSupport()
struct i965_driver_data *i965(*env);
EXPECT_PTR(i965);

- return HAS_JPEG_DECODING(i965) ? VA_STATUS_SUCCESS :
- VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+ if(HAS_JPEG_DECODING(i965))
+ return VA_STATUS_SUCCESS;
+
+ return NotSupported();
}

static const std::vector<ConfigTestInput> inputs = {
diff --git a/test/i965_jpege_config_test.cpp b/test/i965_jpege_config_test.cpp
index 924eccb..eb5931d 100644
--- a/test/i965_jpege_config_test.cpp
+++ b/test/i965_jpege_config_test.cpp
@@ -27,11 +27,30 @@
namespace JPEG {
namespace Encode {

+VAStatus ProfileNotSupported()
+{
+ return VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+}
+
VAStatus EntrypointNotSupported()
{
return VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
}

+VAStatus NotSupported()
+{
+ I965TestEnvironment *env(I965TestEnvironment::instance());
+ EXPECT_PTR(env);
+
+ struct i965_driver_data *i965(*env);
+ EXPECT_PTR(i965);
+
+ if (!HAS_JPEG_DECODING(i965))
+ return ProfileNotSupported();
+
+ return EntrypointNotSupported();
+}
+
VAStatus HasEncodeSupport()
{
I965TestEnvironment *env(I965TestEnvironment::instance());
@@ -40,14 +59,16 @@ VAStatus HasEncodeSupport()
struct i965_driver_data *i965(*env);
EXPECT_PTR(i965);

- return HAS_JPEG_ENCODING(i965) ? VA_STATUS_SUCCESS :
- EntrypointNotSupported();
+ if (HAS_JPEG_ENCODING(i965))
+ return VA_STATUS_SUCCESS;
+
+ return NotSupported();
}

static const std::vector<ConfigTestInput> inputs = {
{VAProfileJPEGBaseline, VAEntrypointEncPicture, &HasEncodeSupport},
- {VAProfileJPEGBaseline, VAEntrypointEncSlice, &EntrypointNotSupported},
- {VAProfileJPEGBaseline, VAEntrypointEncSliceLP, &EntrypointNotSupported},
+ {VAProfileJPEGBaseline, VAEntrypointEncSlice, &NotSupported},
+ {VAProfileJPEGBaseline, VAEntrypointEncSliceLP, &NotSupported},
};

INSTANTIATE_TEST_CASE_P(
--
2.5.5
Eoff, Ullysses A
2016-11-10 23:14:47 UTC
Permalink
LGTM.
-----Original Message-----
Sent: Thursday, November 10, 2016 3:08 PM
Subject: [Libva] [PATCH 0/2 v3][libva-intel-driver] report unsupported profile
This is a re-send of patch 1/2 and a new patch that modifies the current
unittests to properly test the unsupported profile condition.
As mentioned in the commit messages, UNSUPPORTED_PROFILE will be returned
when a queried profile is not supported by any entrypoint.
If squashing the patches is preferred, let me know and I'll resubmit.
v2: do not change the checks for specific h/w, i.e. IS_SKL as it will
change the purpose of the test
v3: fix the config tests for all components available so far using the same
purpose as the original test.
i965_validate_config: return unsupported profile
i965_test_config: return properly unsupported profile
src/i965_drv_video.c | 49 +++++++++++++++++++++-----
test/i965_avcd_config_test.cpp | 71 +++++++++++++++++++++++++++++--------
test/i965_avce_config_test.cpp | 78 ++++++++++++++++++++++++++++++++++-------
test/i965_jpegd_config_test.cpp | 29 +++++++++++++--
test/i965_jpege_config_test.cpp | 29 ++++++++++++---
5 files changed, 214 insertions(+), 42 deletions(-)
--
2.5.5
_______________________________________________
Libva mailing list
https://lists.freedesktop.org/mailman/listinfo/libva
Sean V Kelley
2016-11-10 23:49:35 UTC
Permalink
Post by Daniel Charles
This is a re-send of patch 1/2 and a new patch that modifies the current
unittests to properly test the unsupported profile condition.
As mentioned in the commit messages, UNSUPPORTED_PROFILE will be returned
when a queried profile is not supported by any entrypoint.
If squashing the patches is preferred, let me know and I'll resubmit.
lgtm, added Artie's review tag, applied.

Thanks,

Sean
v2: do not change the checks for specific h/w, i.e. IS_SKL as it will
Post by Daniel Charles
change the purpose of the test
v3: fix the config tests for all components available so far using the same
purpose as the original test.
i965_validate_config: return unsupported profile
i965_test_config: return properly unsupported profile
src/i965_drv_video.c | 49 +++++++++++++++++++++-----
test/i965_avcd_config_test.cpp | 71 +++++++++++++++++++++++++++++--------
test/i965_avce_config_test.cpp | 78 ++++++++++++++++++++++++++++++++++-------
test/i965_jpegd_config_test.cpp | 29 +++++++++++++--
test/i965_jpege_config_test.cpp | 29 ++++++++++++---
5 files changed, 214 insertions(+), 42 deletions(-)
Loading...