* <http://www.gnu.org/licenses/>.
*
*/
+
//#define DEBUG_VERBOSE 1
#include "system.h"
#include <EGL/eglext.h>
#include "windowing/egl/EGLWrapper.h"
#include "android/activity/XBMCApp.h"
-#include "DVDCodecs/Video/StageFrightVideo.h"
+#include "DVDCodecs/Video/DVDVideoCodecStageFright.h"
// EGL extension functions
static PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR;
static PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES;
#endif
+#if defined(TARGET_ANDROID)
+#include "DVDCodecs/Video/DVDVideoCodecAndroidMediaCodec.h"
+#endif
+
using namespace Shaders;
CLinuxRendererGLES::YUVBUFFER::YUVBUFFER()
stf = NULL;
eglimg = EGL_NO_IMAGE_KHR;
#endif
+#if defined(TARGET_ANDROID)
+ mediacodec = NULL;
+#endif
}
CLinuxRendererGLES::YUVBUFFER::~YUVBUFFER()
{
CLog::Log(LOGNOTICE,"Using GL_TEXTURE_2D");
+ // function pointer for texture might change in
+ // call to LoadShaders
+ glFinish();
+ for (int i = 0 ; i < NUM_BUFFERS ; i++)
+ (this->*m_textureDelete)(i);
+
// create the yuv textures
LoadShaders();
{
return source;
}
+
#endif
+ if ( m_renderMethod & RENDER_MEDIACODEC )
+ {
+ return source;
+ }
+
#ifdef HAVE_VIDEOTOOLBOXDECODER
if (m_renderMethod & RENDER_CVREF )
{
}
}
+void CLinuxRendererGLES::Flush()
+{
+ if (!m_bValidated)
+ return;
+
+ glFinish();
+
+ for (int i = 0 ; i < m_NumYV12Buffers ; i++)
+ (this->*m_textureDelete)(i);
+
+ glFinish();
+ m_bValidated = false;
+ m_fbo.Cleanup();
+ m_iYV12RenderBuffer = 0;
+}
+
void CLinuxRendererGLES::Update()
{
if (!m_bConfigured) return;
int index = m_iYV12RenderBuffer;
YUVBUFFER& buf = m_buffers[index];
- if (m_format != RENDER_FMT_OMXEGL && m_format != RENDER_FMT_EGLIMG)
+ if (m_format != RENDER_FMT_OMXEGL && m_format != RENDER_FMT_EGLIMG && m_format != RENDER_FMT_MEDIACODEC)
{
if (!buf.fields[FIELD_FULL][0].id) return;
}
m_NumYV12Buffers = 2;
m_formats.push_back(RENDER_FMT_YUV420P);
+ m_formats.push_back(RENDER_FMT_NV12);
m_formats.push_back(RENDER_FMT_BYPASS);
#if defined(HAVE_LIBOPENMAX)
m_formats.push_back(RENDER_FMT_OMXEGL);
#ifdef HAS_LIBSTAGEFRIGHT
m_formats.push_back(RENDER_FMT_EGLIMG);
#endif
+#if defined(TARGET_ANDROID)
+ m_formats.push_back(RENDER_FMT_MEDIACODEC);
+#endif
// setup the background colour
m_clearColour = (float)(g_advancedSettings.m_videoBlackBarColour & 0xff) / 0xff;
m_renderMethod = RENDER_EGLIMG;
break;
}
+ else if (m_format == RENDER_FMT_MEDIACODEC)
+ {
+ CLog::Log(LOGNOTICE, "GL: Using MediaCodec render method");
+ m_renderMethod = RENDER_MEDIACODEC;
+ break;
+ }
else if (m_format == RENDER_FMT_BYPASS)
{
CLog::Log(LOGNOTICE, "GL: Using BYPASS render method");
m_textureCreate = &CLinuxRendererGLES::CreateEGLIMGTexture;
m_textureDelete = &CLinuxRendererGLES::DeleteEGLIMGTexture;
}
+ else if (m_format == RENDER_FMT_MEDIACODEC)
+ {
+ m_textureUpload = &CLinuxRendererGLES::UploadSurfaceTexture;
+ m_textureCreate = &CLinuxRendererGLES::CreateSurfaceTexture;
+ m_textureDelete = &CLinuxRendererGLES::DeleteSurfaceTexture;
+ }
+ else if (m_format == RENDER_FMT_NV12)
+ {
+ m_textureUpload = &CLinuxRendererGLES::UploadNV12Texture;
+ m_textureCreate = &CLinuxRendererGLES::CreateNV12Texture;
+ m_textureDelete = &CLinuxRendererGLES::DeleteNV12Texture;
+ }
else
{
// default to YV12 texture handlers
}
}
+void CLinuxRendererGLES::ReleaseBuffer(int idx)
+{
+#ifdef HAVE_VIDEOTOOLBOXDECODER
+ YUVBUFFER &buf = m_buffers[idx];
+
+ if (buf.cvBufferRef)
+ CVBufferRelease(buf.cvBufferRef);
+ buf.cvBufferRef = NULL;
+#endif
+#if defined(TARGET_ANDROID)
+ YUVBUFFER &buf = m_buffers[idx];
+
+ SAFE_RELEASE(buf.mediacodec);
+#endif
+}
+
void CLinuxRendererGLES::Render(DWORD flags, int index)
{
// If rendered directly by the hardware
RenderCoreVideoRef(index, m_currentField);
VerifyGLState();
}
+ else if (m_renderMethod & RENDER_MEDIACODEC)
+ {
+ RenderSurfaceTexture(index, m_currentField);
+ }
else
{
RenderSoftware(index, m_currentField);
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
GLfloat ver[4][4];
GLfloat tex[4][2];
- float col[4][3];
-
- for (int index = 0;index < 4;++index)
- col[index][0] = col[index][1] = col[index][2] = 1.0;
+ GLfloat col[3] = {1.0f, 1.0f, 1.0f};
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint texLoc = g_Windowing.GUIShaderGetCoord0();
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
GLfloat ver[4][4];
GLfloat tex[4][2];
- float col[4][3];
-
- for (int index = 0;index < 4;++index)
- {
- col[index][0] = col[index][1] = col[index][2] = 1.0;
- }
+ GLfloat col[3] = {1.0f, 1.0f, 1.0f};
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint texLoc = g_Windowing.GUIShaderGetCoord0();
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
GLfloat ver[4][4];
GLfloat tex[4][2];
- float col[4][3];
-
- for (int i = 0;i < 4;++i)
- {
- col[i][0] = col[i][1] = col[i][2] = 1.0;
- }
+ GLfloat col[3] = {1.0f, 1.0f, 1.0f};
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint texLoc = g_Windowing.GUIShaderGetCoord0();
#endif
}
+void CLinuxRendererGLES::RenderSurfaceTexture(int index, int field)
+{
+#if defined(TARGET_ANDROID)
+ #ifdef DEBUG_VERBOSE
+ unsigned int time = XbmcThreads::SystemClockMillis();
+ #endif
+
+ YUVPLANE &plane = m_buffers[index].fields[0][0];
+
+ glDisable(GL_DEPTH_TEST);
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, plane.id);
+
+ g_Windowing.EnableGUIShader(SM_TEXTURE_RGBA_OES);
+
+ glUniformMatrix4fv(g_Windowing.GUIShaderGetCoord0Matrix(), 1, GL_FALSE, m_textureMatrix);
+
+ GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
+ GLfloat ver[4][4];
+ GLfloat tex[4][4];
+
+ GLint posLoc = g_Windowing.GUIShaderGetPos();
+ GLint texLoc = g_Windowing.GUIShaderGetCoord0();
+
+
+ glVertexAttribPointer(posLoc, 4, GL_FLOAT, 0, 0, ver);
+ glVertexAttribPointer(texLoc, 4, GL_FLOAT, 0, 0, tex);
+
+ glEnableVertexAttribArray(posLoc);
+ glEnableVertexAttribArray(texLoc);
+
+ // Set vertex coordinates
+ for(int i = 0; i < 4; i++)
+ {
+ ver[i][0] = m_rotatedDestCoords[i].x;
+ ver[i][1] = m_rotatedDestCoords[i].y;
+ ver[i][2] = 0.0f; // set z to 0
+ ver[i][3] = 1.0f;
+ }
+
+ // Set texture coordinates (MediaCodec is flipped in y)
+ tex[0][0] = tex[3][0] = 0.0f;
+ tex[0][1] = tex[1][1] = 1.0f;
+ tex[1][0] = tex[2][0] = 1.0f;
+ tex[2][1] = tex[3][1] = 0.0f;
+
+ for(int i = 0; i < 4; i++)
+ {
+ tex[i][2] = 0.0f;
+ tex[i][3] = 1.0f;
+ }
+
+ glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
+
+ glDisableVertexAttribArray(posLoc);
+ glDisableVertexAttribArray(texLoc);
+
+ const float identity[16] = {
+ 1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 1.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 1.0f
+ };
+ glUniformMatrix4fv(g_Windowing.GUIShaderGetCoord0Matrix(), 1, GL_FALSE, identity);
+
+ g_Windowing.DisableGUIShader();
+ VerifyGLState();
+
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
+ VerifyGLState();
+
+ #ifdef DEBUG_VERBOSE
+ CLog::Log(LOGDEBUG, "RenderMediaCodecImage %d: tm:%d", index, XbmcThreads::SystemClockMillis() - time);
+ #endif
+#endif
+}
+
void CLinuxRendererGLES::RenderCoreVideoRef(int index, int field)
{
#ifdef HAVE_VIDEOTOOLBOXDECODER
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
GLfloat ver[4][4];
GLfloat tex[4][2];
- float col[4][3];
-
- for (int index = 0;index < 4;++index)
- {
- col[index][0] = col[index][1] = col[index][2] = 1.0;
- }
+ GLfloat col[3] = {1.0f, 1.0f, 1.0f};
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint texLoc = g_Windowing.GUIShaderGetCoord0();
if (!m_bValidated)
return false;
+ // If rendered directly by the hardware
+ if (m_renderMethod & RENDER_BYPASS)
+ {
+ capture->BeginRender();
+ capture->EndRender();
+ return true;
+ }
+
// save current video rect
CRect saveSize = m_destRect;
saveRotatedCoords();//backup current m_rotatedDestCoords
, im->width >> im->cshift_x, im->height >> (im->cshift_y + 1)
, im->stride[1]*2, im->plane[1] );
- LoadPlane( fields[FIELD_TOP][2], GL_LUMINANCE, buf.flipindex
+ LoadPlane( fields[FIELD_TOP][2], GL_ALPHA, buf.flipindex
, im->width >> im->cshift_x, im->height >> (im->cshift_y + 1)
, im->stride[2]*2, im->plane[2] );
, im->width >> im->cshift_x, im->height >> (im->cshift_y + 1)
, im->stride[1]*2, im->plane[1] + im->stride[1] );
- LoadPlane( fields[FIELD_BOT][2], GL_LUMINANCE, buf.flipindex
+ LoadPlane( fields[FIELD_BOT][2], GL_ALPHA, buf.flipindex
, im->width >> im->cshift_x, im->height >> (im->cshift_y + 1)
, im->stride[2]*2, im->plane[2] + im->stride[2] );
, im->width >> im->cshift_x, im->height >> im->cshift_y
, im->stride[1], im->plane[1] );
- LoadPlane( fields[FIELD_FULL][2], GL_LUMINANCE, buf.flipindex
+ LoadPlane( fields[FIELD_FULL][2], GL_ALPHA, buf.flipindex
, im->width >> im->cshift_x, im->height >> im->cshift_y
, im->stride[2], im->plane[2] );
}
}
else
{
+ GLenum format;
+ GLint internalformat;
+ if (p == 2) //V plane needs an alpha texture
+ {
+ format = GL_ALPHA;
+ internalformat = GL_ALPHA;
+ }
+ else
+ {
+ format = GL_LUMINANCE;
+ internalformat = GL_LUMINANCE;
+ }
+
if(m_renderMethod & RENDER_POT)
CLog::Log(LOGDEBUG, "GL: Creating YUV POT texture of size %d x %d", plane.texwidth, plane.texheight);
else
CLog::Log(LOGDEBUG, "GL: Creating YUV NPOT texture of size %d x %d", plane.texwidth, plane.texheight);
- glTexImage2D(m_textureTarget, 0, GL_LUMINANCE, plane.texwidth, plane.texheight, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
+ glTexImage2D(m_textureTarget, 0, internalformat, plane.texwidth, plane.texheight, 0, format, GL_UNSIGNED_BYTE, NULL);
}
glTexParameteri(m_textureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
//********************************************************************************************************
+// NV12 Texture loading, creation and deletion
+//********************************************************************************************************
+void CLinuxRendererGLES::UploadNV12Texture(int source)
+{
+ YUVBUFFER& buf = m_buffers[source];
+ YV12Image* im = &buf.image;
+ YUVFIELDS& fields = buf.fields;
+
+ if (!(im->flags & IMAGE_FLAG_READY))
+ return;
+ bool deinterlacing;
+ if (m_currentField == FIELD_FULL)
+ deinterlacing = false;
+ else
+ deinterlacing = true;
+
+ glEnable(m_textureTarget);
+ VerifyGLState();
+
+ glPixelStorei(GL_UNPACK_ALIGNMENT, im->bpp);
+
+ if (deinterlacing)
+ {
+ // Load Odd Y field
+ LoadPlane( fields[FIELD_TOP][0] , GL_LUMINANCE, buf.flipindex
+ , im->width, im->height >> 1
+ , im->stride[0]*2, im->plane[0] );
+
+ // Load Even Y field
+ LoadPlane( fields[FIELD_BOT][0], GL_LUMINANCE, buf.flipindex
+ , im->width, im->height >> 1
+ , im->stride[0]*2, im->plane[0] + im->stride[0]) ;
+
+ // Load Odd UV Fields
+ LoadPlane( fields[FIELD_TOP][1], GL_LUMINANCE_ALPHA, buf.flipindex
+ , im->width >> im->cshift_x, im->height >> (im->cshift_y + 1)
+ , im->stride[1]*2, im->plane[1] );
+
+ // Load Even UV Fields
+ LoadPlane( fields[FIELD_BOT][1], GL_LUMINANCE_ALPHA, buf.flipindex
+ , im->width >> im->cshift_x, im->height >> (im->cshift_y + 1)
+ , im->stride[1]*2, im->plane[1] + im->stride[1] );
+
+ }
+ else
+ {
+ // Load Y plane
+ LoadPlane( fields[FIELD_FULL][0], GL_LUMINANCE, buf.flipindex
+ , im->width, im->height
+ , im->stride[0], im->plane[0] );
+
+ // Load UV plane
+ LoadPlane( fields[FIELD_FULL][1], GL_LUMINANCE_ALPHA, buf.flipindex
+ , im->width >> im->cshift_x, im->height >> im->cshift_y
+ , im->stride[1], im->plane[1] );
+ }
+
+ VerifyGLState();
+
+ CalculateTextureSourceRects(source, 3);
+
+ glDisable(m_textureTarget);
+ return;
+}
+
+bool CLinuxRendererGLES::CreateNV12Texture(int index)
+{
+ // since we also want the field textures, pitch must be texture aligned
+ YV12Image &im = m_buffers[index].image;
+ YUVFIELDS &fields = m_buffers[index].fields;
+
+ // Delete any old texture
+ DeleteNV12Texture(index);
+
+ im.height = m_sourceHeight;
+ im.width = m_sourceWidth;
+ im.cshift_x = 1;
+ im.cshift_y = 1;
+ im.bpp = 1;
+
+ im.stride[0] = im.width;
+ im.stride[1] = im.width;
+ im.stride[2] = 0;
+
+ im.plane[0] = NULL;
+ im.plane[1] = NULL;
+ im.plane[2] = NULL;
+
+ // Y plane
+ im.planesize[0] = im.stride[0] * im.height;
+ // packed UV plane
+ im.planesize[1] = im.stride[1] * im.height / 2;
+ // third plane is not used
+ im.planesize[2] = 0;
+
+ for (int i = 0; i < 2; i++)
+ im.plane[i] = new BYTE[im.planesize[i]];
+
+ glEnable(m_textureTarget);
+ for(int f = 0;f<MAX_FIELDS;f++)
+ {
+ for(int p = 0;p<2;p++)
+ {
+ if (!glIsTexture(fields[f][p].id))
+ {
+ glGenTextures(1, &fields[f][p].id);
+ VerifyGLState();
+ }
+ }
+ fields[f][2].id = fields[f][1].id;
+ }
+
+ // YUV
+ for (int f = FIELD_FULL; f<=FIELD_BOT ; f++)
+ {
+ int fieldshift = (f==FIELD_FULL) ? 0 : 1;
+ YUVPLANES &planes = fields[f];
+
+ planes[0].texwidth = im.width;
+ planes[0].texheight = im.height >> fieldshift;
+
+ if (m_renderMethod & RENDER_SW)
+ {
+ planes[1].texwidth = 0;
+ planes[1].texheight = 0;
+ planes[2].texwidth = 0;
+ planes[2].texheight = 0;
+ }
+ else
+ {
+ planes[1].texwidth = planes[0].texwidth >> im.cshift_x;
+ planes[1].texheight = planes[0].texheight >> im.cshift_y;
+ planes[2].texwidth = planes[1].texwidth;
+ planes[2].texheight = planes[1].texheight;
+ }
+
+ if(m_renderMethod & RENDER_POT)
+ {
+ for(int p = 0; p < 3; p++)
+ {
+ planes[p].texwidth = NP2(planes[p].texwidth);
+ planes[p].texheight = NP2(planes[p].texheight);
+ }
+ }
+
+ for(int p = 0; p < 2; p++)
+ {
+ YUVPLANE &plane = planes[p];
+ if (plane.texwidth * plane.texheight == 0)
+ continue;
+
+ glBindTexture(m_textureTarget, plane.id);
+ if (m_renderMethod & RENDER_SW)
+ {
+ glTexImage2D(m_textureTarget, 0, GL_RGBA, plane.texwidth, plane.texheight, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
+ }
+ else
+ {
+ if (p == 1)
+ glTexImage2D(m_textureTarget, 0, GL_LUMINANCE_ALPHA, plane.texwidth, plane.texheight, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
+ else
+ glTexImage2D(m_textureTarget, 0, GL_LUMINANCE, plane.texwidth, plane.texheight, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
+ }
+
+ glTexParameteri(m_textureTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ glTexParameteri(m_textureTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(m_textureTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameteri(m_textureTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+ VerifyGLState();
+ }
+ }
+ glDisable(m_textureTarget);
+
+ return true;
+}
+void CLinuxRendererGLES::DeleteNV12Texture(int index)
+{
+ YV12Image &im = m_buffers[index].image;
+ YUVFIELDS &fields = m_buffers[index].fields;
+
+ if( fields[FIELD_FULL][0].id == 0 ) return;
+
+ // finish up all textures, and delete them
+ g_graphicsContext.BeginPaint(); //FIXME
+ for(int f = 0;f<MAX_FIELDS;f++)
+ {
+ for(int p = 0;p<2;p++)
+ {
+ if( fields[f][p].id )
+ {
+ if (glIsTexture(fields[f][p].id))
+ {
+ glDeleteTextures(1, &fields[f][p].id);
+ }
+ fields[f][p].id = 0;
+ }
+ }
+ fields[f][2].id = 0;
+ }
+ g_graphicsContext.EndPaint();
+
+ for(int p = 0;p<2;p++)
+ {
+ if (im.plane[p])
+ {
+ delete[] im.plane[p];
+ im.plane[p] = NULL;
+ }
+ }
+}
+
+//********************************************************************************************************
// CoreVideoRef Texture creation, deletion, copying + clearing
//********************************************************************************************************
void CLinuxRendererGLES::UploadCVRefTexture(int index)
return true;
}
+//********************************************************************************************************
+// SurfaceTexture creation, deletion, copying + clearing
+//********************************************************************************************************
+void CLinuxRendererGLES::UploadSurfaceTexture(int index)
+{
+#if defined(TARGET_ANDROID)
+#ifdef DEBUG_VERBOSE
+ unsigned int time = XbmcThreads::SystemClockMillis();
+ int mindex = -1;
+#endif
+
+ YUVBUFFER &buf = m_buffers[index];
+
+ if (buf.mediacodec)
+ {
+#ifdef DEBUG_VERBOSE
+ mindex = buf.mediacodec->GetIndex();
+#endif
+ buf.fields[0][0].id = buf.mediacodec->GetTextureID();
+ buf.mediacodec->UpdateTexImage();
+ buf.mediacodec->GetTransformMatrix(m_textureMatrix);
+ SAFE_RELEASE(buf.mediacodec);
+ }
+
+#ifdef DEBUG_VERBOSE
+ CLog::Log(LOGDEBUG, "UploadSurfaceTexture %d: img: %d tm:%d", index, mindex, XbmcThreads::SystemClockMillis() - time);
+#endif
+#endif
+}
+void CLinuxRendererGLES::DeleteSurfaceTexture(int index)
+{
+#if defined(TARGET_ANDROID)
+ SAFE_RELEASE(m_buffers[index].mediacodec);
+#endif
+}
+bool CLinuxRendererGLES::CreateSurfaceTexture(int index)
+{
+ return true;
+}
+
void CLinuxRendererGLES::SetTextureFilter(GLenum method)
{
for (int i = 0 ; i<m_NumYV12Buffers ; i++)
if(m_renderMethod & RENDER_EGLIMG)
return false;
+ if(m_renderMethod & RENDER_MEDIACODEC)
+ return false;
+
if(m_renderMethod & RENDER_CVREF)
return false;
{
if(m_format == RENDER_FMT_OMXEGL
|| m_format == RENDER_FMT_CVBREF
- || m_format == RENDER_FMT_EGLIMG)
+ || m_format == RENDER_FMT_EGLIMG
+ || m_format == RENDER_FMT_MEDIACODEC)
return 1;
else
return 0;
}
#endif
#ifdef HAS_LIBSTAGEFRIGHT
-void CLinuxRendererGLES::AddProcessor(CStageFrightVideo* stf, EGLImageKHR eglimg, int index)
+void CLinuxRendererGLES::AddProcessor(CDVDVideoCodecStageFright* stf, EGLImageKHR eglimg, int index)
{
#ifdef DEBUG_VERBOSE
unsigned int time = XbmcThreads::SystemClockMillis();
}
#endif
+#if defined(TARGET_ANDROID)
+void CLinuxRendererGLES::AddProcessor(CDVDMediaCodecInfo *mediacodec, int index)
+{
+#ifdef DEBUG_VERBOSE
+ unsigned int time = XbmcThreads::SystemClockMillis();
+ int mindex = -1;
+#endif
+
+ YUVBUFFER &buf = m_buffers[index];
+ if (mediacodec)
+ {
+ buf.mediacodec = mediacodec->Retain();
+#ifdef DEBUG_VERBOSE
+ mindex = buf.mediacodec->GetIndex();
+#endif
+ // releaseOutputBuffer must be in same thread as
+ // dequeueOutputBuffer. We are in DVDPlayerVideo
+ // thread here, so we are safe.
+ buf.mediacodec->ReleaseOutputBuffer(true);
+ }
+
+#ifdef DEBUG_VERBOSE
+ CLog::Log(LOGDEBUG, "AddProcessor %d: img:%d tm:%d", index, mindex, XbmcThreads::SystemClockMillis() - time);
+#endif
+}
+#endif
+
#endif
projects / vuplus_xbmc / blobdiff