bool VAApiWriter::processParams( bool * )
{
zoom = getParam( "Zoom" ).toDouble();
deinterlace = getParam( "Deinterlace" ).toInt();
aspect_ratio = getParam( "AspectRatio" ).toDouble();
const int _Hue = getParam( "Hue" ).toInt();
const int _Saturation = getParam( "Saturation" ).toInt();
const int _Brightness = getParam( "Brightness" ).toInt();
const int _Contrast = getParam( "Contrast" ).toInt();
if ( _Hue != Hue || _Saturation != Saturation || _Brightness != Brightness || _Contrast != Contrast )
{
Hue = _Hue;
Saturation = _Saturation;
Brightness = _Brightness;
Contrast = _Contrast;
int num_attribs = vaMaxNumDisplayAttributes( VADisp );
VADisplayAttribute attribs[ num_attribs ];
if ( !vaQueryDisplayAttributes( VADisp, attribs, &num_attribs ) )
{
for ( int i = 0 ; i < num_attribs ; ++i )
{
switch ( attribs[ i ].type )
{
case VADisplayAttribHue:
attribs[ i ].value = Functions::scaleEQValue( Hue, attribs[ i ].min_value, attribs[ i ].max_value );
break;
case VADisplayAttribSaturation:
attribs[ i ].value = Functions::scaleEQValue( Saturation, attribs[ i ].min_value, attribs[ i ].max_value );
break;
case VADisplayAttribBrightness:
attribs[ i ].value = Functions::scaleEQValue( Brightness, attribs[ i ].min_value, attribs[ i ].max_value );
break;
case VADisplayAttribContrast:
attribs[ i ].value = Functions::scaleEQValue( Contrast, attribs[ i ].min_value, attribs[ i ].max_value );
break;
default:
break;
}
}
vaSetDisplayAttributes( VADisp, attribs, num_attribs );
}
}
if ( !isVisible() )
QMPlay2Core.dockVideo( this );
else
{
resizeEvent( NULL );
if ( paused )
draw();
}
return readyWrite();
}
int VAAPIContext::SetPictureAttribute(PictureAttribute attribute, int newValue)
{
if (!m_display)
return newValue;
if (!m_display->m_va_disp)
return newValue;
int adj = 0;
VADisplayAttribType attrib = VADisplayAttribBrightness;
switch (attribute)
{
case kPictureAttribute_Brightness:
attrib = VADisplayAttribBrightness;
break;
case kPictureAttribute_Contrast:
attrib = VADisplayAttribContrast;
break;
case kPictureAttribute_Hue:
attrib = VADisplayAttribHue;
adj = m_hueBase;
break;
case kPictureAttribute_Colour:
attrib = VADisplayAttribSaturation;
break;
default:
return -1;
}
bool found = false;
for (int i = 0; i < m_pictureAttributeCount; i++)
{
if (m_pictureAttributes[i].type == attrib)
{
int min = m_pictureAttributes[i].min_value;
int max = m_pictureAttributes[i].max_value;
int val = min + (int)(((float)((newValue + adj) % 100) / 100.0) * (max - min));
m_pictureAttributes[i].value = val;
found = true;
break;
}
}
if (found)
{
INIT_ST;
va_status = vaSetDisplayAttributes(m_display->m_va_disp,
m_pictureAttributes,
m_pictureAttributeCount);
CHECK_ST;
return newValue;
}
return -1;
}
bool VaapiDisplay::setRotation(int degree)
{
VAStatus vaStatus;
VADisplayAttribute rotate;
rotate.type = VADisplayAttribRotation;
rotate.value = VA_ROTATION_NONE;
if (degree == 0)
rotate.value = VA_ROTATION_NONE;
else if (degree == 90)
rotate.value = VA_ROTATION_90;
else if (degree == 180)
rotate.value = VA_ROTATION_180;
else if (degree == 270)
rotate.value = VA_ROTATION_270;
vaStatus = vaSetDisplayAttributes(m_vaDisplay, &rotate, 1);
if (!checkVaapiStatus(vaStatus, "vaSetDisplayAttributes"))
return false;
return true;
}
bool VaapiDisplay::setRotation(int degree)
{
VAStatus vaStatus;
VADisplayAttribute* attrList = NULL;
VADisplayAttribute rotate;
int i, numAttributes;
rotate.type = VADisplayAttribRotation;
rotate.value = VA_ROTATION_NONE;
if (degree == 0) //no need to set rotation when degree is zero
return true;
else if (degree == 90)
rotate.value = VA_ROTATION_90;
else if (degree == 180)
rotate.value = VA_ROTATION_180;
else if (degree == 270)
rotate.value = VA_ROTATION_270;
/* should query before set display attributres */
vaStatus = vaQueryDisplayAttributes(m_vaDisplay, attrList, &numAttributes);
if (!checkVaapiStatus(vaStatus, "vaQueryDisplayAttributes") || !attrList)
return false;
for (i = 0; i < numAttributes; i++) {
if (attrList[i].type == VADisplayAttribRotation)
break;
}
if ((i == numAttributes) || !(attrList[i].flags & VA_DISPLAY_ATTRIB_SETTABLE) )
return false;
vaStatus = vaSetDisplayAttributes(m_vaDisplay, &rotate, 1);
if (!checkVaapiStatus(vaStatus, "vaSetDisplayAttributes"))
return false;
return true;
}
Decode_Status
VaapiDecoderBase::setupVA(uint32_t numSurface, VAProfile profile)
{
INFO("base: setup VA");
uint32_t i;
VASurfaceID *surfaces;
VideoSurfaceBuffer *buf;
VaapiSurface *suf;
Decode_Status status;
VAStatus vaStatus = VA_STATUS_SUCCESS;
if (m_enableNativeBuffersFlag == true) {
numSurface = 20; //NATIVE_WINDOW_COUNT;
}
if (m_VAStarted) {
return DECODE_SUCCESS;
}
if (m_VADisplay != NULL) {
WARNING("VA is partially started.");
return DECODE_FAIL;
}
#ifdef ANDROID
m_display = new Display;
*m_display = ANDROID_DISPLAY_HANDLE;
#else
if (!m_display) {
m_display = XOpenDisplay(NULL);
m_ownNativeDisplay = true;
}
#if __PLATFORM_BYT__
if (setenv("LIBVA_DRIVER_NAME", "wrapper", 1) == 0) {
INFO("setting LIBVA_DRIVER_NAME to wrapper for chromeos");
}
#endif
#endif
m_VADisplay = vaGetDisplay(m_display);
if (m_VADisplay == NULL) {
ERROR("vaGetDisplay failed.");
return DECODE_DRIVER_FAIL;
}
int majorVersion, minorVersion;
vaStatus = vaInitialize(m_VADisplay, &majorVersion, &minorVersion);
checkVaapiStatus(vaStatus, "vaInitialize");
VAConfigAttrib attrib;
attrib.type = VAConfigAttribRTFormat;
attrib.value = VA_RT_FORMAT_YUV420;
INFO("base:the profile = %d", profile);
vaStatus = vaCreateConfig(m_VADisplay,
profile,
VAEntrypointVLD, &attrib, 1, &m_VAConfig);
checkVaapiStatus(vaStatus, "vaCreateConfig");
m_configBuffer.surfaceNumber = numSurface;
m_bufPool = new VaapiSurfaceBufferPool(m_VADisplay, &m_configBuffer);
surfaces = new VASurfaceID[numSurface];
for (i = 0; i < numSurface; i++) {
surfaces[i] = VA_INVALID_SURFACE;
buf = m_bufPool->getBufferByIndex(i);
suf = m_bufPool->getVaapiSurface(buf);
if (suf)
surfaces[i] = suf->getID();
}
vaStatus = vaCreateContext(m_VADisplay,
m_VAConfig,
m_videoFormatInfo.width,
m_videoFormatInfo.height,
0, surfaces, numSurface, &m_VAContext);
checkVaapiStatus(vaStatus, "vaCreateContext");
VADisplayAttribute rotate;
rotate.type = VADisplayAttribRotation;
rotate.value = VA_ROTATION_NONE;
if (m_configBuffer.rotationDegrees == 0)
rotate.value = VA_ROTATION_NONE;
else if (m_configBuffer.rotationDegrees == 90)
rotate.value = VA_ROTATION_90;
else if (m_configBuffer.rotationDegrees == 180)
rotate.value = VA_ROTATION_180;
else if (m_configBuffer.rotationDegrees == 270)
rotate.value = VA_ROTATION_270;
vaStatus = vaSetDisplayAttributes(m_VADisplay, &rotate, 1);
m_videoFormatInfo.surfaceNumber = numSurface;
m_videoFormatInfo.ctxSurfaces = surfaces;
if (!(m_configBuffer.flag & USE_NATIVE_GRAPHIC_BUFFER)) {
m_videoFormatInfo.surfaceWidth = m_videoFormatInfo.width;
m_videoFormatInfo.surfaceHeight = m_videoFormatInfo.height;
}
m_VAStarted = true;
return DECODE_SUCCESS;
}
int vaapi_init(VADisplay display)
{
#if 0
CommonContext * common = common_get_context();
#endif
VAAPIContext *vaapi;
int major_version, minor_version;
int i, num_display_attrs, max_display_attrs;
VADisplayAttribute *display_attrs;
VAStatus status;
if (vaapi_context)
return 0;
if (!display)
return -1;
D(bug("VA display %p\n", display));
status = vaInitialize(display, &major_version, &minor_version);
if (!vaapi_check_status(status, "vaInitialize()"))
return -1;
D(bug("VA API version %d.%d\n", major_version, minor_version));
max_display_attrs = vaMaxNumDisplayAttributes(display);
display_attrs = malloc(max_display_attrs * sizeof(display_attrs[0]));
if (!display_attrs)
return -1;
num_display_attrs = 0; /* XXX: workaround old GMA500 bug */
status = vaQueryDisplayAttributes(display, display_attrs, &num_display_attrs);
if (!vaapi_check_status(status, "vaQueryDisplayAttributes()")) {
free(display_attrs);
return -1;
}
D(bug("%d display attributes available\n", num_display_attrs));
for (i = 0; i < num_display_attrs; i++) {
VADisplayAttribute * const display_attr = &display_attrs[i];
D(bug(" %-32s (%s/%s) min %d max %d value 0x%x\n",
string_of_VADisplayAttribType(display_attr->type),
(display_attr->flags & VA_DISPLAY_ATTRIB_GETTABLE) ? "get" : "---",
(display_attr->flags & VA_DISPLAY_ATTRIB_SETTABLE) ? "set" : "---",
display_attr->min_value,
display_attr->max_value,
display_attr->value));
}
free(display_attrs);
#if 0
if (common->use_vaapi_background_color) {
VADisplayAttribute attr;
attr.type = VADisplayAttribBackgroundColor;
attr.value = common->vaapi_background_color;
status = vaSetDisplayAttributes(display, &attr, 1);
if (!vaapi_check_status(status, "vaSetDisplayAttributes()"))
return -1;
}
#endif
if ((vaapi = calloc(1, sizeof(*vaapi))) == NULL)
return -1;
vaapi->display = display;
vaapi->subpic_image.image_id = VA_INVALID_ID;
for (i = 0; i < ARRAY_ELEMS(vaapi->subpic_ids); i++)
vaapi->subpic_ids[i] = VA_INVALID_ID;
vaapi_context = vaapi;
return 0;
}
