frodovdr/vdr-plugin-softhddevice
1
0
Fork 0
mirror of https://projects.vdr-developer.org/git/vdr-plugin-softhddevice.git synced 2023-10-10 19:16:51 +02:00
Code Issues Releases Wiki Activity
fc2580dc2a
vdr-plugin-softhddevice/video.c

3839 lines
98 KiB
C
Raw Blame History

///
/// @file video.c @brief Video module
///
/// Copyright (c) 2009 - 2011 by Johns. All Rights Reserved.
///
/// Contributor(s):
///
/// License: AGPLv3
///
/// This program is free software: you can redistribute it and/or modify
/// it under the terms of the GNU Affero General Public License as
/// published by the Free Software Foundation, either version 3 of the
/// License.
///
/// This program is distributed in the hope that it will be useful,
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
/// GNU Affero General Public License for more details.
///
/// $Id$
//////////////////////////////////////////////////////////////////////////////
///
/// @defgroup Video The video module.
///
/// This module contains all video rendering functions.
///
/// @todo hide mouse cursor support
///
/// Uses Xlib where it is needed for VA-API or vdpau. XCB is used for
/// everything else.
///
/// - X11
/// - OpenGL rendering
/// - OpenGL rendering with GLX texture-from-pixmap
/// - Xrender rendering
///
#define DEBUG
#define USE_XLIB_XCB
#define noUSE_GLX
#define noUSE_DOUBLEBUFFER
#define USE_VAAPI
#define noUSE_VDPAU
#define noUSE_BITMAP
#define USE_VIDEO_THREAD
#include <sys/time.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <libintl.h>
#define _(str) gettext(str) ///< gettext shortcut
#define _N(str) str ///< gettext_noop shortcut
#include <alsa/iatomic.h> // portable atomic_t
#ifdef USE_VIDEO_THREAD
#ifndef __USE_GNU
#define __USE_GNU
#endif
#include <pthread.h>
#include <time.h>
#endif
#ifdef USE_XLIB_XCB
#include <X11/Xlib-xcb.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <xcb/xcb.h>
#include <xcb/bigreq.h>
#include <xcb/dpms.h>
#include <xcb/glx.h>
#include <xcb/randr.h>
#include <xcb/screensaver.h>
#include <xcb/shm.h>
#include <xcb/xv.h>
#include <xcb/xcb_image.h>
#include <xcb/xcb_event.h>
#include <xcb/xcb_atom.h>
#include <xcb/xcb_icccm.h>
#include <xcb/xcb_keysyms.h>
#endif
#ifdef USE_GLX
#include <GL/glx.h>
// only for gluErrorString
#include <GL/glu.h>
#endif
#ifdef USE_VAAPI
#include <va/va_x11.h>
#ifdef USE_GLX
#include <va/va_glx.h>
#endif
#endif
#ifdef USE_VDPAU
#include <vdpau/vdpau_x11.h>
#endif
#include <libavcodec/avcodec.h>
#include <libavcodec/vaapi.h>
#include <libavutil/pixdesc.h>
#include "misc.h"
#include "video.h"
#include "audio.h"
#ifdef USE_XLIB_XCB
//----------------------------------------------------------------------------
// Declarations
//----------------------------------------------------------------------------
///
/// Video deinterlace modes.
///
typedef enum _video_deinterlace_modes_
{
VideoDeinterlaceBob, ///< bob deinterlace
VideoDeinterlaceWeave, ///< weave deinterlace
VideoDeinterlaceTemporal, ///< temporal deinterlace
VideoDeinterlaceTemporalSpatial, ///< temporal spatial deinterlace
VideoDeinterlaceSoftware, ///< software deinterlace
} VideoDeinterlaceModes;
///
/// Video scalinng modes.
///
typedef enum _video_scaling_modes_
{
VideoScalingNormal, ///< normal scaling
VideoScalingFast, ///< fastest scaling
VideoScalingHQ, ///< high quality scaling
VideoScalingAnamorphic, ///< anamorphic scaling
} VideoScalingModes;
//----------------------------------------------------------------------------
// Defines
//----------------------------------------------------------------------------
#define CODEC_SURFACES_MAX 31 ///< maximal of surfaces
#define CODEC_SURFACES_DEFAULT (21+4) ///< default of surfaces
#define CODEC_SURFACES_MPEG2 3 ///< 1 decode, up to 2 references
#define CODEC_SURFACES_MPEG4 3 ///< 1 decode, up to 2 references
#define CODEC_SURFACES_H264 21 ///< 1 decode, up to 20 references
#define CODEC_SURFACES_VC1 3 ///< 1 decode, up to 2 references
#define VIDEO_SURFACES_MAX 3 ///< video output surfaces for queue
#define OUTPUT_SURFACES_MAX 4 ///< output surfaces for flip page
//----------------------------------------------------------------------------
// Variables
//----------------------------------------------------------------------------
static Display *XlibDisplay; ///< Xlib X11 display
static xcb_connection_t *Connection; ///< xcb connection
static xcb_colormap_t VideoColormap; ///< video colormap
static xcb_window_t VideoWindow; ///< video window
static int VideoWindowX; ///< video output x
static int VideoWindowY; ///< video outout y
static unsigned VideoWindowWidth; ///< video output width
static unsigned VideoWindowHeight; ///< video output height
/// Default deinterlace mode
static VideoDeinterlaceModes VideoDeinterlace;
/// Default scaling mode
static VideoScalingModes VideoScaling;
static xcb_atom_t WmDeleteWindowAtom; ///< WM delete message
extern uint32_t VideoSwitch;
//----------------------------------------------------------------------------
// Functions
//----------------------------------------------------------------------------
static void VideoThreadLock(void); ///< lock video thread
static void VideoThreadUnlock(void); ///< unlock video thread
//----------------------------------------------------------------------------
// GLX
//----------------------------------------------------------------------------
#ifdef USE_GLX
static int GlxEnabled = 1; ///< use GLX
static int GlxVSyncEnabled = 0; ///< enable/disable v-sync
static GLXContext GlxSharedContext; ///< shared gl context
static GLXContext GlxContext; ///< our gl context
static XVisualInfo *GlxVisualInfo; ///< our gl visual
static GLuint OsdGlTextures[2]; ///< gl texture for OSD
static int OsdIndex; ///< index into OsdGlTextures
///
/// GLX extension functions
///@{
#ifdef GLX_MESA_swap_control
static PFNGLXSWAPINTERVALMESAPROC GlxSwapIntervalMESA;
#endif
#ifdef GLX_SGI_video_sync
static PFNGLXGETVIDEOSYNCSGIPROC GlxGetVideoSyncSGI;
#endif
#ifdef GLX_SGI_swap_control
static PFNGLXSWAPINTERVALSGIPROC GlxSwapIntervalSGI;
#endif
///@}
///
/// GLX check error.
///
static void GlxCheck(void)
{
GLenum err;
if ((err = glGetError()) != GL_NO_ERROR) {
Debug(3, "video/glx: error %d '%s'\n", err, gluErrorString(err));
}
}
///
/// GLX check if a GLX extension is supported.
///
/// @param ext extension to query
/// @returns true if supported, false otherwise
///
static int GlxIsExtensionSupported(const char *ext)
{
const char *extensions;
if ((extensions =
glXQueryExtensionsString(XlibDisplay,
DefaultScreen(XlibDisplay)))) {
const char *s;
int l;
s = strstr(extensions, ext);
l = strlen(ext);
return s && (s[l] == ' ' || s[l] == '\0');
}
return 0;
}
#if 0
///
/// Setup GLX decoder
///
/// @param decoder VA-API decoder
///
void GlxSetupDecoder(VaapiDecoder * decoder)
{
int width;
int height;
int i;
width = decoder->InputWidth;
height = decoder->InputHeight;
glEnable(GL_TEXTURE_2D); // create 2d texture
glGenTextures(2, decoder->GlTexture);
GlxCheck();
for (i = 0; i < 2; ++i) {
glBindTexture(GL_TEXTURE_2D, decoder->GlTexture[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_BGRA,
GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
}
glDisable(GL_TEXTURE_2D);
GlxCheck();
}
#endif
/**
** Render texture.
**
** @param texture 2d texture
*/
static inline void GlxRenderTexture(GLuint texture, int x, int y, int width,
int height)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f); // no color
glBegin(GL_QUADS); {
glTexCoord2f(1.0f, 1.0f);
glVertex2i(x + width, y + height);
glTexCoord2f(0.0f, 1.0f);
glVertex2i(x, y + height);
glTexCoord2f(0.0f, 0.0f);
glVertex2i(x, y);
glTexCoord2f(1.0f, 0.0f);
glVertex2i(x + width, y);
#if 0
glTexCoord2f(0.0f, 0.0f);
glVertex2i(x, y);
glTexCoord2f(0.0f, 1.0f);
glVertex2i(x, y + height);
glTexCoord2f(1.0f, 1.0f);
glVertex2i(x + width, y + height);
glTexCoord2f(1.0f, 0.0f);
glVertex2i(x + width, y);
#endif
}
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
}
/**
** Upload texture.
*/
static void GlxUploadTexture(int x, int y, int width, int height,
const uint8_t * argb)
{
// FIXME: use other / faster uploads
// ARB_pixelbuffer_object GL_PIXEL_UNPACK_BUFFER glBindBufferARB()
// glMapBuffer() glUnmapBuffer()
// glTexSubImage2D
glEnable(GL_TEXTURE_2D); // upload 2d texture
glBindTexture(GL_TEXTURE_2D, OsdGlTextures[OsdIndex]);
glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height, GL_BGRA,
GL_UNSIGNED_BYTE, argb);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
}
/**
** Render to glx texture.
*/
static void GlxRender(int osd_width, int osd_height)
{
static uint8_t *image;
static uint8_t cycle;
int x;
int y;
if (!OsdGlTextures[0] || !OsdGlTextures[1]) {
return;
}
// render each frame kills performance
// osd 1920 * 1080 * 4 (RGBA) * 50 (HZ) = 396 Mb/s
// too big for alloca
if (!image) {
image = malloc(4 * osd_width * osd_height);
memset(image, 0x00, 4 * osd_width * osd_height);
}
for (y = 0; y < osd_height; ++y) {
for (x = 0; x < osd_width; ++x) {
((uint32_t *) image)[x + y * osd_width] =
0x00FFFFFF | (cycle++) << 24;
}
}
cycle++;
// FIXME: convert is for GLX texture unneeded
// convert internal osd to image
//GfxConvert(image, 0, 4 * osd_width);
//
GlxUploadTexture(0, 0, osd_width, osd_height, image);
}
///
/// Setup GLX window.
///
static void GlxSetupWindow(xcb_window_t window, int width, int height)
{
uint32_t start;
uint32_t end;
int i;
unsigned count;
Debug(3, "video/glx: %s\n %x %dx%d", __FUNCTION__, window, width, height);
// set glx context
if (!glXMakeCurrent(XlibDisplay, window, GlxContext)) {
Fatal(_("video/glx: can't make glx context current\n"));
// FIXME: disable glx
return;
}
Debug(3, "video/glx: ok\n");
#ifdef DEBUG
// check if v-sync is working correct
end = GetMsTicks();
for (i = 0; i < 10; ++i) {
start = end;
glClear(GL_COLOR_BUFFER_BIT);
glXSwapBuffers(XlibDisplay, window);
end = GetMsTicks();
GlxGetVideoSyncSGI(&count);
Debug(3, "video/glx: %5d frame rate %d ms\n", count, end - start);
// nvidia can queue 5 swaps
if (i > 5 && (end - start) < 15) {
Warning(_("video/glx: no v-sync\n"));
}
}
#endif
// viewpoint
GlxCheck();
glViewport(0, 0, width, height);
glDepthRange(-1.0, 1.0);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glColor3f(1.0f, 1.0f, 1.0f);
glClearDepth(1.0);
GlxCheck();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, width, height, 0.0, -1.0, 1.0);
GlxCheck();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_DEPTH_TEST); // setup 2d drawing
glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE);
#ifdef USE_DOUBLEBUFFER
glDrawBuffer(GL_BACK);
#else
glDrawBuffer(GL_FRONT);
#endif
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#ifdef DEBUG
#ifdef USE_DOUBLEBUFFER
glDrawBuffer(GL_FRONT);
glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glDrawBuffer(GL_BACK);
#endif
#endif
// clear
glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // intial background color
glClear(GL_COLOR_BUFFER_BIT);
#ifdef DEBUG
glClearColor(1.0f, 1.0f, 0.0f, 1.0f); // background color
#endif
GlxCheck();
}
///
/// Initialize GLX.
///
static void GlxInit(void)
{
static GLint visual_attr[] = {
GLX_RGBA,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
#ifdef USE_DOUBLEBUFFER
GLX_DOUBLEBUFFER,
#endif
None
};
XVisualInfo *vi;
GLXContext context;
int major;
int minor;
int glx_GLX_EXT_swap_control;
int glx_GLX_MESA_swap_control;
int glx_GLX_SGI_swap_control;
int glx_GLX_SGI_video_sync;
if (!glXQueryVersion(XlibDisplay, &major, &minor)) {
Error(_("video/glx: no GLX support\n"));
GlxEnabled = 0;
return;
}
Info(_("video/glx: glx version %d.%d\n"), major, minor);
//
// check which extension are supported
//
glx_GLX_EXT_swap_control = GlxIsExtensionSupported("GLX_EXT_swap_control");
glx_GLX_MESA_swap_control =
GlxIsExtensionSupported("GLX_MESA_swap_control");
glx_GLX_SGI_swap_control = GlxIsExtensionSupported("GLX_SGI_swap_control");
glx_GLX_SGI_video_sync = GlxIsExtensionSupported("GLX_SGI_video_sync");
#ifdef GLX_MESA_swap_control
if (glx_GLX_MESA_swap_control) {
GlxSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)
glXGetProcAddress((const GLubyte *)"glXSwapIntervalMESA");
}
Debug(3, "video/glx: GlxSwapIntervalMESA=%p\n", GlxSwapIntervalMESA);
#endif
#ifdef GLX_SGI_swap_control
if (glx_GLX_SGI_swap_control) {
GlxSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)
glXGetProcAddress((const GLubyte *)"glXSwapIntervalSGI");
}
Debug(3, "video/glx: GlxSwapIntervalSGI=%p\n", GlxSwapIntervalSGI);
#endif
#ifdef GLX_SGI_video_sync
if (glx_GLX_SGI_video_sync) {
GlxGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)
glXGetProcAddress((const GLubyte *)"glXGetVideoSyncSGI");
}
Debug(3, "video/glx: GlxGetVideoSyncSGI=%p\n", GlxGetVideoSyncSGI);
#endif
// glXGetVideoSyncSGI glXWaitVideoSyncSGI
#if 0
// FIXME: use xcb: xcb_glx_create_context
#endif
// create glx context
glXMakeCurrent(XlibDisplay, None, NULL);
vi = glXChooseVisual(XlibDisplay, DefaultScreen(XlibDisplay), visual_attr);
if (!vi) {
Error(_("video/glx: can't get a RGB visual\n"));
GlxEnabled = 0;
return;
}
if (!vi->visual) {
Error(_("video/glx: no valid visual found\n"));
GlxEnabled = 0;
return;
}
if (vi->bits_per_rgb < 8) {
Error(_("video/glx: need atleast 8-bits per RGB\n"));
GlxEnabled = 0;
return;
}
context = glXCreateContext(XlibDisplay, vi, NULL, GL_TRUE);
if (!context) {
Error(_("video/glx: can't create glx context\n"));
GlxEnabled = 0;
return;
}
GlxSharedContext = context;
context = glXCreateContext(XlibDisplay, vi, GlxSharedContext, GL_TRUE);
if (!context) {
Error(_("video/glx: can't create glx context\n"));
GlxEnabled = 0;
// FIXME: destroy GlxSharedContext
return;
}
GlxContext = context;
GlxVisualInfo = vi;
Debug(3, "video/glx: visual %#02x depth %u\n", (unsigned)vi->visualid,
vi->depth);
//
// query default v-sync state
//
if (glx_GLX_EXT_swap_control) {
unsigned tmp;
tmp = -1;
glXQueryDrawable(XlibDisplay, DefaultRootWindow(XlibDisplay),
GLX_SWAP_INTERVAL_EXT, &tmp);
GlxCheck();
Debug(3, "video/glx: default v-sync is %d\n", tmp);
} else {
Debug(3, "video/glx: default v-sync is unknown\n");
}
//
// disable wait on v-sync
//
// FIXME: sleep before swap / busy waiting hardware
// FIXME: 60hz lcd panel
// FIXME: config: default, on, off
#ifdef GLX_SGI_swap_control
if (GlxVSyncEnabled < 0 && GlxSwapIntervalSGI) {
if (GlxSwapIntervalSGI(0)) {
GlxCheck();
Warning(_("video/glx: can't disable v-sync\n"));
} else {
Info(_("video/glx: v-sync disabled\n"));
}
} else
#endif
#ifdef GLX_MESA_swap_control
if (GlxVSyncEnabled < 0 && GlxSwapIntervalMESA) {
if (GlxSwapIntervalMESA(0)) {
GlxCheck();
Warning(_("video/glx: can't disable v-sync\n"));
} else {
Info(_("video/glx: v-sync disabled\n"));
}
}
#endif
//
// enable wait on v-sync
//
#ifdef GLX_SGI_swap_control
if (GlxVSyncEnabled > 0 && GlxSwapIntervalMESA) {
if (GlxSwapIntervalMESA(1)) {
GlxCheck();
Warning(_("video/glx: can't enable v-sync\n"));
} else {
Info(_("video/glx: v-sync enabled\n"));
}
} else
#endif
#ifdef GLX_MESA_swap_control
if (GlxVSyncEnabled > 0 && GlxSwapIntervalSGI) {
if (GlxSwapIntervalSGI(1)) {
GlxCheck();
Warning(_("video/glx: can't enable v-sync\n"));
} else {
Info(_("video/glx: v-sync enabled\n"));
}
}
#endif
}
///
/// Cleanup GLX.
///
static void GlxExit(void)
{
Debug(3, "video/glx: %s\n", __FUNCTION__);
glFinish();
// must destroy glx
if (glXGetCurrentContext() == GlxContext) {
// if currently used, set to none
glXMakeCurrent(XlibDisplay, None, NULL);
}
if (GlxSharedContext) {
glXDestroyContext(XlibDisplay, GlxSharedContext);
}
if (GlxContext) {
glXDestroyContext(XlibDisplay, GlxContext);
}
#if 0
if (GlxThreadContext) {
glXDestroyContext(XlibDisplay, GlxThreadContext);
}
// FIXME: must free GlxVisualInfo
#endif
}
#endif
//----------------------------------------------------------------------------
// VA-API
//----------------------------------------------------------------------------
#ifdef USE_VAAPI
static int VideoVaapiEnabled = 1; ///< use VA-API decoder
static int VaapiBuggyVdpau; ///< fix libva-driver-vdpau bugs
static VADisplay *VaDisplay; ///< VA-API display
static VAImage VaOsdImage = {
.image_id = VA_INVALID_ID
}; ///< osd VA-API image
static VASubpictureID VaOsdSubpicture; ///< osd VA-API subpicture
static char VaapiUnscaledOsd; ///< unscaled osd supported
/// VA-API decoder typedef
typedef struct _vaapi_decoder_ VaapiDecoder;
///
/// VA-API decoder
///
struct _vaapi_decoder_
{
VADisplay *VaDisplay; ///< VA-API display
unsigned SurfaceFlags; ///< flags for put surface
xcb_window_t Window; ///< output window
int OutputX; ///< output window x
int OutputY; ///< output window y
int OutputWidth; ///< output window width
int OutputHeight; ///< output window height
enum PixelFormat PixFmt; ///< ffmpeg frame pixfmt
int WrongInterlacedWarned; ///< warning about interlace flag issued
int Interlaced; ///< ffmpeg interlaced flag
int TopFieldFirst; ///< ffmpeg top field displayed first
VAImage DeintImages[3]; ///< deinterlace image buffers
VAImage Image[1]; ///< image buffer to update surface
struct vaapi_context VaapiContext[1]; ///< ffmpeg VA-API context
int SurfaceUsedN; ///< number of used surfaces
/// used surface ids
VASurfaceID SurfacesUsed[CODEC_SURFACES_MAX];
int SurfaceFreeN; ///< number of free surfaces
/// free surface ids
VASurfaceID SurfacesFree[CODEC_SURFACES_MAX];
int InputX; ///< input x
int InputY; ///< input y
int InputWidth; ///< input width
int InputHeight; ///< input height
AVRational InputAspect; ///< input aspect ratio
#ifdef USE_GLX
GLuint GlTexture[2]; ///< gl texture for VA-API
void *GlxSurface[2]; ///< VA-API/GLX surface
#endif
VASurfaceID BlackSurface; ///< empty black surface
/// video surface ring buffer
VASurfaceID SurfacesRb[VIDEO_SURFACES_MAX];
int SurfaceWrite; ///< write pointer
int SurfaceRead; ///< read pointer
atomic_t SurfacesFilled; ///< how many of the buffer is used
int SurfaceField; ///< current displayed field
struct timespec FrameTime; ///< time of last display
struct timespec StartTime; ///< decoder start time
int FramesDuped; ///< frames duplicated
int FramesDropped; ///< frames dropped
int FrameCounter; ///< number of frames decoded
};
static VaapiDecoder *VaapiDecoders[1]; ///< open decoder streams
static int VaapiDecoderN; ///< number of decoder streams
/// forward display back surface
static void VaapiBlackSurface(VaapiDecoder * decoder);
//----------------------------------------------------------------------------
// VA-API Functions
//----------------------------------------------------------------------------
// Surfaces -------------------------------------------------------------
///
/// Create surfaces for VA-API decoder.
///
/// @param decoder VA-API decoder
/// @param width surface source/video width
/// @param height surface source/video height
///
static void VaapiCreateSurfaces(VaapiDecoder * decoder, int width, int height)
{
Debug(3, "video/vaapi: %s: %dx%d * %d\n", __FUNCTION__, width, height,
CODEC_SURFACES_DEFAULT);
// FIXME: allocate only the number of needed surfaces
decoder->SurfaceFreeN = CODEC_SURFACES_DEFAULT;
// VA_RT_FORMAT_YUV420 VA_RT_FORMAT_YUV422 VA_RT_FORMAT_YUV444
if (vaCreateSurfaces(decoder->VaDisplay, width, height,
VA_RT_FORMAT_YUV420, decoder->SurfaceFreeN,
decoder->SurfacesFree) != VA_STATUS_SUCCESS) {
Fatal(_("video/vaapi: can't create %d surfaces\n"),
decoder->SurfaceFreeN);
// FIXME: write error handler / fallback
}
//
// update OSD associate
//
if (VaOsdSubpicture == VA_INVALID_ID) {
Warning(_("video/vaapi: no osd subpicture yet\n"));
return;
}
if (VaapiUnscaledOsd) {
if (vaAssociateSubpicture(VaDisplay, VaOsdSubpicture,
decoder->SurfacesFree, decoder->SurfaceFreeN, 0, 0,
VaOsdImage.width, VaOsdImage.height, 0, 0, VideoWindowWidth,
VideoWindowHeight, VA_SUBPICTURE_DESTINATION_IS_SCREEN_COORD)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't associate subpicture\n"));
}
} else {
if (vaAssociateSubpicture(VaDisplay, VaOsdSubpicture,
decoder->SurfacesFree, decoder->SurfaceFreeN, 0, 0,
VaOsdImage.width, VaOsdImage.height, 0, 0, width, height, 0)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't associate subpicture\n"));
}
}
}
///
/// Destroy surfaces of VA-API decoder.
///
/// @param decoder VA-API decoder
///
static void VaapiDestroySurfaces(VaapiDecoder * decoder)
{
Debug(3, "video/vaapi: %s:\n", __FUNCTION__);
//
// update OSD associate
//
if (VaOsdSubpicture != VA_INVALID_ID) {
if (vaDeassociateSubpicture(VaDisplay, VaOsdSubpicture,
decoder->SurfacesFree, decoder->SurfaceFreeN)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't deassociate %d surfaces\n"),
decoder->SurfaceFreeN);
}
if (vaDeassociateSubpicture(VaDisplay, VaOsdSubpicture,
decoder->SurfacesUsed, decoder->SurfaceUsedN)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't deassociate %d surfaces\n"),
decoder->SurfaceUsedN);
}
}
if (vaDestroySurfaces(decoder->VaDisplay, decoder->SurfacesFree,
decoder->SurfaceFreeN)
!= VA_STATUS_SUCCESS) {
Error("video/vaapi: can't destroy %d surfaces\n",
decoder->SurfaceFreeN);
}
decoder->SurfaceFreeN = 0;
if (vaDestroySurfaces(decoder->VaDisplay, decoder->SurfacesUsed,
decoder->SurfaceUsedN)
!= VA_STATUS_SUCCESS) {
Error("video/vaapi: can't destroy %d surfaces\n",
decoder->SurfaceUsedN);
}
decoder->SurfaceUsedN = 0;
// FIXME surfaces used for output
}
///
/// Get a free surface.
///
/// @param decoder VA-API decoder
///
static VASurfaceID VaapiGetSurface(VaapiDecoder * decoder)
{
VASurfaceID surface;
int i;
if (!decoder->SurfaceFreeN) {
Error("video/vaapi: out of surfaces\n");
return VA_INVALID_ID;
}
// use oldest surface
surface = decoder->SurfacesFree[0];
decoder->SurfaceFreeN--;
for (i = 0; i < decoder->SurfaceFreeN; ++i) {
decoder->SurfacesFree[i] = decoder->SurfacesFree[i + 1];
}
// save as used
decoder->SurfacesUsed[decoder->SurfaceUsedN++] = surface;
return surface;
}
///
/// Release a surface.
///
/// @param decoder VA-API decoder
/// @param surface surface no longer used
///
static void VaapiReleaseSurface(VaapiDecoder * decoder, VASurfaceID surface)
{
int i;
for (i = 0; i < decoder->SurfaceUsedN; ++i) {
if (decoder->SurfacesUsed[i] == surface) {
// no problem, with last used
decoder->SurfacesUsed[i] =
decoder->SurfacesUsed[--decoder->SurfaceUsedN];
decoder->SurfacesFree[decoder->SurfaceFreeN++] = surface;
return;
}
}
Error(_("video/vaapi: release surface %#x, which is not in use\n"),
surface);
}
// Init/Exit ------------------------------------------------------------
///
/// Debug VA-API decoder frames drop...
///
/// @param decoder video hardware decoder
///
static void VaapiPrintFrames(const VaapiDecoder * decoder)
{
Debug(3, "video/vaapi: %d duped, %d dropped frames of %d\n",
decoder->FramesDuped, decoder->FramesDropped, decoder->FrameCounter);
}
///
/// Allocate new VA-API decoder.
///
static VaapiDecoder *VaapiNewDecoder(void)
{
VaapiDecoder *decoder;
int i;
if (VaapiDecoderN == 1) {
Fatal(_("video/vaapi: out of decoders\n"));
}
if (!(decoder = calloc(1, sizeof(*decoder)))) {
Fatal(_("video/vaapi: out of memory\n"));
}
decoder->VaDisplay = VaDisplay;
decoder->Window = VideoWindow;
decoder->SurfaceFlags = VA_CLEAR_DRAWABLE;
// color space conversion none, ITU-R BT.601, ITU-R BT.709
decoder->SurfaceFlags |= VA_SRC_BT601;
// scaling flags FAST, HQ, NL_ANAMORPHIC
// FIXME: need to detect the backend to choose the parameter
switch (VideoScaling) {
case VideoScalingNormal:
decoder->SurfaceFlags |= VA_FILTER_SCALING_DEFAULT;
break;
case VideoScalingFast:
decoder->SurfaceFlags |= VA_FILTER_SCALING_FAST;
break;
case VideoScalingHQ:
// vdpau backend supports only VA_FILTER_SCALING_HQ
// vdpau backend with advanced deinterlacer and my GT-210
// is too slow
decoder->SurfaceFlags |= VA_FILTER_SCALING_HQ;
break;
case VideoScalingAnamorphic:
// intel backend supports only VA_FILTER_SCALING_NL_ANAMORPHIC;
// don't use it, its for 4:3 -> 16:9 scaling
decoder->SurfaceFlags |= VA_FILTER_SCALING_NL_ANAMORPHIC;
break;
}
// deinterlace flags (not yet supported by libva)
switch (VideoDeinterlace) {
case VideoDeinterlaceBob:
break;
case VideoDeinterlaceWeave:
break;
case VideoDeinterlaceTemporal:
//FIXME: private hack
//decoder->SurfaceFlags |= 0x00002000;
break;
case VideoDeinterlaceTemporalSpatial:
//FIXME: private hack
//decoder->SurfaceFlags |= 0x00006000;
break;
case VideoDeinterlaceSoftware:
break;
}
decoder->DeintImages[0].image_id = VA_INVALID_ID;
decoder->DeintImages[1].image_id = VA_INVALID_ID;
decoder->DeintImages[2].image_id = VA_INVALID_ID;
decoder->Image->image_id = VA_INVALID_ID;
// setup video surface ring buffer
atomic_set(&decoder->SurfacesFilled, 0);
for (i = 0; i < VIDEO_SURFACES_MAX; ++i) {
decoder->SurfacesRb[i] = VA_INVALID_ID;
}
decoder->BlackSurface = VA_INVALID_ID;
//
// Setup ffmpeg vaapi context
//
decoder->VaapiContext->display = VaDisplay;
decoder->VaapiContext->config_id = VA_INVALID_ID;
decoder->VaapiContext->context_id = VA_INVALID_ID;
#ifdef USE_GLX
if (GlxEnabled) {
// FIXME: create GLX context here
}
#endif
decoder->OutputWidth = VideoWindowWidth;
decoder->OutputHeight = VideoWindowHeight;
#ifdef noDEBUG
// FIXME: for play
decoder->OutputX = 40;
decoder->OutputY = 40;
decoder->OutputWidth = VideoWindowWidth - 40 * 2;
decoder->OutputHeight = VideoWindowHeight - 40 * 2;
#endif
VaapiDecoders[VaapiDecoderN++] = decoder;
return decoder;
}
/**
** Cleanup VA-API.
**
** @param decoder va-api hw decoder
*/
static void VaapiCleanup(VaapiDecoder * decoder)
{
int filled;
VASurfaceID surface;
// flush output queue, only 1-2 frames buffered, no big loss
while ((filled = atomic_read(&decoder->SurfacesFilled))) {
decoder->SurfaceRead = (decoder->SurfaceRead + 1) % VIDEO_SURFACES_MAX;
atomic_dec(&decoder->SurfacesFilled);
surface = decoder->SurfacesRb[decoder->SurfaceRead];
if (vaSyncSurface(decoder->VaDisplay, surface)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaSyncSurface failed\n"));
}
}
decoder->WrongInterlacedWarned = 0;
// cleanup image
if (decoder->Image->image_id != VA_INVALID_ID) {
if (vaDestroyImage(VaDisplay,
decoder->Image->image_id) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't destroy image!\n"));
}
decoder->Image->image_id = VA_INVALID_ID;
}
// cleanup context and config
if (decoder->VaapiContext) {
if (decoder->VaapiContext->context_id != VA_INVALID_ID) {
if (vaDestroyContext(VaDisplay,
decoder->VaapiContext->context_id) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't destroy context!\n"));
}
decoder->VaapiContext->context_id = VA_INVALID_ID;
}
if (decoder->VaapiContext->config_id != VA_INVALID_ID) {
if (vaDestroyConfig(VaDisplay,
decoder->VaapiContext->config_id) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't destroy config!\n"));
}
decoder->VaapiContext->config_id = VA_INVALID_ID;
}
}
// cleanup surfaces
if (decoder->SurfaceFreeN || decoder->SurfaceUsedN) {
VaapiDestroySurfaces(decoder);
}
clock_gettime(CLOCK_REALTIME, &decoder->StartTime);
}
///
/// Destroy a VA-API decoder.
///
/// @param decoder VA-API decoder
///
static void VaapiDelDecoder(VaapiDecoder * decoder)
{
VaapiCleanup(decoder);
if (decoder->BlackSurface) {
if (vaDestroySurfaces(decoder->VaDisplay, &decoder->BlackSurface, 1)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't destroy a surface\n"));
}
}
// FIXME: decoder->DeintImages
#ifdef USE_GLX
if (decoder->GlxSurface[0]) {
if (vaDestroySurfaceGLX(VaDisplay, decoder->GlxSurface[0])
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't destroy glx surface!\n"));
}
}
if (decoder->GlxSurface[1]) {
if (vaDestroySurfaceGLX(VaDisplay, decoder->GlxSurface[1])
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't destroy glx surface!\n"));
}
}
if (decoder->GlTexture[0]) {
glDeleteTextures(2, decoder->GlTexture);
}
#endif
VaapiPrintFrames(decoder);
free(decoder);
}
/**
** VA-API setup.
**
** @param display_name x11/xcb display name
*/
static void VideoVaapiInit(const char *display_name)
{
int major;
int minor;
VADisplayAttribute attr;
const char *s;
// FIXME: make configurable
// FIXME: intel get hangups with bob
// VideoDeinterlace = VideoDeinterlaceWeave;
VaOsdImage.image_id = VA_INVALID_ID;
VaOsdSubpicture = VA_INVALID_ID;
#ifdef USE_GLX
if (GlxEnabled) { // support glx
VaDisplay = vaGetDisplayGLX(XlibDisplay);
} else
#endif
{
VaDisplay = vaGetDisplay(XlibDisplay);
}
if (!VaDisplay) {
Fatal(_("video/vaapi: Can't connect VA-API to X11 server on '%s'"),
display_name);
// FIXME: no fatal for plugin
}
if (vaInitialize(VaDisplay, &major, &minor) != VA_STATUS_SUCCESS) {
Fatal(_("video/vaapi: Can't inititialize VA-API on '%s'"),
display_name);
}
s = vaQueryVendorString(VaDisplay);
Info(_("video/vaapi: libva %d.%d (%s) initialized\n"), major, minor, s);
//
// Setup fixes for driver bugs.
//
if (strstr(s, "VDPAU")) {
Info(_("video/vaapi: use vdpau bug workaround\n"));
setenv("VDPAU_VIDEO_PUTSURFACE_FAST", "0", 0);
VaapiBuggyVdpau = 1;
}
//
// check if driver makes a copy of the VA surface for display.
//
attr.type = VADisplayAttribDirectSurface;
attr.flags = VA_DISPLAY_ATTRIB_GETTABLE;
if (vaGetDisplayAttributes(VaDisplay, &attr, 1) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: Can't get direct-surface attribute\n"));
attr.value = 1;
}
Info(_("video/vaapi: VA surface is %s\n"),
attr.value ? _("direct mapped") : _("copied"));
// FIXME: handle the cases: new liba: Don't use it.
#if 0
//
// check the chroma format
//
attr.type = VAConfigAttribRTFormat attr.flags = VA_DISPLAY_ATTRIB_GETTABLE;
#endif
}
///
/// VA-API cleanup
///
static void VideoVaapiExit(void)
{
int i;
// FIXME: more VA-API cleanups...
if (VaOsdImage.image_id != VA_INVALID_ID) {
if (vaDestroyImage(VaDisplay,
VaOsdImage.image_id) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't destroy image!\n"));
}
VaOsdImage.image_id = VA_INVALID_ID;
}
if (VaOsdSubpicture != VA_INVALID_ID) {
if (vaDestroySubpicture(VaDisplay, VaOsdSubpicture)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't destroy subpicture\n"));
}
VaOsdSubpicture = VA_INVALID_ID;
}
for (i = 0; i < VaapiDecoderN; ++i) {
if (VaapiDecoders[i]) {
VaapiDelDecoder(VaapiDecoders[i]);
VaapiDecoders[i] = NULL;
}
}
VaapiDecoderN = 0;
if (!VaDisplay) {
vaTerminate(VaDisplay);
VaDisplay = NULL;
}
}
/**
** Update output for new size or aspect ratio.
**
** @param decoder VA-API decoder
*/
static void VaapiUpdateOutput(VaapiDecoder * decoder)
{
AVRational input_aspect_ratio;
AVRational display_aspect_ratio;
input_aspect_ratio = decoder->InputAspect;
if (!input_aspect_ratio.num || !input_aspect_ratio.den) {
input_aspect_ratio.num = 1;
input_aspect_ratio.den = 1;
Debug(3, "video: aspect defaults to %d:%d\n", input_aspect_ratio.num,
input_aspect_ratio.den);
}
av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
decoder->InputWidth * input_aspect_ratio.num,
decoder->InputHeight * input_aspect_ratio.den, 1024 * 1024);
Debug(3, "video: aspect %d : %d\n", display_aspect_ratio.num,
display_aspect_ratio.den);
// FIXME: store different positions for the ratios
decoder->OutputX = 0;
decoder->OutputY = 0;
decoder->OutputWidth = (VideoWindowHeight * display_aspect_ratio.num)
/ display_aspect_ratio.den;
decoder->OutputHeight = (VideoWindowWidth * display_aspect_ratio.num)
/ display_aspect_ratio.den;
if ((unsigned)decoder->OutputWidth > VideoWindowWidth) {
decoder->OutputWidth = VideoWindowWidth;
decoder->OutputY = (VideoWindowHeight - decoder->OutputHeight) / 2;
} else {
decoder->OutputHeight = VideoWindowHeight;
decoder->OutputX = (VideoWindowWidth - decoder->OutputWidth) / 2;
}
}
/**
** Find VA-API profile.
**
** Check if the requested profile is supported by VA-API.
**
** @param profiles a table of all supported profiles
** @param n number of supported profiles
** @param profile requested profile
**
** @returns the profile if supported, -1 if unsupported.
*/
static VAProfile VaapiFindProfile(const VAProfile * profiles, unsigned n,
VAProfile profile)
{
unsigned u;
for (u = 0; u < n; ++u) {
if (profiles[u] == profile) {
return profile;
}
}
return -1;
}
/**
** Find VA-API entry point.
**
** Check if the requested entry point is supported by VA-API.
**
** @param entrypoints a table of all supported entrypoints
** @param n number of supported entrypoints
** @param entrypoint requested entrypoint
**
** @returns the entry point if supported, -1 if unsupported.
*/
static VAEntrypoint VaapiFindEntrypoint(const VAEntrypoint * entrypoints,
unsigned n, VAEntrypoint entrypoint)
{
unsigned u;
for (u = 0; u < n; ++u) {
if (entrypoints[u] == entrypoint) {
return entrypoint;
}
}
return -1;
}
/**
** Callback to negotiate the PixelFormat.
**
** @param fmt is the list of formats which are supported by the codec,
** it is terminated by -1 as 0 is a valid format, the
** formats are ordered by quality.
*/
static enum PixelFormat Vaapi_get_format(VaapiDecoder * decoder,
AVCodecContext * video_ctx, const enum PixelFormat *fmt)
{
const enum PixelFormat *fmt_idx;
VAProfile profiles[vaMaxNumProfiles(VaDisplay)];
int profile_n;
VAEntrypoint entrypoints[vaMaxNumEntrypoints(VaDisplay)];
int entrypoint_n;
int p;
int e;
VAConfigAttrib attrib;
Debug(3, "video: new stream format %d\n", GetMsTicks() - VideoSwitch);
// create initial black surface and display
VaapiBlackSurface(decoder);
VaapiCleanup(decoder);
if (getenv("NO_HW")) { // FIXME: make config option
goto slow_path;
}
p = -1;
e = -1;
// prepare va-api profiles
if (vaQueryConfigProfiles(VaDisplay, profiles, &profile_n)) {
Error(_("codec: vaQueryConfigProfiles failed"));
goto slow_path;
}
Debug(3, "codec: %d profiles\n", profile_n);
// check profile
switch (video_ctx->codec_id) {
case CODEC_ID_MPEG2VIDEO:
p = VaapiFindProfile(profiles, profile_n, VAProfileMPEG2Main);
break;
case CODEC_ID_MPEG4:
case CODEC_ID_H263:
p = VaapiFindProfile(profiles, profile_n,
VAProfileMPEG4AdvancedSimple);
break;
case CODEC_ID_H264:
// try more simple formats, fallback to better
if (video_ctx->profile == FF_PROFILE_H264_BASELINE) {
p = VaapiFindProfile(profiles, profile_n,
VAProfileH264Baseline);
if (p == -1) {
p = VaapiFindProfile(profiles, profile_n,
VAProfileH264Main);
}
} else if (video_ctx->profile == FF_PROFILE_H264_MAIN) {
p = VaapiFindProfile(profiles, profile_n, VAProfileH264Main);
}
if (p == -1) {
p = VaapiFindProfile(profiles, profile_n, VAProfileH264High);
}
break;
case CODEC_ID_WMV3:
p = VaapiFindProfile(profiles, profile_n, VAProfileVC1Main);
break;
case CODEC_ID_VC1:
p = VaapiFindProfile(profiles, profile_n, VAProfileVC1Advanced);
break;
default:
goto slow_path;
}
if (p == -1) {
Debug(3, "\tno profile found\n");
goto slow_path;
}
Debug(3, "\tprofile %d\n", p);
// prepare va-api entry points
if (vaQueryConfigEntrypoints(VaDisplay, p, entrypoints, &entrypoint_n)) {
Error(_("codec: vaQueryConfigEntrypoints failed"));
goto slow_path;
}
Debug(3, "codec: %d entrypoints\n", entrypoint_n);
// look through formats
for (fmt_idx = fmt; *fmt_idx != PIX_FMT_NONE; fmt_idx++) {
Debug(3, "\t%#010x %s\n", *fmt_idx, av_get_pix_fmt_name(*fmt_idx));
// check supported pixel format with entry point
switch (*fmt_idx) {
case PIX_FMT_VAAPI_VLD:
e = VaapiFindEntrypoint(entrypoints, entrypoint_n,
VAEntrypointVLD);
break;
case PIX_FMT_VAAPI_MOCO:
case PIX_FMT_VAAPI_IDCT:
Debug(3, "codec: this VA-API pixel format is not supported\n");
default:
continue;
}
if (e != -1) {
Debug(3, "\tentry point %d\n", e);
break;
}
}
if (e == -1) {
Warning(_("codec: unsupported: slow path\n"));
goto slow_path;
}
//
// prepare decoder
//
memset(&attrib, 0, sizeof(attrib));
attrib.type = VAConfigAttribRTFormat;
if (vaGetConfigAttributes(decoder->VaDisplay, p, e, &attrib, 1)) {
Error(_("codec: can't get attributes"));
goto slow_path;
}
if (attrib.value & VA_RT_FORMAT_YUV420) {
Info(_("codec: YUV 420 supported\n"));
}
if (attrib.value & VA_RT_FORMAT_YUV422) {
Info(_("codec: YUV 422 supported\n"));
}
if (attrib.value & VA_RT_FORMAT_YUV444) {
Info(_("codec: YUV 444 supported\n"));
}
if (!(attrib.value & VA_RT_FORMAT_YUV420)) {
Warning(_("codec: YUV 420 not supported\n"));
goto slow_path;
}
// create a configuration for the decode pipeline
if (vaCreateConfig(decoder->VaDisplay, p, e, &attrib, 1,
&decoder->VaapiContext->config_id)) {
Error(_("codec: can't create config"));
goto slow_path;
}
// FIXME: need only to create and destroy surfaces for size changes!
VaapiCreateSurfaces(decoder, video_ctx->width, video_ctx->height);
// bind surfaces to context
if (vaCreateContext(decoder->VaDisplay, decoder->VaapiContext->config_id,
video_ctx->width, video_ctx->height, VA_PROGRESSIVE,
decoder->SurfacesFree, decoder->SurfaceFreeN,
&decoder->VaapiContext->context_id)) {
Error(_("codec: can't create context"));
goto slow_path;
}
decoder->InputX = 0;
decoder->InputY = 0;
decoder->InputWidth = video_ctx->width;
decoder->InputHeight = video_ctx->height;
decoder->InputAspect = video_ctx->sample_aspect_ratio;
VaapiUpdateOutput(decoder);
#ifdef USE_GLX
if (GlxEnabled) {
GlxSetupDecoder(decoder);
// FIXME: try two textures, but vdpau-backend supports only 1 surface
if (vaCreateSurfaceGLX(decoder->VaDisplay, GL_TEXTURE_2D,
decoder->GlTexture[0], &decoder->GlxSurface[0])
!= VA_STATUS_SUCCESS) {
Fatal(_("video: can't create glx surfaces"));
}
// FIXME: this isn't usable with vdpau-backend
/*
if (vaCreateSurfaceGLX(decoder->VaDisplay, GL_TEXTURE_2D,
decoder->GlTexture[1], &decoder->GlxSurface[1])
!= VA_STATUS_SUCCESS) {
Fatal(_("video: can't create glx surfaces"));
}
*/
}
#endif
Debug(3, "\tpixel format %#010x\n", *fmt_idx);
return *fmt_idx;
slow_path:
// no accelerated format found
video_ctx->hwaccel_context = NULL;
return avcodec_default_get_format(video_ctx, fmt);
}
/**
** Draw surface of the VA-API decoder with x11.
**
** vaPutSurface with intel backend does sync on v-sync.
**
** @param decoder VA-API decoder
** @param surface VA-API surface id
** @param interlaced flag interlaced source
** @param top_field_first flag top_field_first for interlaced source
** @param field interlaced draw: 0 first field, 1 second field
*/
static void VaapiPutSurfaceX11(VaapiDecoder * decoder, VASurfaceID surface,
int interlaced, int top_field_first, int field)
{
unsigned type;
VAStatus status;
// fixes: [drm:i915_hangcheck_elapsed] *ERROR* Hangcheck
// timer elapsed... GPU hung
usleep(1 * 1000);
// deinterlace
if (interlaced && VideoDeinterlace != VideoDeinterlaceWeave) {
if (top_field_first) {
if (field) {
type = VA_BOTTOM_FIELD;
} else {
type = VA_TOP_FIELD;
}
} else {
if (field) {
type = VA_TOP_FIELD;
} else {
type = VA_BOTTOM_FIELD;
}
}
} else {
type = VA_FRAME_PICTURE;
}
if ((status = vaPutSurface(decoder->VaDisplay, surface, decoder->Window,
// decoder src
decoder->InputX, decoder->InputY, decoder->InputWidth,
decoder->InputHeight,
// video dst
decoder->OutputX, decoder->OutputY, decoder->OutputWidth,
decoder->OutputHeight, NULL, 0,
type | decoder->SurfaceFlags)) != VA_STATUS_SUCCESS) {
// switching video kills VdpPresentationQueueBlockUntilSurfaceIdle
Error(_("video/vaapi: vaPutSurface failed %d\n"), status);
}
if (0) {
// check if surface is really ready
// VDPAU backend, says always ready
VASurfaceStatus status;
if (vaQuerySurfaceStatus(decoder->VaDisplay, surface, &status)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaQuerySurface failed\n"));
status = VASurfaceReady;
}
if (status != VASurfaceReady) {
Warning(_
("video/vaapi: surface %#x not ready: still displayed %d\n"),
surface, status);
return;
}
if (vaSyncSurface(decoder->VaDisplay, surface) != VA_STATUS_SUCCESS) {
Error(_("video: vaSyncSurface failed\n"));
}
}
if (0) {
int i;
// look how the status changes the next 40ms
for (i = 0; i < 40; ++i) {
VASurfaceStatus status;
if (vaQuerySurfaceStatus(VaDisplay, surface,
&status) != VA_STATUS_SUCCESS) {
Error(_("video: vaQuerySurface failed\n"));
}
Debug(3, "video/vaapi: %2d %d\n", i, status);
usleep(1 * 1000);
}
}
}
#ifdef USE_GLX
/**
** Render texture.
**
** @param texture 2d texture
*/
static inline void VideoRenderTexture(GLuint texture, int x, int y, int width,
int height)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f); // no color
glBegin(GL_QUADS); {
glTexCoord2f(1.0f, 1.0f);
glVertex2i(x + width, y + height);
glTexCoord2f(0.0f, 1.0f);
glVertex2i(x, y + height);
glTexCoord2f(0.0f, 0.0f);
glVertex2i(x, y);
glTexCoord2f(1.0f, 0.0f);
glVertex2i(x + width, y);
#if 0
glTexCoord2f(0.0f, 0.0f);
glVertex2i(x, y);
glTexCoord2f(0.0f, 1.0f);
glVertex2i(x, y + height);
glTexCoord2f(1.0f, 1.0f);
glVertex2i(x + width, y + height);
glTexCoord2f(1.0f, 0.0f);
glVertex2i(x + width, y);
#endif
}
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
}
/**
** Draw surface of the VA-API decoder with glx.
**
** @param decoder VA-API decoder
** @param surface VA-API surface id
** @param interlaced flag interlaced source
** @param top_field_first flag top_field_first for interlaced source
** @param field interlaced draw: 0 first field, 1 second field
*/
static void VaapiPutSurfaceGLX(VaapiDecoder * decoder, VASurfaceID surface,
int interlaced, int top_field_first, int field)
{
unsigned type;
uint32_t start;
uint32_t copy;
uint32_t end;
// deinterlace
if (interlaced && VideoDeinterlace != VideoDeinterlaceWeave) {
if (top_field_first) {
if (field) {
type = VA_BOTTOM_FIELD;
} else {
type = VA_TOP_FIELD;
}
} else {
if (field) {
type = VA_TOP_FIELD;
} else {
type = VA_BOTTOM_FIELD;
}
}
} else {
type = VA_FRAME_PICTURE;
}
start = GetMsTicks();
if (vaCopySurfaceGLX(decoder->VaDisplay, decoder->GlxSurface[0], surface,
type | decoder->SurfaceFlags) != VA_STATUS_SUCCESS) {
Error(_("video: vaCopySurfaceGLX failed\n"));
return;
}
copy = GetMsTicks();
// hardware surfaces are always busy
VideoRenderTexture(decoder->GlTexture[0], decoder->OutputX,
decoder->OutputY, decoder->OutputWidth, decoder->OutputHeight);
end = GetMsTicks();
//Debug(3, "video/vaapi/glx: %d copy %d render\n", copy - start, end - copy);
}
#endif
/**
** Find VA-API image format.
**
** @param decoder VA-API decoder
** @param pix_fmt ffmpeg pixel format
** @param[out] format image format
**
** FIXME: can fallback from I420 to YV12, if not supported
** FIXME: must check if put/get with this format is supported (see intel)
*/
static int VaapiFindImageFormat(VaapiDecoder * decoder,
enum PixelFormat pix_fmt, VAImageFormat * format)
{
VAImageFormat *imgfrmts;
int imgfrmt_n;
int i;
unsigned fourcc;
switch (pix_fmt) { // convert ffmpeg to VA-API
// NV12, YV12, I420, BGRA
// intel: I420 is native format for MPEG-2 decoded surfaces
// intel: NV12 is native format for H.264 decoded surfaces
case PIX_FMT_YUV420P:
fourcc = VA_FOURCC_YV12; // YVU
fourcc = VA_FOURCC('I', '4', '2', '0'); // YUV
// FIXME: intel deinterlace ... only supported with nv12
break;
case PIX_FMT_NV12:
fourcc = VA_FOURCC_NV12;
break;
default:
Fatal(_("video/vaapi: unsupported pixel format %d\n"), pix_fmt);
}
imgfrmt_n = vaMaxNumImageFormats(decoder->VaDisplay);
imgfrmts = alloca(imgfrmt_n * sizeof(*imgfrmts));
if (vaQueryImageFormats(decoder->VaDisplay, imgfrmts, &imgfrmt_n)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaQueryImageFormats failed\n"));
return 0;
}
Debug(3, "video/vaapi: search format %c%c%c%c in %d image formats\n",
fourcc, fourcc >> 8, fourcc >> 16, fourcc >> 24, imgfrmt_n);
Debug(3, "video/vaapi: supported image formats:\n");
for (i = 0; i < imgfrmt_n; ++i) {
Debug(3, "video/vaapi:\t%c%c%c%c\t%d\n", imgfrmts[i].fourcc,
imgfrmts[i].fourcc >> 8, imgfrmts[i].fourcc >> 16,
imgfrmts[i].fourcc >> 24, imgfrmts[i].depth);
}
//
// search image format
//
for (i = 0; i < imgfrmt_n; ++i) {
if (imgfrmts[i].fourcc == fourcc) {
*format = imgfrmts[i];
Debug(3, "video/vaapi: use\t%c%c%c%c\t%d\n", imgfrmts[i].fourcc,
imgfrmts[i].fourcc >> 8, imgfrmts[i].fourcc >> 16,
imgfrmts[i].fourcc >> 24, imgfrmts[i].depth);
return 1;
}
}
Fatal("video/vaapi: pixel format %d unsupported by VA-API\n", pix_fmt);
return 0;
}
/**
** Configure VA-API for new video format.
**
** @note called only for software decoder.
*/
static void VaapiSetup(VaapiDecoder * decoder, AVCodecContext * video_ctx)
{
int width;
int height;
VAImageFormat format[1];
// create initial black surface and display
VaapiBlackSurface(decoder);
// cleanup last context
VaapiCleanup(decoder);
width = video_ctx->width;
height = video_ctx->height;
if (decoder->Image->image_id != VA_INVALID_ID) {
if (vaDestroyImage(VaDisplay, decoder->Image->image_id)
!= VA_STATUS_SUCCESS) {
Error("video: can't destroy image!\n");
}
}
VaapiFindImageFormat(decoder, video_ctx->pix_fmt, format);
if (vaCreateImage(VaDisplay, format, width, height,
decoder->Image) != VA_STATUS_SUCCESS) {
Fatal("video: can't create image!\n");
}
Debug(3,
"video/vaapi: created image %dx%d with id 0x%08x and buffer id 0x%08x\n",
width, height, decoder->Image->image_id, decoder->Image->buf);
VaapiCreateSurfaces(decoder, width, height);
#ifdef USE_GLX
if (GlxEnabled) {
// FIXME: destroy old context
GlxSetupDecoder(decoder);
// FIXME: try two textures
if (vaCreateSurfaceGLX(decoder->VaDisplay, GL_TEXTURE_2D,
decoder->GlTexture[0], &decoder->GlxSurface[0])
!= VA_STATUS_SUCCESS) {
Fatal(_("video: can't create glx surfaces"));
}
/*
if (vaCreateSurfaceGLX(decoder->VaDisplay, GL_TEXTURE_2D,
decoder->GlTexture[1], &decoder->GlxSurface[1])
!= VA_STATUS_SUCCESS) {
Fatal(_("video: can't create glx surfaces"));
}
*/
}
#endif
}
///
/// Queue output surface.
///
/// @param decoder VA-API decoder
/// @param surface output surface
/// @param softdec software decoder
///
/// @note we can't mix software and hardware decoder surfaces
///
static void VaapiQueueSurface(VaapiDecoder * decoder, VASurfaceID surface,
int softdec)
{
VASurfaceID old;
++decoder->FrameCounter;
if (1) { // can't wait for output queue empty
if (atomic_read(&decoder->SurfacesFilled) >= VIDEO_SURFACES_MAX) {
++decoder->FramesDropped;
Warning(_("video: output buffer full, dropping frame (%d/%d)\n"),
decoder->FramesDropped, decoder->FrameCounter);
if (!(decoder->FrameCounter % 100)) {
VaapiPrintFrames(decoder);
}
if (softdec) { // software surfaces only
VaapiReleaseSurface(decoder, surface);
}
return;
}
} else { // wait for output queue empty
while (atomic_read(&decoder->SurfacesFilled) >= VIDEO_SURFACES_MAX) {
VideoDisplayHandler();
}
}
//
// Check and release, old surface
//
if ((old = decoder->SurfacesRb[decoder->SurfaceWrite])
!= VA_INVALID_ID) {
if (vaSyncSurface(decoder->VaDisplay, old) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaSyncSurface failed\n"));
}
#if 0
VASurfaceStatus status;
if (vaQuerySurfaceStatus(decoder->VaDisplay, old, &status)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaQuerySurface failed\n"));
status = VASurfaceReady;
}
if (status != VASurfaceReady) {
Warning(_
("video/vaapi: surface %#x not ready: still displayed %d\n"),
old, status);
if (vaSyncSurface(decoder->VaDisplay, old) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaSyncSurface failed\n"));
}
}
#endif
// now we can release the surface
if (softdec) { // software surfaces only
VaapiReleaseSurface(decoder, old);
}
}
#if 0
//
// associate the OSD with surface
//
if (vaAssociateSubpicture(VaDisplay, VaOsdSubpicture, &surface, 1, 0, 0,
VaOsdImage.width, VaOsdImage.height, 0, 0, decoder->InputWidth,
decoder->InputHeight, 0) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't associate subpicture\n"));
}
#endif
decoder->SurfacesRb[decoder->SurfaceWrite] = surface;
decoder->SurfaceWrite = (decoder->SurfaceWrite + 1)
% VIDEO_SURFACES_MAX;
atomic_inc(&decoder->SurfacesFilled);
Debug(4, "video/vaapi: yy video surface %#x ready\n", surface);
}
#if 0
/// Return the absolute value of an integer.
#define ABS(i) ((i) >= 0 ? (i) : (-(i)))
///
/// ELA Edge-based Line Averaging
/// Low-Complexity Interpolation Method
///
/// abcdefg abcdefg abcdefg abcdefg abcdefg
/// x x x x x
/// hijklmn hijklmn hijklmn hijklmn hijklmn
///
static void FilterLine(const uint8_t * past, const uint8_t * cur,
const uint8_t * future, int width, int above, int below)
{
int a, b, c, d, e, f, g, h, i, j, k, l, m, n;
}
#endif
///
/// Create and display a black empty surface.
///
/// @param decoder VA-API decoder
///
static void VaapiBlackSurface(VaapiDecoder * decoder)
{
VAStatus status;
// wait until we have osd subpicture
if (VaOsdSubpicture == VA_INVALID_ID) {
Warning(_("video/vaapi: no osd subpicture yet\n"));
return;
}
if (decoder->BlackSurface == VA_INVALID_ID) {
if (vaCreateSurfaces(decoder->VaDisplay, VideoWindowWidth,
VideoWindowHeight, VA_RT_FORMAT_YUV420, 1,
&decoder->BlackSurface) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't create a surface\n"));
return;
}
}
if (vaAssociateSubpicture(decoder->VaDisplay, VaOsdSubpicture,
&decoder->BlackSurface, 1, 0, 0, VaOsdImage.width,
VaOsdImage.height, 0, 0, VideoWindowWidth, VideoWindowHeight,
0) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't associate subpicture\n"));
}
if (vaSyncSurface(decoder->VaDisplay,
decoder->BlackSurface) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaSyncSurface failed\n"));
}
Debug(4, "video/vaapi: yy black video surface %#x displayed\n",
decoder->BlackSurface);
if ((status =
vaPutSurface(decoder->VaDisplay, decoder->BlackSurface,
decoder->Window,
// decoder src
0, 0, VideoWindowWidth, VideoWindowHeight,
// video dst
0, 0, VideoWindowWidth, VideoWindowHeight, NULL, 0,
VA_FRAME_PICTURE)) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaPutSurface failed %d\n"), status);
}
clock_gettime(CLOCK_REALTIME, &decoder->FrameTime);
if (vaSyncSurface(decoder->VaDisplay,
decoder->BlackSurface) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaSyncSurface failed\n"));
}
usleep(1 * 1000);
}
///
/// Vaapi bob deinterlace.
///
static void VaapiBob(VaapiDecoder * decoder, VAImage * src, VAImage * dst1,
VAImage * dst2)
{
void *src_base;
void *dst1_base;
void *dst2_base;
unsigned y;
unsigned p;
if (vaMapBuffer(decoder->VaDisplay, src->buf,
&src_base) != VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't map the image!\n");
}
if (vaMapBuffer(decoder->VaDisplay, dst1->buf,
&dst1_base) != VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't map the image!\n");
}
if (vaMapBuffer(decoder->VaDisplay, dst2->buf,
&dst2_base) != VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't map the image!\n");
}
if (1) {
memset(dst1_base, 0x00, dst1->data_size);
memset(dst2_base, 0x00, dst2->data_size);
}
for (p = 0; p < src->num_planes; ++p) {
for (y = 0; y < (unsigned)(src->height >> (p != 0)); y += 2) {
memcpy(dst1_base + src->offsets[p] + y * src->pitches[p],
src_base + src->offsets[p] + y * src->pitches[p],
src->pitches[p]);
memcpy(dst1_base + src->offsets[p] + (y + 1) * src->pitches[p],
src_base + src->offsets[p] + y * src->pitches[p],
src->pitches[p]);
memcpy(dst2_base + src->offsets[p] + y * src->pitches[p],
src_base + src->offsets[p] + (y + 1) * src->pitches[p],
src->pitches[p]);
memcpy(dst2_base + src->offsets[p] + (y + 1) * src->pitches[p],
src_base + src->offsets[p] + (y + 1) * src->pitches[p],
src->pitches[p]);
}
}
if (vaUnmapBuffer(decoder->VaDisplay, dst2->buf) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't unmap image buffer\n"));
}
if (vaUnmapBuffer(decoder->VaDisplay, dst1->buf) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't unmap image buffer\n"));
}
if (vaUnmapBuffer(decoder->VaDisplay, src->buf) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't unmap image buffer\n"));
}
}
///
/// Vaapi software deinterlace.
///
static void VaapiCpuDeinterlace(VaapiDecoder * decoder, VASurfaceID surface)
{
#if 0
VAImage image[1];
VAStatus status;
VAImageFormat format[1];
void *image_base;
int image_derived;
// release old frame
// get new frame
// deinterlace
image_derived = 1;
if ((status =
vaDeriveImage(decoder->VaDisplay, surface,
image)) != VA_STATUS_SUCCESS) {
image_derived = 0;
Warning(_("video/vaapi: vaDeriveImage failed %d\n"), status);
// NV12, YV12, I420, BGRA
VaapiFindImageFormat(decoder, PIX_FMT_YUV420P, format);
if (vaCreateImage(decoder->VaDisplay, format, decoder->InputWidth,
decoder->InputHeight, image) != VA_STATUS_SUCCESS) {
Fatal(_("video/vaapi: can't create image!\n"));
}
if (vaGetImage(decoder->VaDisplay, surface, 0, 0, decoder->InputWidth,
decoder->InputHeight, image->image_id) != VA_STATUS_SUCCESS) {
Fatal(_("video/vaapi: can't get image!\n"));
}
}
Debug(3, "video/vaapi: %c%c%c%c %dx%d*%d\n", image->format.fourcc,
image->format.fourcc >> 8, image->format.fourcc >> 16,
image->format.fourcc >> 24, image->width, image->height,
image->num_planes);
if (vaMapBuffer(decoder->VaDisplay, image->buf,
&image_base) != VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't map the image!\n");
}
memset(image_base, 0xff, image->width * image->height);
if (vaUnmapBuffer(decoder->VaDisplay, image->buf) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't unmap image buffer\n"));
}
if (!image_derived) {
if ((status =
vaPutImage(decoder->VaDisplay, surface, image->image_id, 0, 0,
image->width, image->height, 0, 0, image->width,
image->height)) != VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't put image %d!\n", status);
}
}
vaDestroyImage(decoder->VaDisplay, image->image_id);
#endif
VAImage *img1;
VAImage *img2;
VAImage *img3;
VASurfaceID out1;
VASurfaceID out2;
//
// Create deinterlace images.
//
if (decoder->DeintImages[0].image_id == VA_INVALID_ID) {
VAImageFormat format[1];
int i;
// NV12, YV12, I420, BGRA
// VaapiFindImageFormat(decoder, PIX_FMT_YUV420P, format);
// Intel needs NV12
VaapiFindImageFormat(decoder, PIX_FMT_NV12, format);
for (i = 0; i < 3; ++i) {
if (vaCreateImage(decoder->VaDisplay, format, decoder->InputWidth,
decoder->InputHeight,
decoder->DeintImages + i) != VA_STATUS_SUCCESS) {
Fatal(_("video/vaapi: can't create image!\n"));
}
}
img1 = decoder->DeintImages;
Debug(3, "video/vaapi: %c%c%c%c %dx%d*%d\n", img1->format.fourcc,
img1->format.fourcc >> 8, img1->format.fourcc >> 16,
img1->format.fourcc >> 24, img1->width, img1->height,
img1->num_planes);
}
if (vaSyncSurface(decoder->VaDisplay, surface) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaSyncSurface failed\n"));
}
img1 = decoder->DeintImages;
img2 = decoder->DeintImages + 1;
img3 = decoder->DeintImages + 2;
if (vaGetImage(decoder->VaDisplay, surface, 0, 0, decoder->InputWidth,
decoder->InputHeight, img1->image_id) != VA_STATUS_SUCCESS) {
Fatal(_("video/vaapi: can't get img1!\n"));
}
VaapiBob(decoder, img1, img2, img3);
// get a free surface and upload the image
out1 = VaapiGetSurface(decoder);
if (vaPutImage(VaDisplay, out1, img2->image_id, 0, 0, img2->width,
img2->height, 0, 0, img2->width,
img2->height) != VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't put image!\n");
}
VaapiQueueSurface(decoder, out1, 1);
if (vaSyncSurface(decoder->VaDisplay, out1) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaSyncSurface failed\n"));
}
// get a free surface and upload the image
out2 = VaapiGetSurface(decoder);
if (vaPutImage(VaDisplay, out2, img3->image_id, 0, 0, img3->width,
img3->height, 0, 0, img3->width,
img3->height) != VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't put image!\n");
}
VaapiQueueSurface(decoder, out2, 1);
if (vaSyncSurface(decoder->VaDisplay, out2) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaSyncSurface failed\n"));
}
// FIXME: must release software input surface
}
///
/// Render a ffmpeg frame
///
/// @param decoder VA-API decoder
/// @param video_ctx ffmpeg video codec context
/// @param frame frame to display
///
static void VaapiRenderFrame(VaapiDecoder * decoder,
AVCodecContext * video_ctx, AVFrame * frame)
{
VASurfaceID surface;
if (video_ctx->height != decoder->InputHeight
|| video_ctx->width != decoder->InputWidth) {
Debug(3, "video/vaapi: stream <-> surface size mismatch\n");
}
//
// Hardware render
//
if (video_ctx->hwaccel_context) {
int interlaced;
surface = (unsigned)(size_t) frame->data[3];
Debug(4, "video/vaapi: hw render hw surface %#x\n", surface);
// FIXME: some tv-stations toggle interlace on/off
// frame->interlaced_frame isn't always correct set
interlaced = frame->interlaced_frame;
if (video_ctx->height == 720) {
if (interlaced && !decoder->WrongInterlacedWarned) {
Debug(3, "video/vaapi: wrong interlace flag fixed\n");
decoder->WrongInterlacedWarned = 1;
}
interlaced = 0;
} else {
if (!interlaced && !decoder->WrongInterlacedWarned) {
Debug(3, "video/vaapi: wrong interlace flag fixed\n");
decoder->WrongInterlacedWarned = 1;
}
interlaced = 1;
}
// update aspect ratio changes
#ifdef still_to_detect_define
if (av_cmp_q(decoder->InputAspect, frame->sample_aspect_ratio)) {
Debug(3, "video/vaapi: aspect ratio changed\n");
//decoder->InputWidth = video_ctx->width;
//decoder->InputHeight = video_ctx->height;
decoder->InputAspect = frame->sample_aspect_ratio;
VaapiUpdateOutput(decoder);
}
#else
if (av_cmp_q(decoder->InputAspect, frame->sample_aspect_ratio)) {
Debug(3, "video/vaapi: aspect ratio changed\n");
//decoder->InputWidth = video_ctx->width;
//decoder->InputHeight = video_ctx->height;
decoder->InputAspect = frame->sample_aspect_ratio;
VaapiUpdateOutput(decoder);
}
#endif
if (VideoDeinterlace == VideoDeinterlaceSoftware && interlaced) {
// FIXME: software deinterlace avpicture_deinterlace
VaapiCpuDeinterlace(decoder, surface);
} else {
// FIXME: should be done by init
if (decoder->Interlaced != interlaced
|| decoder->TopFieldFirst != frame->top_field_first) {
Debug(3, "video/vaapi: interlaced %d top-field-first %d\n",
interlaced, frame->top_field_first);
decoder->Interlaced = interlaced;
decoder->TopFieldFirst = frame->top_field_first;
}
VaapiQueueSurface(decoder, surface, 0);
}
//
// VAImage render
//
} else {
void *va_image_data;
int i;
AVPicture picture[1];
int width;
int height;
Debug(4, "video/vaapi: hw render sw surface\n");
width = video_ctx->width;
height = video_ctx->height;
//
// Check image, format, size
//
if (decoder->Image->image_id == VA_INVALID_ID
|| decoder->PixFmt != video_ctx->pix_fmt
|| width != decoder->InputWidth
|| height != decoder->InputHeight) {
decoder->PixFmt = video_ctx->pix_fmt;
decoder->InputX = 0;
decoder->InputY = 0;
decoder->InputWidth = width;
decoder->InputHeight = height;
VaapiSetup(decoder, video_ctx);
//
// detect interlaced input
//
Debug(3, "video/vaapi: interlaced %d top-field-first %d\n",
frame->interlaced_frame, frame->top_field_first);
decoder->Interlaced = frame->interlaced_frame;
decoder->TopFieldFirst = frame->top_field_first;
// FIXME: I hope this didn't change in the middle of the stream
}
// FIXME: Need to insert software deinterlace here
//
// Copy data from frame to image
//
if (vaMapBuffer(VaDisplay, decoder->Image->buf, &va_image_data)
!= VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't map the image!\n");
}
for (i = 0; (unsigned)i < decoder->Image->num_planes; ++i) {
picture->data[i] = va_image_data + decoder->Image->offsets[i];
picture->linesize[i] = decoder->Image->pitches[i];
}
av_picture_copy(picture, (AVPicture *) frame, video_ctx->pix_fmt,
width, height);
if (vaUnmapBuffer(VaDisplay, decoder->Image->buf) != VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't unmap the image!\n");
}
// get a free surface and upload the image
surface = VaapiGetSurface(decoder);
// FIXME: intel didn't support put image.
if ((i = vaPutImage(VaDisplay, surface, decoder->Image->image_id, 0, 0,
width, height, 0, 0, width, height)
) != VA_STATUS_SUCCESS) {
Fatal("video/vaapi: can't put image %d!\n", i);
}
VaapiQueueSurface(decoder, surface, 1);
}
if (decoder->Interlaced) {
++decoder->FrameCounter;
}
}
/**
** Video render frame.
**
** FIXME: no locks for multi-thread
** FIXME: frame delay for 50hz hardcoded
**
*/
void VaapiDisplayFrame(void)
{
uint32_t start;
uint32_t sync;
uint32_t put1;
uint32_t put2;
int i;
VaapiDecoder *decoder;
VASurfaceID surface;
// look if any stream have a new surface available
for (i = 0; i < VaapiDecoderN; ++i) {
int filled;
decoder = VaapiDecoders[i];
filled = atomic_read(&decoder->SurfacesFilled);
if (filled) {
// show any frame as fast as possible
// we keep always the last frame in the ring buffer
if (filled > 1) {
decoder->SurfaceRead = (decoder->SurfaceRead + 1)
% VIDEO_SURFACES_MAX;
atomic_dec(&decoder->SurfacesFilled);
}
start = GetMsTicks();
surface = decoder->SurfacesRb[decoder->SurfaceRead];
Debug(4, "video/vaapi: yy video surface %#x displayed\n", surface);
if (vaSyncSurface(decoder->VaDisplay, surface)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: vaSyncSurface failed\n"));
}
sync = GetMsTicks();
VaapiPutSurfaceX11(decoder, surface, decoder->Interlaced,
decoder->TopFieldFirst, 0);
put1 = GetMsTicks();
put2 = put1;
// deinterlace and full frame rate
if (decoder->Interlaced) {
VaapiPutSurfaceX11(decoder, surface, decoder->Interlaced,
decoder->TopFieldFirst, 1);
// FIXME: buggy libva-driver-vdpau.
if (VaapiBuggyVdpau
&& VideoDeinterlace != VideoDeinterlaceWeave) {
VaapiPutSurfaceX11(decoder, surface, decoder->Interlaced,
decoder->TopFieldFirst, 0);
VaapiPutSurfaceX11(decoder, surface, decoder->Interlaced,
decoder->TopFieldFirst, 1);
}
put2 = GetMsTicks();
}
xcb_flush(Connection);
Debug(4, "video/vaapi: sync %2u put1 %2u put2 %2u\n", sync - start,
put1 - sync, put2 - put1);
clock_gettime(CLOCK_REALTIME, &decoder->FrameTime);
} else {
Debug(3, "video/vaapi: no video surface ready\n");
}
}
}
/**
** Clear subpicture image.
**
** @note it is possible, that we need a lock here
*/
static void VaapiOsdClear(void)
{
void *image_buffer;
// osd image available?
if (VaOsdImage.image_id == VA_INVALID_ID) {
return;
}
Debug(3, "video/vaapi: clear image\n");
// map osd surface/image into memory.
if (vaMapBuffer(VaDisplay, VaOsdImage.buf, &image_buffer)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't map osd image buffer\n"));
return;
}
// 100% transparent
memset(image_buffer, 0x00, VaOsdImage.data_size);
if (vaUnmapBuffer(VaDisplay, VaOsdImage.buf) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't unmap osd image buffer\n"));
}
}
/**
** Upload ARGB to subpicture image.
**
** @note it is possible, that we need a lock here
*/
static void VaapiUploadImage(int x, int y, int width, int height,
const uint8_t * argb)
{
void *image_buffer;
int o;
// osd image available?
if (VaOsdImage.image_id == VA_INVALID_ID) {
return;
}
Debug(3, "video/vaapi: upload image\n");
// map osd surface/image into memory.
if (vaMapBuffer(VaDisplay, VaOsdImage.buf, &image_buffer)
!= VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't map osd image buffer\n"));
return;
}
// 100% transparent
//memset(image_buffer, 0x00, VaOsdImage.data_size);
// FIXME: convert image from ARGB to subpicture format, if not argb
// copy argb to image
for (o = 0; o < height; ++o) {
memcpy(image_buffer + (x + (y + o) * VaOsdImage.width) * 4,
argb + o * width * 4, width * 4);
}
if (vaUnmapBuffer(VaDisplay, VaOsdImage.buf) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't unmap osd image buffer\n"));
}
}
/**
** VA-API initialize OSD.
**
** Subpicture is unusable, its scaled with the video image.
*/
static void VaapiOsdInit(int width, int height)
{
VAImageFormat *formats;
unsigned *flags;
unsigned format_n;
unsigned u;
unsigned v;
static uint32_t wanted_formats[] =
{ VA_FOURCC('B', 'G', 'R', 'A'), VA_FOURCC_RGBA };
if (VaOsdImage.image_id != VA_INVALID_ID) {
Debug(3, "video/vaapi: osd already setup\n");
return;
}
if (!VaDisplay) {
Debug(3, "video/vaapi: va-api not setup\n");
return;
}
//
// look through subpicture formats
//
format_n = vaMaxNumSubpictureFormats(VaDisplay);
formats = alloca(format_n * sizeof(*formats));
flags = alloca(format_n * sizeof(*formats));
if (vaQuerySubpictureFormats(VaDisplay, formats, flags,
&format_n) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't get subpicture formats"));
return;
}
#ifdef DEBUG
Debug(3, "video/vaapi: supported subpicture formats:\n");
for (u = 0; u < format_n; ++u) {
Debug(3, "video/vaapi:\t%c%c%c%c flags %#x %s\n", formats[u].fourcc,
formats[u].fourcc >> 8, formats[u].fourcc >> 16,
formats[u].fourcc >> 24, flags[u],
flags[u] & VA_SUBPICTURE_DESTINATION_IS_SCREEN_COORD ?
"screen coord" : "");
}
#endif
for (v = 0; v < sizeof(wanted_formats) / sizeof(*wanted_formats); ++v) {
for (u = 0; u < format_n; ++u) {
if (formats[u].fourcc == wanted_formats[v]) {
goto found;
}
}
}
Error(_("video/vaapi: can't find a supported subpicture format"));
return;
found:
Debug(3, "video/vaapi: use %c%c%c%c subpicture format with flags %#x\n",
formats[u].fourcc, formats[u].fourcc >> 8, formats[u].fourcc >> 16,
formats[u].fourcc >> 24, flags[u]);
VaapiUnscaledOsd = 0;
if (flags[u] & VA_SUBPICTURE_DESTINATION_IS_SCREEN_COORD) {
Info(_("video/vaapi: vaapi supports unscaled osd\n"));
VaapiUnscaledOsd = 1;
}
// FIXME:
VaapiUnscaledOsd = 0;
Info(_("video/vaapi: unscaled osd disabled\n"));
if (vaCreateImage(VaDisplay, &formats[u], width, height,
&VaOsdImage) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't create osd image\n"));
return;
}
if (vaCreateSubpicture(VaDisplay, VaOsdImage.image_id,
&VaOsdSubpicture) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't create subpicture\n"));
return;
}
// FIXME: must store format, to convert ARGB to it.
VaapiOsdClear();
}
#endif
//----------------------------------------------------------------------------
// OSD
//----------------------------------------------------------------------------
//static int OsdShow; ///< flag show osd
static int OsdWidth; ///< osd width
static int OsdHeight; ///< osd height
/**
** Clear the OSD.
**
** @todo I use glTexImage2D to clear the texture, are there faster and
** better ways to clear a texture?
*/
void VideoOsdClear(void)
{
VideoThreadLock();
#ifdef USE_GLX
if (GlxEnabled) {
void *texbuf;
texbuf = calloc(OsdWidth * OsdHeight, 4);
glEnable(GL_TEXTURE_2D); // 2d texture
glBindTexture(GL_TEXTURE_2D, OsdGlTextures[OsdIndex]);
// upload no image data, clears texture (on some drivers only)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, OsdWidth, OsdHeight, 0,
GL_BGRA, GL_UNSIGNED_BYTE, texbuf);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
GlxCheck();
free(texbuf);
}
#endif
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
VaapiOsdClear();
VideoThreadUnlock();
return;
}
#endif
VideoThreadUnlock();
}
/**
** Draw an OSD ARGB image.
*/
void VideoOsdDrawARGB(int x, int y, int height, int width,
const uint8_t * argb)
{
VideoThreadLock();
#ifdef USE_GLX
if (GlxEnabled) {
Debug(3, "video: %p <-> %p\n", glXGetCurrentContext(), GlxContext);
GlxUploadTexture(x, y, height, width, argb);
VideoThreadUnlock();
return;
}
#endif
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
VaapiUploadImage(x, y, height, width, argb);
VideoThreadUnlock();
return;
}
#endif
(void)x;
(void)y;
(void)height;
(void)width;
(void)argb;
VideoThreadUnlock();
}
/**
** Setup osd.
**
** FIXME: looking for BGRA, but this fourcc isn't supported by the
** drawing functions yet.
*/
void VideoOsdInit(void)
{
OsdWidth = 1920 / 1;
OsdHeight = 1080 / 1; // worst-case
//OsdWidth = 768;
//OsdHeight = VideoWindowHeight; // FIXME: must be configured
#ifdef USE_GLX
// FIXME: make an extra function for this
if (GlxEnabled) {
int i;
Debug(3, "video/glx: %p <-> %p\n", glXGetCurrentContext(), GlxContext);
//
// create a RGBA texture.
//
glEnable(GL_TEXTURE_2D); // create 2d texture(s)
glGenTextures(2, OsdGlTextures);
for (i = 0; i < 2; ++i) {
glBindTexture(GL_TEXTURE_2D, OsdGlTextures[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, OsdWidth, OsdHeight, 0,
GL_BGRA, GL_UNSIGNED_BYTE, NULL);
}
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
return;
}
#endif
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
VaapiOsdInit(OsdWidth, OsdHeight);
return;
}
#endif
}
#if 0
//----------------------------------------------------------------------------
// Overlay
//----------------------------------------------------------------------------
/**
** Render osd surface.
*/
void VideoRenderOverlay(void)
{
#ifdef USE_GLX
if (GlxEnabled) {
GlxRender(OsdWidth, OsdHeight);
} else
#endif
{
}
}
/**
** Display overlay surface.
*/
void VideoDisplayOverlay(void)
{
#ifdef USE_GLX
if (GlxEnabled) {
int osd_x1;
int osd_y1;
osd_x1 = 0;
osd_y1 = 0;
#ifdef noDEBUG
osd_x1 = 100;
osd_y1 = 100;
#endif
GlxRenderTexture(OsdGlTextures[OsdIndex], osd_x1, osd_y1,
VideoWindowWidth, VideoWindowHeight);
return;
}
#endif
#ifdef USE_VAAPI
{
void *image_buffer;
static int counter;
// upload needs long time
if (counter == 5) {
//return;
}
// osd image available?
if (VaOsdImage.image_id == VA_INVALID_ID) {
return;
}
// FIXME: this version hangups
//return;
// map osd surface/image into memory.
if (vaMapBuffer(VaDisplay, VaOsdImage.buf,
&image_buffer) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't map osd image buffer\n"));
return;
}
// 100% transparent
memset(image_buffer, 0x80 | counter++, VaOsdImage.data_size);
// convert internal osd to VA-API image
//GfxConvert(image_buffer, VaOsdImage.offsets[0], VaOsdImage.pitches[0]);
if (vaUnmapBuffer(VaDisplay, VaOsdImage.buf) != VA_STATUS_SUCCESS) {
Error(_("video/vaapi: can't unmap osd image buffer\n"));
}
}
#endif
}
#endif
//----------------------------------------------------------------------------
// Frame
//----------------------------------------------------------------------------
/**
** Display a single frame.
*/
static void VideoDisplayFrame(void)
{
#ifdef USE_GLX
if (GlxEnabled) {
VideoDisplayOverlay();
#ifdef USE_DOUBLEBUFFER
glXSwapBuffers(XlibDisplay, VideoWindow);
#else
glFinish(); // wait for all execution finished
#endif
GlxCheck();
glClear(GL_COLOR_BUFFER_BIT);
}
#endif
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
VaapiDisplayFrame();
return;
}
#endif
#ifdef USE_VDPAU
if (VideoVdpauEnabled) {
return;
}
#endif
}
//----------------------------------------------------------------------------
// Events
//----------------------------------------------------------------------------
/// C callback feed key press
extern void FeedKeyPress(const char *, const char *, int, int);
/**
** Handle X11 events.
**
** @todo Signal WmDeleteMessage to application.
*/
static void VideoEvent(void)
{
XEvent event;
KeySym keysym;
//char buf[32];
XNextEvent(XlibDisplay, &event);
switch (event.type) {
case ClientMessage:
Debug(3, "video/event: ClientMessage\n");
if (event.xclient.data.l[0] == (long)WmDeleteWindowAtom) {
// FIXME: wrong, kills recordings ...
Error(_("video: FIXME: wm-delete-message\n"));
}
break;
case MapNotify:
Debug(3, "video/event: MapNotify\n");
break;
case Expose:
Debug(3, "video/event: Expose\n");
break;
case ReparentNotify:
Debug(3, "video/event: ReparentNotify\n");
break;
case ConfigureNotify:
Debug(3, "video/event: ConfigureNotify\n");
break;
case KeyPress:
keysym = XLookupKeysym(&event.xkey, 0);
if (keysym == NoSymbol) {
Warning(_("video: No symbol for %d\n"), event.xkey.keycode);
}
FeedKeyPress("XKeySym", XKeysymToString(keysym), 0, 0);
/*
if (XLookupString(&event.xkey, buf, sizeof(buf), &keysym, NULL)) {
FeedKeyPress("XKeySym", buf, 0, 0);
} else {
FeedKeyPress("XKeySym", XKeysymToString(keysym), 0, 0);
}
*/
case KeyRelease:
break;
default:
#if 0
if (XShmGetEventBase(XlibDisplay) + ShmCompletion == event.type) {
// printf("ShmCompletion\n");
}
#endif
Debug(3, "Unsupported event type %d\n", event.type);
break;
}
}
/**
** Poll all x11 events.
*/
void VideoPollEvent(void)
{
while (XPending(XlibDisplay)) {
VideoEvent();
}
}
//----------------------------------------------------------------------------
// Thread
//----------------------------------------------------------------------------
#ifdef USE_VIDEO_THREAD
static pthread_t VideoThread; ///< video decode thread
static pthread_cond_t VideoWakeupCond; ///< wakeup condition variable
static pthread_mutex_t VideoMutex; ///< video condition mutex
static pthread_mutex_t VideoLockMutex; ///< video lock mutex
#ifdef USE_GLX
static GLXContext GlxThreadContext; ///< our gl context for the thread
#endif
/**
** Lock video thread.
*/
static void VideoThreadLock(void)
{
if (pthread_mutex_lock(&VideoLockMutex)) {
Error(_("video: can't lock thread\n"));
}
}
/**
** Unlock video thread.
*/
static void VideoThreadUnlock(void)
{
if (pthread_mutex_unlock(&VideoLockMutex)) {
Error(_("video: can't unlock thread\n"));
}
}
/**
** Video render thread.
*/
static void *VideoDisplayHandlerThread(void *dummy)
{
Debug(3, "video: display thread started\n");
#ifdef USE_GLX
if (GlxEnabled) {
Debug(3, "video: %p <-> %p\n", glXGetCurrentContext(),
GlxThreadContext);
GlxThreadContext =
glXCreateContext(XlibDisplay, GlxVisualInfo, GlxContext, GL_TRUE);
if (!GlxThreadContext) {
Error(_("video/glx: can't create glx context\n"));
return NULL;
}
// set glx context
if (!glXMakeCurrent(XlibDisplay, VideoWindow, GlxThreadContext)) {
GlxCheck();
Error(_("video/glx: can't make glx context current\n"));
return NULL;
}
}
#endif
for (;;) {
int err;
int filled;
struct timespec nowtime;
struct timespec abstime;
VaapiDecoder *decoder;
uint64_t delay;
decoder = VaapiDecoders[0];
VideoPollEvent();
// initial delay
delay = AudioGetDelay();
if (delay < 100 * 90) { // no audio delay known
delay = 760 * 1000 * 1000;
} else {
delay = (delay * 1000 * 1000) / 90 + 60 * 1000 * 1000;
}
clock_gettime(CLOCK_REALTIME, &nowtime);
if (!atomic_read(&decoder->SurfacesFilled)
|| (uint64_t) ((nowtime.tv_sec - decoder->StartTime.tv_sec)
* 1000 * 1000 * 1000 + (nowtime.tv_nsec -
decoder->StartTime.tv_nsec)) > delay) {
if ((nowtime.tv_sec - decoder->StartTime.tv_sec)
* 1000 * 1000 * 1000 + (nowtime.tv_nsec -
decoder->StartTime.tv_nsec)
< 2000 * 1000 * 1000) {
Debug(3, "video: audio delay %lu ms\n", delay / (1000 * 1000));
}
// FIXME: hot polling
pthread_mutex_lock(&VideoLockMutex);
// fetch or reopen
err = VideoDecode();
pthread_mutex_unlock(&VideoLockMutex);
if (err) {
// FIXME: sleep on wakeup
usleep(5 * 1000); // nothing buffered
}
} else {
Debug(3, "video/vaapi: waiting %9lu ms\n",
((nowtime.tv_sec - decoder->StartTime.tv_sec)
* 1000 * 1000 * 1000 + (nowtime.tv_nsec -
decoder->StartTime.tv_nsec)) / (1000 * 1000));
abstime = nowtime;
abstime.tv_nsec += 18 * 1000 * 1000;
if (abstime.tv_nsec >= 1000 * 1000 * 1000) {
// avoid overflow
abstime.tv_sec++;
abstime.tv_nsec -= 1000 * 1000 * 1000;
}
pthread_mutex_lock(&VideoLockMutex);
// give osd some time slot
while (pthread_cond_timedwait(&VideoWakeupCond, &VideoLockMutex,
&abstime) != ETIMEDOUT) {
// SIGUSR1
Debug(3, "video/vaapi: pthread_cond_timedwait error\n");
}
pthread_mutex_unlock(&VideoLockMutex);
}
clock_gettime(CLOCK_REALTIME, &nowtime);
// time for one frame over, buggy for vaapi-vdpau
if ((nowtime.tv_sec - decoder->FrameTime.tv_sec) * 1000 * 1000 * 1000 +
(nowtime.tv_nsec - decoder->FrameTime.tv_nsec) <
(decoder->Interlaced ? 17 : 17) * 1000 * 1000) {
continue;
}
filled = atomic_read(&decoder->SurfacesFilled);
if (!filled) {
pthread_mutex_lock(&VideoLockMutex);
VaapiBlackSurface(decoder);
pthread_mutex_unlock(&VideoLockMutex);
} else if (filled == 1) {
decoder->FramesDuped++;
++decoder->FrameCounter;
if (!(decoder->FrameCounter % 333)) {
Warning(_
("video: display buffer empty, duping frame (%d/%d)\n"),
decoder->FramesDuped, decoder->FrameCounter);
VaapiPrintFrames(decoder);
}
}
if (filled) {
pthread_mutex_lock(&VideoLockMutex);
VideoDisplayFrame();
pthread_mutex_unlock(&VideoLockMutex);
}
}
#if 0
for (;;) {
int err;
int filled;
struct timespec nowtime;
struct timespec abstime;
VaapiDecoder *decoder;
clock_gettime(CLOCK_REALTIME, &abstime);
VideoPollEvent();
// fill surface buffer
for (;;) {
static int max_filled;
uint32_t delay;
clock_gettime(CLOCK_REALTIME, &nowtime);
// time to receive and decode over
if ((nowtime.tv_sec - abstime.tv_sec) * 1000 * 1000 * 1000 +
(nowtime.tv_nsec - abstime.tv_nsec) >
(decoder->Interlaced + 1) * 15 * 1000 * 1000) {
break;
}
delay = 700 * 1000 * 1000;
// initial delay get decode only 1 frame
if ((nowtime.tv_sec - decoder->StartTime.tv_sec)
* 1000 * 1000 * 1000 + (nowtime.tv_nsec -
decoder->StartTime.tv_nsec) < delay) {
Debug(3, "video/vaapi: waiting %9lu ms\n",
((nowtime.tv_sec - decoder->StartTime.tv_sec)
* 1000 * 1000 * 1000 + (nowtime.tv_nsec -
decoder->StartTime.tv_nsec)) / (1000 * 1000));
if (atomic_read(&decoder->SurfacesFilled)) {
break;
}
}
if (atomic_read(&decoder->SurfacesFilled) >= 3) {
break;
}
// FIXME: hot polling
pthread_mutex_lock(&VideoLockMutex);
err = VideoDecode();
pthread_mutex_unlock(&VideoLockMutex);
if (atomic_read(&decoder->SurfacesFilled) > 3) {
Debug(3, "video: %d filled\n",
atomic_read(&decoder->SurfacesFilled));
if (atomic_read(&decoder->SurfacesFilled) > max_filled) {
max_filled = atomic_read(&decoder->SurfacesFilled);
}
}
if (err) {
usleep(1 * 1000); // nothing buffered
}
}
// wait up to 20ms
// FIXME: 50hz video frame rate hardcoded
abstime.tv_nsec += (decoder->Interlaced + 1) * 16 * 1000 * 1000;
if (abstime.tv_nsec >= 1000 * 1000 * 1000) {
// avoid overflow
abstime.tv_sec++;
abstime.tv_nsec -= 1000 * 1000 * 1000;
}
pthread_mutex_lock(&VideoMutex);
while ((err =
pthread_cond_timedwait(&VideoWakeupCond, &VideoMutex,
&abstime)) != ETIMEDOUT) {
Debug(3, "video/vaapi: pthread_cond_timedwait timeout\n");
}
pthread_mutex_unlock(&VideoMutex);
if (err != ETIMEDOUT) {
Debug(3, "video/vaapi: pthread_cond_timedwait failed: %d\n", err);
}
#ifdef USE_GLX
//printf("video %p <-> %p\n", glXGetCurrentContext(), GlxThreadContext);
if (!glXMakeCurrent(XlibDisplay, VideoWindow, GlxThreadContext)) {
GlxCheck();
Error(_("video/glx: can't make glx context current\n"));
return NULL;
}
#endif
filled = atomic_read(&decoder->SurfacesFilled);
if (!filled) {
pthread_mutex_lock(&VideoLockMutex);
VaapiBlackSurface(decoder);
pthread_mutex_unlock(&VideoLockMutex);
} else if (filled == 1) {
decoder->FramesDuped++;
++decoder->FrameCounter;
Warning(_("video: display buffer empty, duping frame (%d/%d)\n"),
decoder->FramesDuped, decoder->FrameCounter);
if (!(decoder->FrameCounter % 333)) {
VaapiPrintFrames(decoder);
}
}
if (filled) {
pthread_mutex_lock(&VideoLockMutex);
VideoDisplayFrame();
pthread_mutex_unlock(&VideoLockMutex);
}
if (0) {
clock_gettime(CLOCK_REALTIME, &nowtime);
Debug(3, "video/vaapi: ticks %9lu ms\n",
((nowtime.tv_sec - abstime.tv_sec) * 1000 * 1000 * 1000 +
(nowtime.tv_nsec - abstime.tv_nsec)) / (1000 * 1000));
}
}
#endif
return dummy;
}
/**
** Video render.
*/
void VideoDisplayHandler(void)
{
if (!XlibDisplay) { // not yet started
return;
}
#ifdef USE_GLX
glFinish(); // wait for all execution finished
Debug(3, "video: %p <-> %p\n", glXGetCurrentContext(), GlxContext);
#endif
if (!VideoThread) {
#ifdef USE_GLX
if (GlxEnabled) { // other thread renders
// glXMakeCurrent(XlibDisplay, None, NULL);
}
#endif
pthread_mutex_init(&VideoMutex, NULL);
pthread_mutex_init(&VideoLockMutex, NULL);
pthread_cond_init(&VideoWakeupCond, NULL);
pthread_create(&VideoThread, NULL, VideoDisplayHandlerThread, NULL);
//pthread_detach(VideoThread);
}
}
/**
** Exit and cleanup video threads.
*/
static void VideoThreadExit(void)
{
void *retval;
if (VideoThread) {
if (pthread_cancel(VideoThread)) {
Error(_("video: can't cancel video display thread\n"));
}
if (pthread_join(VideoThread, &retval) || retval != PTHREAD_CANCELED) {
Error(_("video: can't cancel video display thread\n"));
}
pthread_cond_destroy(&VideoWakeupCond);
pthread_mutex_destroy(&VideoLockMutex);
pthread_mutex_destroy(&VideoMutex);
}
}
#endif
//----------------------------------------------------------------------------
// Video API
//----------------------------------------------------------------------------
///
/// Video hardware decoder
///
struct _video_hw_decoder_
{
union
{
#ifdef USE_VAAPI
VaapiDecoder Vaapi; ///< VA-API decoder structure
#endif
#ifdef USE_VDPAU
VdpauDecoder Vdpau; ///< vdpau decoder structure
#endif
};
};
///
/// Allocate new video hw decoder.
///
VideoHwDecoder *VideoNewHwDecoder(void)
{
if (!XlibDisplay) { // waiting for x11 start
return NULL;
}
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
return (VideoHwDecoder *) VaapiNewDecoder();
}
#endif
#ifdef USE_VDPAU
if (VideoVdpauEnabled) {
return (VideoHwDecoder *) VdpauNewDecoder();
}
#endif
return NULL;
}
///
/// Get a free hardware decoder surface.
///
/// @param decoder video hardware decoder
///
unsigned VideoGetSurface(VideoHwDecoder * decoder)
{
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
return VaapiGetSurface(&decoder->Vaapi);
}
#endif
#ifdef USE_VDPAU
if (VideoVdpauEnabled) {
return VdpauGetSurface(&decoder->Vdpau);
}
#endif
return -1;
}
///
/// Release a hardware decoder surface.
///
/// @param decoder video hardware decoder
/// @param surface surface no longer used
///
void VideoReleaseSurface(VideoHwDecoder * decoder, unsigned surface)
{
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
VaapiReleaseSurface(&decoder->Vaapi, surface);
return;
}
#endif
#ifdef USE_VDPAU
if (VideoVdpauEnabled) {
return VdpauReleaseSurface(&decoder->Vdpau, surface);
}
#endif
}
///
/// Callback to negotiate the PixelFormat.
///
/// @param fmt is the list of formats which are supported by the codec,
/// it is terminated by -1 as 0 is a valid format, the
/// formats are ordered by quality.
///
enum PixelFormat Video_get_format(VideoHwDecoder * decoder,
AVCodecContext * video_ctx, const enum PixelFormat *fmt)
{
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
return Vaapi_get_format(&decoder->Vaapi, video_ctx, fmt);
}
#endif
#ifdef USE_VDPAU
if (VideoVdpauEnabled) {
return Vdpau_get_format(&decoder->Vdpau, video_ctx, fmt);
}
#endif
return fmt[0];
}
/**
** Test
*/
void VaapiTest(void)
{
static int state;
static uint32_t clock;
static uint32_t last_tick;
int i;
//XLockDisplay(XlibDisplay);
VideoPollEvent();
for (i = 0; i < VaapiDecoderN; ++i) {
int filled;
VaapiDecoder *decoder;
uint32_t start;
uint32_t end;
decoder = VaapiDecoders[i];
filled = atomic_read(&decoder->SurfacesFilled);
if (!filled) { // trick to reset for new streams
state = 0;
}
switch (state) {
case 0:
// new stream, wait until enough frames are buffered
Debug(3, "video/state: wait on full\n");
if (filled == 1) {
VaapiDisplayFrame();
}
if (filled < VIDEO_SURFACES_MAX - 1) {
continue;
}
state++;
case 1:
// we have enough frames buffered, fill driver buffer
Debug(3, "video/state: ringbuffer full\n");
// intel has 0 buffers
//VaapiDisplayFrame();
state++;
case 2:
// normal run, just play a buffered frame
start = GetMsTicks();
// intel 20ms / 40ms
VaapiDisplayFrame();
end = GetMsTicks();
last_tick = end;
if (start + (decoder->Interlaced + 1) * 20 < end) {
Debug(3, "video/state: display %u ms\n", end - start);
}
clock += (decoder->Interlaced + 1) * 20;
if (last_tick < clock - 1000) {
clock = last_tick;
}
if (last_tick > clock + 1000) {
clock = last_tick;
}
//Debug(3, "video/state: %+4d ms\n", clock - last_tick);
break;
}
}
//XUnlockDisplay(XlibDisplay);
}
///
/// Display a ffmpeg frame
///
/// @param decoder video hardware decoder
/// @param video_ctx ffmpeg video codec context
/// @param frame frame to display
///
void VideoRenderFrame(VideoHwDecoder * decoder, AVCodecContext * video_ctx,
AVFrame * frame)
{
if (!atomic_read(&decoder->Vaapi.SurfacesFilled)) {
Debug(3, "video: new stream frame %d\n", GetMsTicks() - VideoSwitch);
}
// if video output buffer is full, wait and display surface.
if (atomic_read(&decoder->Vaapi.SurfacesFilled) >= VIDEO_SURFACES_MAX) {
struct timespec abstime;
abstime = decoder->Vaapi.FrameTime;
abstime.tv_nsec += 16 * 1000 * 1000;
if (abstime.tv_nsec >= 1000 * 1000 * 1000) {
// avoid overflow
abstime.tv_sec++;
abstime.tv_nsec -= 1000 * 1000 * 1000;
}
VideoPollEvent();
// give osd some time slot
while (pthread_cond_timedwait(&VideoWakeupCond, &VideoLockMutex,
&abstime) != ETIMEDOUT) {
// SIGUSR1
Debug(3, "video/vaapi: pthread_cond_timedwait error\n");
}
VideoDisplayFrame();
}
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
VaapiRenderFrame(&decoder->Vaapi, video_ctx, frame);
return;
}
#endif
#ifdef USE_VDPAU
if (VideoVdpauEnabled) {
VdpauRenderFrame(&decoder->Vdpau, video_ctx, frame);
return;
}
#endif
(void)decoder;
(void)video_ctx;
(void)frame;
//Error(_("video: unsupported %p %p %p\n"), decoder, video_ctx, frame);
}
///
/// Get VA-API ffmpeg context
///
/// @param decoder VA-API decoder
///
struct vaapi_context *VideoGetVaapiContext(VideoHwDecoder * decoder)
{
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
return decoder->Vaapi.VaapiContext;
}
#endif
Error(_("video/vaapi: get vaapi context, without vaapi enabled\n"));
return NULL;
}
#ifndef USE_VIDEO_THREAD
/**
** Video render.
*/
void VideoDisplayHandler(void)
{
uint32_t now;
if (!XlibDisplay) { // not yet started
return;
}
now = GetMsTicks();
if (now < VaapiDecoders[0]->LastFrameTick) {
return;
}
if (now - VaapiDecoders[0]->LastFrameTick < 500) {
return;
}
VideoPollEvent();
VaapiBlackSurface(VaapiDecoders[0]);
return;
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
VaapiDisplayFrame();
return;
}
#endif
#ifdef USE_VDPAU
if (VideoVdpauEnabled) {
return;
}
#endif
VideoDisplayFrame();
}
#endif
//----------------------------------------------------------------------------
// Setup
//----------------------------------------------------------------------------
/**
** Create main window.
*/
static void VideoCreateWindow(xcb_window_t parent, xcb_visualid_t visual,
uint8_t depth)
{
uint32_t values[4];
xcb_intern_atom_reply_t *reply;
Debug(3, "video: visual %#0x depth %d\n", visual, depth);
// Color map
VideoColormap = xcb_generate_id(Connection);
xcb_create_colormap(Connection, XCB_COLORMAP_ALLOC_NONE, VideoColormap,
parent, visual);
values[0] = 0;
values[1] = 0;
values[2] =
XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |
XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE |
XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY;
values[3] = VideoColormap;
VideoWindow = xcb_generate_id(Connection);
xcb_create_window(Connection, depth, VideoWindow, parent, VideoWindowX,
VideoWindowY, VideoWindowWidth, VideoWindowHeight, 0,
XCB_WINDOW_CLASS_INPUT_OUTPUT, visual,
XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_EVENT_MASK |
XCB_CW_COLORMAP, values);
// FIXME: utf _NET_WM_NAME
xcb_icccm_set_wm_name(Connection, VideoWindow, XCB_ATOM_STRING, 8,
sizeof("softhddevice") - 1, "softhddevice");
xcb_icccm_set_wm_icon_name(Connection, VideoWindow, XCB_ATOM_STRING, 8,
sizeof("softhddevice") - 1, "softhddevice");
// FIXME: size hints
// register interest in the delete window message
if ((reply =
xcb_intern_atom_reply(Connection, xcb_intern_atom(Connection, 0,
sizeof("WM_DELETE_WINDOW") - 1, "WM_DELETE_WINDOW"),
NULL))) {
WmDeleteWindowAtom = reply->atom;
free(reply);
if ((reply =
xcb_intern_atom_reply(Connection, xcb_intern_atom(Connection,
0, sizeof("WM_PROTOCOLS") - 1, "WM_PROTOCOLS"),
NULL))) {
xcb_icccm_set_wm_protocols(Connection, VideoWindow, reply->atom, 1,
&WmDeleteWindowAtom);
free(reply);
}
}
values[0] = XCB_NONE;
xcb_change_window_attributes(Connection, VideoWindow, XCB_CW_CURSOR,
values);
xcb_map_window(Connection, VideoWindow);
}
/**
** Set video geometry.
**
** @param geometry [=][<width>{xX}<height>][{+-}<xoffset>{+-}<yoffset>]
*/
int VideoSetGeometry(const char *geometry)
{
int flags;
flags =
XParseGeometry(geometry, &VideoWindowX, &VideoWindowY,
&VideoWindowWidth, &VideoWindowHeight);
return 0;
}
/**
** Initialize video output module.
**
** @param display_name X11 display name
*/
void VideoInit(const char *display_name)
{
int screen_nr;
int i;
xcb_screen_iterator_t screen_iter;
xcb_screen_t *screen;
if (XlibDisplay) { // allow multiple calls
Debug(3, "video: x11 already setup\n");
return;
}
// Open the connection to the X server.
// use the DISPLAY environment variable as the default display name
if (!display_name) {
display_name = getenv("DISPLAY");
if (!display_name) {
// use :0.0 as default display name
display_name = ":0.0";
}
}
if (!(XlibDisplay = XOpenDisplay(display_name))) {
Fatal(_("video: Can't connect to X11 server on '%s'"), display_name);
// FIXME: we need to retry connection
}
XInitThreads();
// Convert XLIB display to XCB connection
if (!(Connection = XGetXCBConnection(XlibDisplay))) {
Fatal(_("video: Can't convert XLIB display to XCB connection"));
}
// prefetch extensions
//xcb_prefetch_extension_data(Connection, &xcb_big_requests_id);
//xcb_prefetch_extension_data(Connection, &xcb_dpms_id);
//xcb_prefetch_extension_data(Connection, &xcb_glx_id);
//xcb_prefetch_extension_data(Connection, &xcb_randr_id);
//xcb_prefetch_extension_data(Connection, &xcb_screensaver_id);
//xcb_prefetch_extension_data(Connection, &xcb_shm_id);
//xcb_prefetch_extension_data(Connection, &xcb_xv_id);
// Get the requested screen number
screen_nr = DefaultScreen(XlibDisplay);
screen_iter = xcb_setup_roots_iterator(xcb_get_setup(Connection));
for (i = 0; i < screen_nr; ++i) {
xcb_screen_next(&screen_iter);
}
screen = screen_iter.data;
//
// Default window size
//
if (!VideoWindowHeight) {
if (VideoWindowWidth) {
VideoWindowHeight = (VideoWindowWidth * 9) / 16;
}
VideoWindowHeight = 576;
}
if (!VideoWindowWidth) {
VideoWindowWidth = (VideoWindowHeight * 16) / 9;
}
//
// prepare opengl
//
#ifdef USE_GLX
if (GlxEnabled) {
GlxInit();
// FIXME: use root window?
VideoCreateWindow(screen->root, GlxVisualInfo->visualid,
GlxVisualInfo->depth);
GlxSetupWindow(VideoWindow, VideoWindowWidth, VideoWindowHeight);
} else
#endif
//
// Create output window
//
if (1) { // FIXME: use window mode
VideoCreateWindow(screen->root, screen->root_visual,
screen->root_depth);
} else {
// FIXME: support embedded mode
VideoWindow = screen->root;
// FIXME: VideoWindowHeight VideoWindowWidth
}
Debug(3, "video: window prepared\n");
//
// prepare hardware decoder VA-API/VDPAU
//
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
VideoVaapiInit(display_name);
}
#endif
#ifdef USE_VDPAU
if (VideoVdpauEnabled) {
VideoVdpauInit(display_name);
}
#endif
//xcb_prefetch_maximum_request_length(Connection);
xcb_flush(Connection);
}
/**
** Cleanup video output module.
*/
void VideoExit(void)
{
if (!XlibDisplay) { // no init or failed
return;
}
#ifdef USE_VIDEO_THREAD
VideoThreadExit();
#endif
#ifdef USE_VDPAU
if (VideoVdpauEnabled) {
VideoVdpauExit();
}
#endif
#ifdef USE_VAAPI
if (VideoVaapiEnabled) {
VideoVaapiExit();
}
#endif
#ifdef USE_GLX
if (GlxEnabled) {
GlxExit();
}
#endif
//
// Reenable screensaver / DPMS.
//
//X11SuspendScreenSaver(XlibDisplay, False);
//X11DPMSEnable(XlibDisplay);
//
// FIXME: cleanup.
//
//RandrExit();
}
#endif
#ifdef VIDEO_TEST
#include <getopt.h>
int SysLogLevel; ///< show additional debug informations
/**
** Print version.
*/
static void PrintVersion(void)
{
printf("video_test: video tester Version " VERSION
#ifdef GIT_REV
"(GIT-" GIT_REV ")"
#endif
",\n\t(c) 2009 - 2011 by Johns\n"
"\tLicense AGPLv3: GNU Affero General Public License version 3\n");
}
/**
** Print usage.
*/
static void PrintUsage(void)
{
printf("Usage: video_test [-?dhv]\n"
"\t-d\tenable debug, more -d increase the verbosity\n"
"\t-? -h\tdisplay this message\n" "\t-v\tdisplay version information\n"
"Only idiots print usage on stderr!\n");
}
/**
** Main entry point.
**
** @param argc number of arguments
** @param argv arguments vector
**
** @returns -1 on failures, 0 clean exit.
*/
int main(int argc, char *const argv[])
{
SysLogLevel = 0;
//
// Parse command line arguments
//
for (;;) {
switch (getopt(argc, argv, "hv?-c:d")) {
case 'd': // enabled debug
++SysLogLevel;
continue;
case EOF:
break;
case 'v': // print version
PrintVersion();
return 0;
case '?':
case 'h': // help usage
PrintVersion();
PrintUsage();
return 0;
case '-':
PrintVersion();
PrintUsage();
fprintf(stderr, "\nWe need no long options\n");
return -1;
case ':':
PrintVersion();
fprintf(stderr, "Missing argument for option '%c'\n", optopt);
return -1;
default:
PrintVersion();
fprintf(stderr, "Unkown option '%c'\n", optopt);
return -1;
}
break;
}
if (optind < argc) {
PrintVersion();
while (optind < argc) {
fprintf(stderr, "Unhandled argument '%s'\n", argv[optind++]);
}
return -1;
}
//
// main loop
//
VideoInit();
VideoOsdInit();
for (;;) {
VideoRenderOverlay();
VideoDisplayOverlay();
glXSwapBuffers(XlibDisplay, VideoWindow);
GlxCheck();
glClear(GL_COLOR_BUFFER_BIT);
XFlush(XlibDisplay);
XSync(XlibDisplay, False);
XFlush(XlibDisplay);
XSync(XlibDisplay, False);
XFlush(XlibDisplay);
XSync(XlibDisplay, False);
XFlush(XlibDisplay);
XSync(XlibDisplay, False);
XFlush(XlibDisplay);
XSync(XlibDisplay, False);
XFlush(XlibDisplay);
usleep(20 * 1000);
}
VideoExit();
return 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink