void
MIR_SetWindowFullscreen(_THIS, SDL_Window* window,
SDL_VideoDisplay* display,
SDL_bool fullscreen)
{
MIR_Data* mir_data = _this->driverdata;
MIR_Window* mir_window = window->driverdata;
MirSurfaceSpec* spec;
MirSurfaceState state;
if (IsSurfaceValid(mir_window) < 0)
return;
if (fullscreen) {
state = mir_surface_state_fullscreen;
} else {
state = mir_surface_state_restored;
}
spec = MIR_mir_connection_create_spec_for_changes(mir_data->connection);
MIR_mir_surface_spec_set_state(spec, state);
MIR_mir_surface_apply_spec(mir_window->surface, spec);
MIR_mir_surface_spec_release(spec);
}
void
MIR_RestoreWindow(_THIS, SDL_Window * window)
{
MIR_Window* mir_window = window->driverdata;
if (IsSurfaceValid(mir_window) < 0)
return;
MIR_mir_surface_set_state(mir_window->surface, mir_surface_state_restored);
}
template <class T> int CIsoSurface<T>::GetVolumeLengths(float& fVolLengthX, float& fVolLengthY, float& fVolLengthZ)
{
if (IsSurfaceValid()) {
fVolLengthX = m_fCellLengthX*m_nCellsX;
fVolLengthY = m_fCellLengthY*m_nCellsY;
fVolLengthZ = m_fCellLengthZ*m_nCellsZ;
return 1;
}
else
return -1;
}
int CIsoSurfaceBase::GetVolumeLengths( float& fVolLengthX, float& fVolLengthY, float& fVolLengthZ )
{
if ( IsSurfaceValid() )
{
fVolLengthX = m_fCellLengthX * m_nCellsX;
fVolLengthY = m_fCellLengthY * m_nCellsY;
fVolLengthZ = m_fCellLengthZ * m_nCellsZ;
return 1;
}
else
{
return -1;
}
}
void
MIR_SetWindowFullscreen(_THIS, SDL_Window* window,
SDL_VideoDisplay* display,
SDL_bool fullscreen)
{
MIR_Window* mir_window = window->driverdata;
if (IsSurfaceValid(mir_window) < 0)
return;
if (fullscreen) {
MIR_mir_surface_set_state(mir_window->surface, mir_surface_state_fullscreen);
} else {
MIR_mir_surface_set_state(mir_window->surface, mir_surface_state_restored);
}
}
void
MIR_HideWindow(_THIS, SDL_Window* window)
{
MIR_Data* mir_data = _this->driverdata;
MIR_Window* mir_window = window->driverdata;
MirSurfaceSpec* spec;
if (IsSurfaceValid(mir_window) < 0)
return;
spec = MIR_mir_connection_create_spec_for_changes(mir_data->connection);
MIR_mir_surface_spec_set_state(spec, mir_surface_state_hidden);
MIR_mir_surface_apply_spec(mir_window->surface, spec);
MIR_mir_surface_spec_release(spec);
}
void
MIR_SetWindowTitle(_THIS, SDL_Window* window)
{
MIR_Data* mir_data = _this->driverdata;
MIR_Window* mir_window = window->driverdata;
char const* title = window->title ? window->title : "";
MirSurfaceSpec* spec;
if (IsSurfaceValid(mir_window) < 0)
return;
spec = MIR_mir_connection_create_spec_for_changes(mir_data->connection);
MIR_mir_surface_spec_set_name(spec, title);
MIR_mir_surface_apply_spec(mir_window->surface, spec);
MIR_mir_surface_spec_release(spec);
}
void
MIR_SetWindowMaximumSize(_THIS, SDL_Window* window)
{
MIR_Data* mir_data = _this->driverdata;
MIR_Window* mir_window = window->driverdata;
MirSurfaceSpec* spec;
if (IsSurfaceValid(mir_window) < 0)
return;
spec = MIR_mir_connection_create_spec_for_changes(mir_data->connection);
MIR_mir_surface_spec_set_max_width (spec, window->max_w);
MIR_mir_surface_spec_set_max_height(spec, window->max_h);
MIR_mir_surface_apply_spec(mir_window->surface, spec);
MIR_mir_surface_spec_release(spec);
}
void
MIR_SetWindowSize(_THIS, SDL_Window* window)
{
MIR_Data* mir_data = _this->driverdata;
MIR_Window* mir_window = window->driverdata;
MirSurfaceSpec* spec;
if (IsSurfaceValid(mir_window) < 0)
return;
/* You cannot set the x/y of a mir window! So only update w/h */
spec = MIR_mir_connection_create_spec_for_changes(mir_data->connection);
MIR_mir_surface_spec_set_width (spec, window->w);
MIR_mir_surface_spec_set_height(spec, window->h);
MIR_mir_surface_apply_spec(mir_window->surface, spec);
MIR_mir_surface_spec_release(spec);
}
int CVDPAU::Decode(AVCodecContext *avctx, AVFrame *pFrame)
{
//CLog::Log(LOGNOTICE,"%s",__FUNCTION__);
VdpStatus vdp_st;
VdpTime time;
int result = Check(avctx);
if (result)
return result;
CSharedLock lock(m_DecoderSection);
if (!vdpauConfigured)
return VC_ERROR;
// configure vdpau output
if (!ConfigOutputMethod(avctx, pFrame))
return VC_FLUSHED;
outputSurface = outputSurfaces[surfaceNum];
CheckFeatures();
if (( (int)outRectVid.x1 != OutWidth ) ||
( (int)outRectVid.y1 != OutHeight ))
{
outRectVid.x0 = 0;
outRectVid.y0 = 0;
outRectVid.x1 = OutWidth;
outRectVid.y1 = OutHeight;
}
EDEINTERLACEMODE mode = g_settings.m_currentVideoSettings.m_DeinterlaceMode;
EINTERLACEMETHOD method = g_settings.m_currentVideoSettings.m_InterlaceMethod;
if (method == VS_INTERLACEMETHOD_AUTO)
method = AutoInterlaceMethod();
if(pFrame)
{ // we have a new frame from decoder
vdpau_render_state * render = (vdpau_render_state*)pFrame->data[2];
if(!render) // old style ffmpeg gave data on plane 0
render = (vdpau_render_state*)pFrame->data[0];
if(!render)
return VC_ERROR;
// ffmpeg vc-1 decoder does not flush, make sure the data buffer is still valid
if (!IsSurfaceValid(render))
{
CLog::Log(LOGWARNING, "CVDPAU::Decode - ignoring invalid buffer");
return VC_BUFFER;
}
render->state |= FF_VDPAU_STATE_USED_FOR_RENDER;
ClearUsedForRender(&past[0]);
past[0] = past[1];
past[1] = current;
current = future;
future = render;
DVDVideoPicture DVDPic;
memset(&DVDPic, 0, sizeof(DVDVideoPicture));
((CDVDVideoCodecFFmpeg*)avctx->opaque)->GetPictureCommon(&DVDPic);
m_DVDVideoPics.push(DVDPic);
int pics = m_DVDVideoPics.size();
if (pics < 2)
return VC_BUFFER;
else if (pics > 2)
{
// this should not normally happen
CLog::Log(LOGERROR, "CVDPAU::Decode - invalid number of pictures in queue");
while (pics-- != 2)
m_DVDVideoPics.pop();
}
if (mode == VS_DEINTERLACEMODE_FORCE
|| (mode == VS_DEINTERLACEMODE_AUTO && m_DVDVideoPics.front().iFlags & DVP_FLAG_INTERLACED))
{
if((method == VS_INTERLACEMETHOD_VDPAU_BOB
|| method == VS_INTERLACEMETHOD_VDPAU_TEMPORAL
|| method == VS_INTERLACEMETHOD_VDPAU_TEMPORAL_HALF
|| method == VS_INTERLACEMETHOD_VDPAU_TEMPORAL_SPATIAL
|| method == VS_INTERLACEMETHOD_VDPAU_TEMPORAL_SPATIAL_HALF
|| method == VS_INTERLACEMETHOD_VDPAU_INVERSE_TELECINE ))
{
if(method == VS_INTERLACEMETHOD_VDPAU_TEMPORAL_HALF
|| method == VS_INTERLACEMETHOD_VDPAU_TEMPORAL_SPATIAL_HALF
|| avctx->skip_frame == AVDISCARD_NONREF)
m_mixerstep = 0;
else
m_mixerstep = 1;
if(m_DVDVideoPics.front().iFlags & DVP_FLAG_TOP_FIELD_FIRST)
m_mixerfield = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD;
else
m_mixerfield = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD;
}
else
{
m_mixerstep = 0;
m_mixerfield = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME;
}
}
else
{
m_mixerstep = 0;
m_mixerfield = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME;
}
}
else if(m_mixerstep == 1)
{ // no new frame given, output second field of old frame
if(avctx->skip_frame == AVDISCARD_NONREF)
{
ClearUsedForRender(&past[1]);
m_DVDVideoPics.pop();
return VC_BUFFER;
}
m_mixerstep = 2;
if(m_mixerfield == VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD)
m_mixerfield = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD;
else
m_mixerfield = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD;
}
else
{
CLog::Log(LOGERROR, "CVDPAU::Decode - invalid mixer state reached");
return VC_BUFFER;
}
VdpVideoSurface past_surfaces[2] = { VDP_INVALID_HANDLE, VDP_INVALID_HANDLE };
VdpVideoSurface futu_surfaces[1] = { VDP_INVALID_HANDLE };
if(m_mixerfield == VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME)
{
if (past[0])
past_surfaces[1] = past[0]->surface;
if (past[1])
past_surfaces[0] = past[1]->surface;
futu_surfaces[0] = future->surface;
}
else
{
if(m_mixerstep == 1)
{ // first field
if (past[1])
{
past_surfaces[1] = past[1]->surface;
past_surfaces[0] = past[1]->surface;
}
futu_surfaces[0] = current->surface;
}
else
{ // second field
if (past[1])
past_surfaces[1] = past[1]->surface;
past_surfaces[0] = current->surface;
futu_surfaces[0] = future->surface;
}
}
vdp_st = vdp_presentation_queue_block_until_surface_idle(vdp_flip_queue,outputSurface,&time);
VdpRect sourceRect = {0,0,vid_width, vid_height};
vdp_st = vdp_video_mixer_render(videoMixer,
VDP_INVALID_HANDLE,
0,
m_mixerfield,
2,
past_surfaces,
current->surface,
1,
futu_surfaces,
&sourceRect,
outputSurface,
&(outRectVid),
&(outRectVid),
0,
NULL);
CheckStatus(vdp_st, __LINE__);
surfaceNum++;
if (surfaceNum >= totalAvailableOutputSurfaces) surfaceNum = 0;
if(m_mixerfield == VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME)
{
ClearUsedForRender(&past[0]);
return VC_BUFFER | VC_PICTURE;
}
else
{
if(m_mixerstep == 1)
return VC_PICTURE;
else
{
ClearUsedForRender(&past[1]);
return VC_BUFFER | VC_PICTURE;
}
}
}
