icculus/SDL-audio-capture: comparison src/render/opengl/SDL_render

equal deleted inserted replaced

-:6801ced90deb
+:309599be5c2a
 GLuint vtexture;
 GL_FBOList *fbo;
 } GL_TextureData;
+static inline const char*
-static void
+GL_TranslateError (GLenum error)
-GL_SetError(const char *prefix, GLenum result)
+{
-{
+#define GL_ERROR_TRANSLATE(e) case e: return #e;
-const char *error;
+switch (error) {
+GL_ERROR_TRANSLATE(GL_INVALID_ENUM)
-switch (result) {
+GL_ERROR_TRANSLATE(GL_INVALID_VALUE)
-case GL_NO_ERROR:
+GL_ERROR_TRANSLATE(GL_INVALID_OPERATION)
-error = "GL_NO_ERROR";
+GL_ERROR_TRANSLATE(GL_OUT_OF_MEMORY)
-break;
+GL_ERROR_TRANSLATE(GL_NO_ERROR)
-case GL_INVALID_ENUM:
+GL_ERROR_TRANSLATE(GL_STACK_OVERFLOW)
-error = "GL_INVALID_ENUM";
+GL_ERROR_TRANSLATE(GL_STACK_UNDERFLOW)
-break;
+GL_ERROR_TRANSLATE(GL_TABLE_TOO_LARGE)
-case GL_INVALID_VALUE:
-error = "GL_INVALID_VALUE";
-break;
-case GL_INVALID_OPERATION:
-error = "GL_INVALID_OPERATION";
-break;
-case GL_STACK_OVERFLOW:
-error = "GL_STACK_OVERFLOW";
-break;
-case GL_STACK_UNDERFLOW:
-error = "GL_STACK_UNDERFLOW";
-break;
-case GL_OUT_OF_MEMORY:
-error = "GL_OUT_OF_MEMORY";
-break;
-case GL_TABLE_TOO_LARGE:
-error = "GL_TABLE_TOO_LARGE";
-break;
 default:
-error = "UNKNOWN";
+return "UNKNOWN";
-break;
+}
-}
+#undef GL_ERROR_TRANSLATE
-SDL_SetError("%s: %s", prefix, error);
+}
-}
+static __inline__ int
+GL_CheckAllErrors (const char *prefix, SDL_Renderer * renderer, const char *file, int line, const char *function)
+{
+GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
+int ret = 0;
+/* check gl errors (can return multiple errors) */
+for (;;) {
+GLenum error = data->glGetError();
+if (error != GL_NO_ERROR) {
+if (prefix == NULL || prefix[0] == '\0') {
+prefix = "generic";
+}
+SDL_SetError("%s: %s (%d): %s %s (0x%X)", prefix, file, line, function, GL_TranslateError(error), error);
+ret++;
+} else {
+break;
+}
+}
+return ret;
+}
+#if 1
+#define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, __FILE__, __LINE__, __PRETTY_FUNCTION__)
+#else
+#define GL_CheckError(prefix, renderer)
+#endif
 static int
 GL_LoadFunctions(GL_RenderData * data)
 {
 #ifdef __SDL_NOGETPROCADDR__
 /* This ended up causing video discrepancies between OpenGL and Direct3D */
 /*data->glEnable(GL_LINE_SMOOTH);*/
 data->glMatrixMode(GL_MODELVIEW);
 data->glLoadIdentity();
+GL_CheckError("", renderer);
 }
 GL_FBOList *
 GL_GetFBO(GL_RenderData *data, Uint32 w, Uint32 h)
 GL_TextureData *data;
 GLint internalFormat;
 GLenum format, type;
 int texture_w, texture_h;
 GLenum scaleMode;
-GLenum result;
 GL_ActivateRenderer(renderer);
 if (!convert_format(renderdata, texture->format, &internalFormat,
 &format, &type)) {
 data->fbo = GL_GetFBO(renderdata, texture->w, texture->h);
 } else {
 data->fbo = NULL;
 }
-renderdata->glGetError();
+GL_CheckError("", renderer);
 renderdata->glGenTextures(1, &data->texture);
 if ((renderdata->GL_ARB_texture_rectangle_supported)
 /*&& texture->access != SDL_TEXTUREACCESS_TARGET*/){
 data->type = GL_TEXTURE_RECTANGLE_ARB;
 texture_w = texture->w;
 {
 renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
 texture_h, 0, format, type, NULL);
 }
 renderdata->glDisable(data->type);
-result = renderdata->glGetError();
+if (GL_CheckError("glTexImage2D()", renderer) > 0) {
-if (result != GL_NO_ERROR) {
-GL_SetError("glTexImage2D()", result);
 return -1;
 }
 if (texture->format == SDL_PIXELFORMAT_YV12 ||
 texture->format == SDL_PIXELFORMAT_IYUV) {
 renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w/2,
 texture_h/2, 0, format, type, NULL);
 renderdata->glDisable(data->type);
 }
+GL_CheckError("", renderer);
 return 0;
 }
 static int
 GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
 const SDL_Rect * rect, const void *pixels, int pitch)
 {
 GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
 GL_TextureData *data = (GL_TextureData *) texture->driverdata;
-GLenum result;
 GL_ActivateRenderer(renderer);
-renderdata->glGetError();
+GL_CheckError("", renderer);
 renderdata->glEnable(data->type);
 renderdata->glBindTexture(data->type, data->texture);
 renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH,
 (pitch / SDL_BYTESPERPIXEL(texture->format)));
 renderdata->glTexSubImage2D(data->type, 0, rect->x/2, rect->y/2,
 rect->w/2, rect->h/2,
 data->format, data->formattype, pixels);
 }
 renderdata->glDisable(data->type);
-result = renderdata->glGetError();
+if (GL_CheckError("glTexSubImage2D()", renderer) > 0) {
-if (result != GL_NO_ERROR) {
-GL_SetError("glTexSubImage2D()", result);
 return -1;
 }
 return 0;
 }
 GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
 if (SDL_CurrentContext != data->context) {
 /* We'll update the viewport after we rebind the context */
 return 0;
+}
+if (!renderer->viewport.w || !renderer->viewport.h) {
+/* The viewport isn't set up yet, ignore it */
+return -1;
 }
 data->glViewport(renderer->viewport.x, renderer->viewport.y,
 renderer->viewport.w, renderer->viewport.h);
 (GLdouble) renderer->viewport.w,
 (GLdouble) renderer->viewport.h,
 (GLdouble) 0,
 0.0, 1.0);
 }
+GL_CheckError("", renderer);
 return 0;
 }
 static void
 GL_SetShader(GL_RenderData * data, GL_Shader shader)
 data->glVertex2f(0.5f + x2, 0.5f + y2);
 }
 #endif
 data->glEnd();
 }
+GL_CheckError("", renderer);
 return 0;
 }
 static int
 for (i = 0; i < count; ++i) {
 const SDL_Rect *rect = &rects[i];
 data->glRecti(rect->x, rect->y, rect->x + rect->w, rect->y + rect->h);
 }
+GL_CheckError("", renderer);
 return 0;
 }
 static int
 data->glTexCoord2f(maxu, maxv);
 data->glVertex2f((GLfloat) maxx, (GLfloat) maxy);
 data->glEnd();
 data->glDisable(texturedata->type);
+GL_CheckError("", renderer);
 return 0;
 }
 static int
 data->glEnd();
 data->glPopMatrix();
 data->glDisable(texturedata->type);
+GL_CheckError("", renderer);
 return 0;
 }
 static int
 GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
 data->glPixelStorei(GL_PACK_ROW_LENGTH,
 (temp_pitch / SDL_BYTESPERPIXEL(temp_format)));
 data->glReadPixels(rect->x, (h-rect->y)-rect->h, rect->w, rect->h,
 format, type, temp_pixels);
+GL_CheckError("", renderer);
 /* Flip the rows to be top-down */
 length = rect->w * SDL_BYTESPERPIXEL(temp_format);
 src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
 dst = (Uint8*)temp_pixels;
 if (data->context) {
 while (data->framebuffers) {
 GL_FBOList *nextnode = data->framebuffers->next;
 /* delete the framebuffer object */
 data->glDeleteFramebuffersEXT(1, &data->framebuffers->FBO);
+GL_CheckError("", renderer);
 SDL_free(data->framebuffers);
 data->framebuffers = nextnode;
 }
 /* SDL_GL_MakeCurrent(0, NULL); *//* doesn't do anything */
 SDL_GL_DeleteContext(data->context);

changeset 6494	309599be5c2a
parent 6449	fa00544b1374
child 6499	a34024340f54