git.sesse.net Git - ffmpeg/blob - libavdevice/opengl_enc.c

   1 /*
   2  * Copyright (c) 2014 Lukasz Marek
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 //TODO: support for more formats
  22 //TODO: support for more systems.
  23 //TODO: implement X11, Windows, Mac OS native default window. SDL 1.2 doesn't allow to render to custom thread.
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <stddef.h>
  30
  31 #include "config.h"
  32
  33 #if HAVE_OPENGL_GL3_H
  34 #include <OpenGL/gl3.h>
  35 #elif HAVE_ES2_GL_H
  36 #include <ES2/gl.h>
  37 #else
  38 #include <GL/gl.h>
  39 #include <GL/glext.h>
  40 #endif
  41 #if HAVE_GLXGETPROCADDRESS
  42 #include <GL/glx.h>
  43 #endif
  44 #if HAVE_WINDOWS_H
  45 #include <windows.h>
  46 #endif
  47
  48 #if HAVE_SDL
  49 #include <SDL.h>
  50 #endif
  51
  52 #include "libavutil/common.h"
  53 #include "libavutil/pixdesc.h"
  54 #include "libavutil/log.h"
  55 #include "libavutil/opt.h"
  56 #include "libavutil/avassert.h"
  57 #include "libavutil/avstring.h"
  58 #include "libavformat/avformat.h"
  59 #include "libavdevice/avdevice.h"
  60 #include "opengl_enc_shaders.h"
  61
  62 #ifndef APIENTRY
  63 #define APIENTRY
  64 #endif
  65
  66 /* GL_RED_COMPONENT is used for plannar pixel types.
  67  * Only red component is sampled in shaders.
  68  * On some platforms GL_RED is not availabe and GL_LUMINANCE have to be used,
  69  * but since OpenGL 3.0 GL_LUMINANCE is deprecated.
  70  * GL_RED produces RGBA = value, 0, 0, 1.
  71  * GL_LUMINANCE produces RGBA = value, value, value, 1.
  72  * Note: GL_INTENSITY may also be used which produce RGBA = value, value, value, value. */
  73 #if defined(GL_RED)
  74 #define GL_RED_COMPONENT GL_RED
  75 #elif defined(GL_LUMINANCE)
  76 #define GL_RED_COMPONENT GL_LUMINANCE
  77 #else
  78 #define GL_RED_COMPONENT 0x1903; //GL_RED
  79 #endif
  80
  81 /* Constants not defined for iOS */
  82 #define FF_GL_UNSIGNED_BYTE_3_3_2 0x8032
  83 #define FF_GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
  84 #define FF_GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
  85
  86 /* MinGW exposes only OpenGL 1.1 API */
  87 #define FF_GL_ARRAY_BUFFER                0x8892
  88 #define FF_GL_ELEMENT_ARRAY_BUFFER        0x8893
  89 #define FF_GL_STATIC_DRAW                 0x88E4
  90 #define FF_GL_FRAGMENT_SHADER             0x8B30
  91 #define FF_GL_VERTEX_SHADER               0x8B31
  92 #define FF_GL_COMPILE_STATUS              0x8B81
  93 #define FF_GL_LINK_STATUS                 0x8B82
  94 #define FF_GL_INFO_LOG_LENGTH             0x8B84
  95 typedef void   (APIENTRY *FF_PFNGLACTIVETEXTUREPROC) (GLenum texture);
  96 typedef void   (APIENTRY *FF_PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
  97 typedef void   (APIENTRY *FF_PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
  98 typedef void   (APIENTRY *FF_PFNGLBUFFERDATAPROC) (GLenum target, ptrdiff_t size, const GLvoid *data, GLenum usage);
  99 typedef void   (APIENTRY *FF_PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
 100 typedef GLint  (APIENTRY *FF_PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const char *name);
 101 typedef void   (APIENTRY *FF_PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index);
 102 typedef void   (APIENTRY *FF_PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, uintptr_t pointer);
 103 typedef GLint  (APIENTRY *FF_PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const char *name);
 104 typedef void   (APIENTRY *FF_PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0);
 105 typedef void   (APIENTRY *FF_PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
 106 typedef void   (APIENTRY *FF_PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
 107 typedef GLuint (APIENTRY *FF_PFNGLCREATEPROGRAMPROC) (void);
 108 typedef void   (APIENTRY *FF_PFNGLDELETEPROGRAMPROC) (GLuint program);
 109 typedef void   (APIENTRY *FF_PFNGLUSEPROGRAMPROC) (GLuint program);
 110 typedef void   (APIENTRY *FF_PFNGLLINKPROGRAMPROC) (GLuint program);
 111 typedef void   (APIENTRY *FF_PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params);
 112 typedef void   (APIENTRY *FF_PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, char *infoLog);
 113 typedef void   (APIENTRY *FF_PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
 114 typedef GLuint (APIENTRY *FF_PFNGLCREATESHADERPROC) (GLenum type);
 115 typedef void   (APIENTRY *FF_PFNGLDELETESHADERPROC) (GLuint shader);
 116 typedef void   (APIENTRY *FF_PFNGLCOMPILESHADERPROC) (GLuint shader);
 117 typedef void   (APIENTRY *FF_PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const char* *string, const GLint *length);
 118 typedef void   (APIENTRY *FF_PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
 119 typedef void   (APIENTRY *FF_PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, char *infoLog);
 120
 121 typedef struct FFOpenGLFunctions {
 122     FF_PFNGLACTIVETEXTUREPROC glActiveTexture;                     //Require GL ARB multitexture
 123     FF_PFNGLGENBUFFERSPROC glGenBuffers;                           //Require GL_ARB_vertex_buffer_object
 124     FF_PFNGLDELETEBUFFERSPROC glDeleteBuffers;                     //Require GL_ARB_vertex_buffer_object
 125     FF_PFNGLBUFFERDATAPROC glBufferData;                           //Require GL_ARB_vertex_buffer_object
 126     FF_PFNGLBINDBUFFERPROC glBindBuffer;                           //Require GL_ARB_vertex_buffer_object
 127     FF_PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation;             //Require GL_ARB_vertex_shader
 128     FF_PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray; //Require GL_ARB_vertex_shader
 129     FF_PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;         //Require GL_ARB_vertex_shader
 130     FF_PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;           //Require GL_ARB_shader_objects
 131     FF_PFNGLUNIFORM1FPROC glUniform1f;                             //Require GL_ARB_shader_objects
 132     FF_PFNGLUNIFORM1IPROC glUniform1i;                             //Require GL_ARB_shader_objects
 133     FF_PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;               //Require GL_ARB_shader_objects
 134     FF_PFNGLCREATEPROGRAMPROC glCreateProgram;                     //Require GL_ARB_shader_objects
 135     FF_PFNGLDELETEPROGRAMPROC glDeleteProgram;                     //Require GL_ARB_shader_objects
 136     FF_PFNGLUSEPROGRAMPROC glUseProgram;                           //Require GL_ARB_shader_objects
 137     FF_PFNGLLINKPROGRAMPROC glLinkProgram;                         //Require GL_ARB_shader_objects
 138     FF_PFNGLGETPROGRAMIVPROC glGetProgramiv;                       //Require GL_ARB_shader_objects
 139     FF_PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;             //Require GL_ARB_shader_objects
 140     FF_PFNGLATTACHSHADERPROC glAttachShader;                       //Require GL_ARB_shader_objects
 141     FF_PFNGLCREATESHADERPROC glCreateShader;                       //Require GL_ARB_shader_objects
 142     FF_PFNGLDELETESHADERPROC glDeleteShader;                       //Require GL_ARB_shader_objects
 143     FF_PFNGLCOMPILESHADERPROC glCompileShader;                     //Require GL_ARB_shader_objects
 144     FF_PFNGLSHADERSOURCEPROC glShaderSource;                       //Require GL_ARB_shader_objects
 145     FF_PFNGLGETSHADERIVPROC glGetShaderiv;                         //Require GL_ARB_shader_objects
 146     FF_PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;               //Require GL_ARB_shader_objects
 147 } FFOpenGLFunctions;
 148
 149 #define OPENGL_ERROR_CHECK(ctx) \
 150 {\
 151     GLenum err_code; \
 152     if ((err_code = glGetError()) != GL_NO_ERROR) { \
 153         av_log(ctx, AV_LOG_ERROR, "OpenGL error occurred in '%s', line %d: %d\n", __FUNCTION__, __LINE__, err_code); \
 154         goto fail; \
 155     } \
 156 }\
 157
 158 typedef struct OpenGLVertexInfo
 159 {
 160     float x, y, z;    ///<Position
 161     float s0, t0;     ///<Texture coords
 162 } OpenGLVertexInfo;
 163
 164 /* defines 2 triangles to display */
 165 static GLushort g_index[6] =
 166 {
 167     0, 1, 2,
 168     0, 3, 2,
 169 };
 170
 171 typedef struct OpenGLContext {
 172     AVClass *class;                    ///< class for private options
 173
 174 #if HAVE_SDL
 175     SDL_Surface *surface;
 176 #endif
 177     FFOpenGLFunctions glprocs;
 178
 179     uint8_t background[4];             ///< Background color
 180     int no_window;                     ///< 0 for create default window
 181     char *window_title;                ///< Title of the window
 182
 183     /* OpenGL implementation limits */
 184     GLint max_texture_size;            ///< Maximum texture size
 185     GLint max_viewport_width;          ///< Maximum viewport size
 186     GLint max_viewport_height;         ///< Maximum viewport size
 187     int non_pow_2_textures;            ///< 1 when non power of 2 textures are supported
 188
 189     /* Current OpenGL configuration */
 190     GLuint program;                    ///< Shader program
 191     GLuint texture_name[4];            ///< Textures' IDs
 192     GLuint index_buffer;               ///< Index buffer
 193     GLuint vertex_buffer;              ///< Vertex buffer
 194     OpenGLVertexInfo vertex[4];        ///< VBO
 195     GLint projection_matrix_location;  ///< Uniforms' locations
 196     GLint model_view_matrix_location;
 197     GLint color_map_location;
 198     GLint chroma_div_w_location;
 199     GLint chroma_div_h_location;
 200     GLint texture_location[4];
 201     GLint position_attrib;             ///< Attibutes' locations
 202     GLint texture_coords_attrib;
 203
 204     GLfloat projection_matrix[16];     ///< Projection matrix
 205     GLfloat model_view_matrix[16];     ///< Modev view matrix
 206     GLfloat color_map[16];             ///< RGBA color map matrix
 207     GLfloat chroma_div_w;              ///< Chroma subsampling w ratio
 208     GLfloat chroma_div_h;              ///< Chroma subsampling h ratio
 209
 210     /* Stream information */
 211     GLenum format;
 212     GLenum type;
 213     int width;                         ///< Stream width
 214     int height;                        ///< Stream height
 215     enum AVPixelFormat pix_fmt;        ///< Stream pixel format
 216     int picture_width;                 ///< Rendered width
 217     int picture_height;                ///< Rendered height
 218     int window_width;
 219     int window_height;
 220 } OpenGLContext;
 221
 222 static av_cold int opengl_prepare_vertex(AVFormatContext *s);
 223 static int opengl_draw(AVFormatContext *h, AVPacket *pkt, int repaint);
 224 static av_cold int opengl_init_context(OpenGLContext *opengl);
 225
 226 static int opengl_resize(AVFormatContext *h, int width, int height)
 227 {
 228     int ret = 0;
 229     OpenGLContext *opengl = h->priv_data;
 230     opengl->window_width = width;
 231     opengl->window_height = height;
 232     /* max_viewport_width == 0 means write_header was not called yet. */
 233     if (opengl->max_viewport_width) {
 234         if (opengl->no_window &&
 235             (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0)) < 0) {
 236             av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
 237             goto end;
 238         }
 239         if ((ret = opengl_prepare_vertex(h)) < 0)
 240             goto end;
 241         ret = opengl_draw(h, NULL, 1);
 242     }
 243   end:
 244     return ret;
 245 }
 246
 247 static int opengl_control_message(AVFormatContext *h, int type, void *data, size_t data_size)
 248 {
 249     OpenGLContext *opengl = h->priv_data;
 250     switch(type) {
 251     case AV_APP_TO_DEV_WINDOW_SIZE:
 252         if (data) {
 253             AVDeviceRect *message = data;
 254             return opengl_resize(h, message->width, message->height);
 255         }
 256         return AVERROR(EINVAL);
 257     case AV_APP_TO_DEV_WINDOW_REPAINT:
 258         return opengl_resize(h, opengl->window_width, opengl->window_height);
 259     }
 260     return AVERROR(ENOSYS);
 261 }
 262
 263 #if HAVE_SDL
 264 static int opengl_sdl_recreate_window(OpenGLContext *opengl, int width, int height)
 265 {
 266     opengl->surface = SDL_SetVideoMode(width, height,
 267                                        32, SDL_OPENGL | SDL_RESIZABLE);
 268     if (!opengl->surface) {
 269         av_log(opengl, AV_LOG_ERROR, "Unable to set video mode: %s\n", SDL_GetError());
 270         return AVERROR_EXTERNAL;
 271     }
 272     SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
 273     SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
 274     SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
 275     SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
 276     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 277     return 0;
 278 }
 279
 280 static int opengl_sdl_process_events(AVFormatContext *h)
 281 {
 282     int ret;
 283     OpenGLContext *opengl = h->priv_data;
 284     SDL_Event event;
 285     SDL_PumpEvents();
 286     while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_ALLEVENTS) > 0) {
 287         switch (event.type) {
 288         case SDL_QUIT:
 289             return AVERROR(EIO);
 290         case SDL_KEYDOWN:
 291             switch (event.key.keysym.sym) {
 292             case SDLK_ESCAPE:
 293             case SDLK_q:
 294                 return AVERROR(EIO);
 295             }
 296             return 0;
 297         case SDL_VIDEORESIZE: {
 298             char buffer[100];
 299             int reinit;
 300             AVDeviceRect message;
 301             /* clean up old context because SDL_SetVideoMode may lose its state. */
 302             SDL_VideoDriverName(buffer, sizeof(buffer));
 303             reinit = !av_strncasecmp(buffer, "quartz", sizeof(buffer));
 304             if (reinit) {
 305                 glDeleteTextures(4, opengl->texture_name);
 306                 opengl->glprocs.glDeleteBuffers(2, &opengl->index_buffer);
 307             }
 308             if ((ret = opengl_sdl_recreate_window(opengl, event.resize.w, event.resize.h)) < 0)
 309                 return ret;
 310             if (reinit && (ret = opengl_init_context(opengl)) < 0)
 311                 return ret;
 312             message.width = opengl->surface->w;
 313             message.height = opengl->surface->h;
 314             return opengl_control_message(h, AV_APP_TO_DEV_WINDOW_SIZE, &message, sizeof(AVDeviceRect));
 315             }
 316         }
 317     }
 318     return 0;
 319 }
 320
 321 static int av_cold opengl_sdl_create_window(AVFormatContext *h)
 322 {
 323     int ret;
 324     char buffer[100];
 325     OpenGLContext *opengl = h->priv_data;
 326     AVDeviceRect message;
 327     if (SDL_Init(SDL_INIT_VIDEO)) {
 328         av_log(opengl, AV_LOG_ERROR, "Unable to initialize SDL: %s\n", SDL_GetError());
 329         return AVERROR_EXTERNAL;
 330     }
 331     if ((ret = opengl_sdl_recreate_window(opengl, opengl->width, opengl->height)) < 0)
 332         return ret;
 333     av_log(opengl, AV_LOG_INFO, "SDL driver: '%s'.\n", SDL_VideoDriverName(buffer, sizeof(buffer)));
 334     message.width = opengl->surface->w;
 335     message.height = opengl->surface->h;
 336     opengl_control_message(h, AV_APP_TO_DEV_WINDOW_SIZE, &message, sizeof(AVDeviceRect));
 337     return 0;
 338 }
 339
 340 static int av_cold opengl_sdl_load_procedures(OpenGLContext *opengl)
 341 {
 342     FFOpenGLFunctions *procs = &opengl->glprocs;
 343
 344 #define LOAD_OPENGL_FUN(name, type) \
 345     procs->name = (type)SDL_GL_GetProcAddress(#name); \
 346     if (!procs->name) { \
 347         av_log(opengl, AV_LOG_ERROR, "Cannot load OpenGL function: '%s'\n", #name); \
 348         return AVERROR(ENOSYS); \
 349     }
 350
 351     LOAD_OPENGL_FUN(glActiveTexture, FF_PFNGLACTIVETEXTUREPROC)
 352     LOAD_OPENGL_FUN(glGenBuffers, FF_PFNGLGENBUFFERSPROC)
 353     LOAD_OPENGL_FUN(glDeleteBuffers, FF_PFNGLDELETEBUFFERSPROC)
 354     LOAD_OPENGL_FUN(glBufferData, FF_PFNGLBUFFERDATAPROC)
 355     LOAD_OPENGL_FUN(glBindBuffer, FF_PFNGLBINDBUFFERPROC)
 356     LOAD_OPENGL_FUN(glGetAttribLocation, FF_PFNGLGETATTRIBLOCATIONPROC)
 357     LOAD_OPENGL_FUN(glGetUniformLocation, FF_PFNGLGETUNIFORMLOCATIONPROC)
 358     LOAD_OPENGL_FUN(glUniform1f, FF_PFNGLUNIFORM1FPROC)
 359     LOAD_OPENGL_FUN(glUniform1i, FF_PFNGLUNIFORM1IPROC)
 360     LOAD_OPENGL_FUN(glUniformMatrix4fv, FF_PFNGLUNIFORMMATRIX4FVPROC)
 361     LOAD_OPENGL_FUN(glCreateProgram, FF_PFNGLCREATEPROGRAMPROC)
 362     LOAD_OPENGL_FUN(glDeleteProgram, FF_PFNGLDELETEPROGRAMPROC)
 363     LOAD_OPENGL_FUN(glUseProgram, FF_PFNGLUSEPROGRAMPROC)
 364     LOAD_OPENGL_FUN(glLinkProgram, FF_PFNGLLINKPROGRAMPROC)
 365     LOAD_OPENGL_FUN(glGetProgramiv, FF_PFNGLGETPROGRAMIVPROC)
 366     LOAD_OPENGL_FUN(glGetProgramInfoLog, FF_PFNGLGETPROGRAMINFOLOGPROC)
 367     LOAD_OPENGL_FUN(glAttachShader, FF_PFNGLATTACHSHADERPROC)
 368     LOAD_OPENGL_FUN(glCreateShader, FF_PFNGLCREATESHADERPROC)
 369     LOAD_OPENGL_FUN(glDeleteShader, FF_PFNGLDELETESHADERPROC)
 370     LOAD_OPENGL_FUN(glCompileShader, FF_PFNGLCOMPILESHADERPROC)
 371     LOAD_OPENGL_FUN(glShaderSource, FF_PFNGLSHADERSOURCEPROC)
 372     LOAD_OPENGL_FUN(glGetShaderiv, FF_PFNGLGETSHADERIVPROC)
 373     LOAD_OPENGL_FUN(glGetShaderInfoLog, FF_PFNGLGETSHADERINFOLOGPROC)
 374     LOAD_OPENGL_FUN(glEnableVertexAttribArray, FF_PFNGLENABLEVERTEXATTRIBARRAYPROC)
 375     LOAD_OPENGL_FUN(glVertexAttribPointer, FF_PFNGLVERTEXATTRIBPOINTERPROC)
 376
 377     return 0;
 378
 379 #undef LOAD_OPENGL_FUN
 380 }
 381 #endif /* HAVE_SDL */
 382
 383 #if defined(__APPLE__)
 384 static int av_cold opengl_load_procedures(OpenGLContext *opengl)
 385 {
 386     FFOpenGLFunctions *procs = &opengl->glprocs;
 387
 388     procs->glActiveTexture = glActiveTexture;
 389     procs->glGenBuffers = glGenBuffers;
 390     procs->glDeleteBuffers = glDeleteBuffers;
 391     procs->glBufferData = glBufferData;
 392     procs->glBindBuffer = glBindBuffer;
 393     procs->glGetAttribLocation = glGetAttribLocation;
 394     procs->glGetUniformLocation = glGetUniformLocation;
 395     procs->glUniform1f = glUniform1f;
 396     procs->glUniform1i = glUniform1i;
 397     procs->glUniformMatrix4fv = glUniformMatrix4fv;
 398     procs->glCreateProgram = glCreateProgram;
 399     procs->glDeleteProgram = glDeleteProgram;
 400     procs->glUseProgram = glUseProgram;
 401     procs->glLinkProgram = glLinkProgram;
 402     procs->glGetProgramiv = glGetProgramiv;
 403     procs->glGetProgramInfoLog = glGetProgramInfoLog;
 404     procs->glAttachShader = glAttachShader;
 405     procs->glCreateShader = glCreateShader;
 406     procs->glDeleteShader = glDeleteShader;
 407     procs->glCompileShader = glCompileShader;
 408     procs->glShaderSource = glShaderSource;
 409     procs->glGetShaderiv = glGetShaderiv;
 410     procs->glGetShaderInfoLog = glGetShaderInfoLog;
 411     procs->glEnableVertexAttribArray = glEnableVertexAttribArray;
 412     procs->glVertexAttribPointer = (FF_PFNGLVERTEXATTRIBPOINTERPROC) glVertexAttribPointer;
 413     return 0;
 414 }
 415 #else
 416 static int av_cold opengl_load_procedures(OpenGLContext *opengl)
 417 {
 418     FFOpenGLFunctions *procs = &opengl->glprocs;
 419
 420 #if HAVE_GLXGETPROCADDRESS
 421 #define SelectedGetProcAddress glXGetProcAddress
 422 #elif HAVE_WGLGETPROCADDRESS
 423 #define SelectedGetProcAddress wglGetProcAddress
 424 #endif
 425
 426 #define LOAD_OPENGL_FUN(name, type) \
 427     procs->name = (type)SelectedGetProcAddress(#name); \
 428     if (!procs->name) { \
 429         av_log(opengl, AV_LOG_ERROR, "Cannot load OpenGL function: '%s'\n", #name); \
 430         return AVERROR(ENOSYS); \
 431     }
 432
 433     LOAD_OPENGL_FUN(glActiveTexture, FF_PFNGLACTIVETEXTUREPROC)
 434     LOAD_OPENGL_FUN(glGenBuffers, FF_PFNGLGENBUFFERSPROC)
 435     LOAD_OPENGL_FUN(glDeleteBuffers, FF_PFNGLDELETEBUFFERSPROC)
 436     LOAD_OPENGL_FUN(glBufferData, FF_PFNGLBUFFERDATAPROC)
 437     LOAD_OPENGL_FUN(glBindBuffer, FF_PFNGLBINDBUFFERPROC)
 438     LOAD_OPENGL_FUN(glGetAttribLocation, FF_PFNGLGETATTRIBLOCATIONPROC)
 439     LOAD_OPENGL_FUN(glGetUniformLocation, FF_PFNGLGETUNIFORMLOCATIONPROC)
 440     LOAD_OPENGL_FUN(glUniform1f, FF_PFNGLUNIFORM1FPROC)
 441     LOAD_OPENGL_FUN(glUniform1i, FF_PFNGLUNIFORM1IPROC)
 442     LOAD_OPENGL_FUN(glUniformMatrix4fv, FF_PFNGLUNIFORMMATRIX4FVPROC)
 443     LOAD_OPENGL_FUN(glCreateProgram, FF_PFNGLCREATEPROGRAMPROC)
 444     LOAD_OPENGL_FUN(glDeleteProgram, FF_PFNGLDELETEPROGRAMPROC)
 445     LOAD_OPENGL_FUN(glUseProgram, FF_PFNGLUSEPROGRAMPROC)
 446     LOAD_OPENGL_FUN(glLinkProgram, FF_PFNGLLINKPROGRAMPROC)
 447     LOAD_OPENGL_FUN(glGetProgramiv, FF_PFNGLGETPROGRAMIVPROC)
 448     LOAD_OPENGL_FUN(glGetProgramInfoLog, FF_PFNGLGETPROGRAMINFOLOGPROC)
 449     LOAD_OPENGL_FUN(glAttachShader, FF_PFNGLATTACHSHADERPROC)
 450     LOAD_OPENGL_FUN(glCreateShader, FF_PFNGLCREATESHADERPROC)
 451     LOAD_OPENGL_FUN(glDeleteShader, FF_PFNGLDELETESHADERPROC)
 452     LOAD_OPENGL_FUN(glCompileShader, FF_PFNGLCOMPILESHADERPROC)
 453     LOAD_OPENGL_FUN(glShaderSource, FF_PFNGLSHADERSOURCEPROC)
 454     LOAD_OPENGL_FUN(glGetShaderiv, FF_PFNGLGETSHADERIVPROC)
 455     LOAD_OPENGL_FUN(glGetShaderInfoLog, FF_PFNGLGETSHADERINFOLOGPROC)
 456     LOAD_OPENGL_FUN(glEnableVertexAttribArray, FF_PFNGLENABLEVERTEXATTRIBARRAYPROC)
 457     LOAD_OPENGL_FUN(glVertexAttribPointer, FF_PFNGLVERTEXATTRIBPOINTERPROC)
 458
 459     return 0;
 460
 461 #undef SelectedGetProcAddress
 462 #undef LOAD_OPENGL_FUN
 463 }
 464 #endif
 465
 466 static av_always_inline void opengl_make_identity(float matrix[16])
 467 {
 468     memset(matrix, 0, 16 * sizeof(float));
 469     matrix[0] = matrix[5] = matrix[10] = matrix[15] = 1.0f;
 470 }
 471
 472 static av_always_inline void opengl_make_ortho(float matrix[16],
 473                                                float left,   float right,
 474                                                float bottom, float top,
 475                                                float nearZ,  float farZ)
 476 {
 477     float ral = right + left;
 478     float rsl = right - left;
 479     float tab = top + bottom;
 480     float tsb = top - bottom;
 481     float fan = farZ + nearZ;
 482     float fsn = farZ - nearZ;
 483
 484     memset(matrix, 0, 16 * sizeof(float));
 485     matrix[0] = 2.0f / rsl;
 486     matrix[5] = 2.0f / tsb;
 487     matrix[10] = -2.0f / fsn;
 488     matrix[12] = -ral / rsl;
 489     matrix[13] = -tab / tsb;
 490     matrix[14] = -fan / fsn;
 491     matrix[15] = 1.0f;
 492 }
 493
 494 static av_cold int opengl_read_limits(OpenGLContext *opengl)
 495 {
 496     static const struct{
 497         const char *extention;
 498         int major;
 499         int minor;
 500     } required_extensions[] = {
 501         { "GL_ARB_multitexture",         1, 3 },
 502         { "GL_ARB_vertex_buffer_object", 1, 5 }, //GLX_ARB_vertex_buffer_object
 503         { "GL_ARB_vertex_shader",        2, 0 },
 504         { "GL_ARB_fragment_shader",      2, 0 },
 505         { "GL_ARB_shader_objects",       2, 0 },
 506         { NULL,                          0, 0 }
 507     };
 508     int i, major, minor;
 509     const char *extensions, *version;
 510
 511     version = glGetString(GL_VERSION);
 512     extensions = glGetString(GL_EXTENSIONS);
 513
 514     av_log(opengl, AV_LOG_DEBUG, "OpenGL version: %s\n", version);
 515     sscanf(version, "%d.%d", &major, &minor);
 516
 517     for (i = 0; required_extensions[i].extention; i++) {
 518         if (major < required_extensions[i].major &&
 519             (major == required_extensions[i].major && minor < required_extensions[i].minor) &&
 520             !strstr(extensions, required_extensions[i].extention)) {
 521             av_log(opengl, AV_LOG_ERROR, "Required extension %s is not supported.\n",
 522                    required_extensions[i].extention);
 523             av_log(opengl, AV_LOG_DEBUG, "Supported extensions are: %s\n", extensions);
 524             return AVERROR(ENOSYS);
 525         }
 526     }
 527     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &opengl->max_texture_size);
 528     glGetIntegerv(GL_MAX_VIEWPORT_DIMS, &opengl->max_viewport_width);
 529     opengl->non_pow_2_textures = major >= 2 || strstr(extensions, "GL_ARB_texture_non_power_of_two");
 530
 531     av_log(opengl, AV_LOG_DEBUG, "Non Power of 2 textures support: %s\n", opengl->non_pow_2_textures ? "Yes" : "No");
 532     av_log(opengl, AV_LOG_DEBUG, "Max texture size: %dx%d\n", opengl->max_texture_size, opengl->max_texture_size);
 533     av_log(opengl, AV_LOG_DEBUG, "Max viewport size: %dx%d\n",
 534            opengl->max_viewport_width, opengl->max_viewport_height);
 535
 536     OPENGL_ERROR_CHECK(opengl);
 537     return 0;
 538   fail:
 539     return AVERROR_EXTERNAL;
 540 }
 541
 542 static av_always_inline const char * opengl_get_fragment_shader_code(enum AVPixelFormat format)
 543 {
 544     switch (format) {
 545     case AV_PIX_FMT_YUV420P:    case AV_PIX_FMT_YUV444P:
 546     case AV_PIX_FMT_YUV422P:    case AV_PIX_FMT_YUV410P:
 547     case AV_PIX_FMT_YUV411P:    case AV_PIX_FMT_YUV440P:
 548     case AV_PIX_FMT_YUV420P16:  case AV_PIX_FMT_YUV422P16:
 549     case AV_PIX_FMT_YUV444P16:
 550         return FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR;
 551     case AV_PIX_FMT_YUVA420P:   case AV_PIX_FMT_YUVA444P:
 552     case AV_PIX_FMT_YUVA422P:
 553     case AV_PIX_FMT_YUVA420P16: case AV_PIX_FMT_YUVA422P16:
 554     case AV_PIX_FMT_YUVA444P16:
 555         return FF_OPENGL_FRAGMENT_SHADER_YUVA_PLANAR;
 556     case AV_PIX_FMT_RGB24:      case AV_PIX_FMT_BGR24:
 557     case AV_PIX_FMT_0RGB:       case AV_PIX_FMT_RGB0:
 558     case AV_PIX_FMT_0BGR:       case AV_PIX_FMT_BGR0:
 559     case AV_PIX_FMT_RGB565:     case AV_PIX_FMT_BGR565:
 560     case AV_PIX_FMT_RGB555:     case AV_PIX_FMT_BGR555:
 561     case AV_PIX_FMT_RGB8:       case AV_PIX_FMT_BGR8:
 562     case AV_PIX_FMT_RGB48:
 563         return FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET;
 564     case AV_PIX_FMT_ARGB:       case AV_PIX_FMT_RGBA:
 565     case AV_PIX_FMT_ABGR:       case AV_PIX_FMT_BGRA:
 566     case AV_PIX_FMT_RGBA64:     case AV_PIX_FMT_BGRA64:
 567         return FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET;
 568     case AV_PIX_FMT_GBRP:       case AV_PIX_FMT_GBRP16:
 569         return FF_OPENGL_FRAGMENT_SHADER_RGB_PLANAR;
 570     case AV_PIX_FMT_GBRAP: case AV_PIX_FMT_GBRAP16:
 571         return FF_OPENGL_FRAGMENT_SHADER_RGBA_PLANAR;
 572     default:
 573         break;
 574     }
 575     return NULL;
 576 }
 577
 578 static av_always_inline int opengl_type_size(GLenum type)
 579 {
 580     switch(type) {
 581     case GL_UNSIGNED_SHORT:
 582     case FF_GL_UNSIGNED_SHORT_1_5_5_5_REV:
 583     case GL_UNSIGNED_SHORT_5_6_5:
 584         return 2;
 585     case GL_UNSIGNED_BYTE:
 586     case FF_GL_UNSIGNED_BYTE_3_3_2:
 587     case FF_GL_UNSIGNED_BYTE_2_3_3_REV:
 588     default:
 589         break;
 590     }
 591     return 1;
 592 }
 593
 594 static av_cold void opengl_get_texture_params(OpenGLContext *opengl)
 595 {
 596     switch(opengl->pix_fmt) {
 597     case AV_PIX_FMT_YUV420P:    case AV_PIX_FMT_YUV444P:
 598     case AV_PIX_FMT_YUV422P:    case AV_PIX_FMT_YUV410P:
 599     case AV_PIX_FMT_YUV411P:    case AV_PIX_FMT_YUV440P:
 600     case AV_PIX_FMT_YUVA420P:   case AV_PIX_FMT_YUVA444P:
 601     case AV_PIX_FMT_YUVA422P:
 602     case AV_PIX_FMT_GBRP:       case AV_PIX_FMT_GBRAP:
 603         opengl->format = GL_RED_COMPONENT;
 604         opengl->type   = GL_UNSIGNED_BYTE;
 605         break;
 606     case AV_PIX_FMT_YUV420P16:  case AV_PIX_FMT_YUV422P16:
 607     case AV_PIX_FMT_YUV444P16:
 608     case AV_PIX_FMT_YUVA420P16: case AV_PIX_FMT_YUVA422P16:
 609     case AV_PIX_FMT_YUVA444P16:
 610     case AV_PIX_FMT_GBRP16:     case AV_PIX_FMT_GBRAP16:
 611         opengl->format = GL_RED_COMPONENT;
 612         opengl->type   = GL_UNSIGNED_SHORT;
 613         break;
 614     case AV_PIX_FMT_RGB24:      case AV_PIX_FMT_BGR24:
 615         opengl->format = GL_RGB;
 616         opengl->type   = GL_UNSIGNED_BYTE;
 617         break;
 618     case AV_PIX_FMT_ARGB:       case AV_PIX_FMT_RGBA:
 619     case AV_PIX_FMT_ABGR:       case AV_PIX_FMT_BGRA:
 620     case AV_PIX_FMT_0RGB:       case AV_PIX_FMT_RGB0:
 621     case AV_PIX_FMT_0BGR:       case AV_PIX_FMT_BGR0:
 622         opengl->format = GL_RGBA;
 623         opengl->type   = GL_UNSIGNED_BYTE;
 624         break;
 625     case AV_PIX_FMT_RGB8:
 626         opengl->format = GL_RGB;
 627         opengl->type   = FF_GL_UNSIGNED_BYTE_3_3_2;
 628         break;
 629     case AV_PIX_FMT_BGR8:
 630         opengl->format = GL_RGB;
 631         opengl->type   = FF_GL_UNSIGNED_BYTE_2_3_3_REV;
 632         break;
 633     case AV_PIX_FMT_RGB555:     case AV_PIX_FMT_BGR555:
 634         opengl->format = GL_RGBA;
 635         opengl->type   = FF_GL_UNSIGNED_SHORT_1_5_5_5_REV;
 636         break;
 637     case AV_PIX_FMT_RGB565:     case AV_PIX_FMT_BGR565:
 638         opengl->format = GL_RGB;
 639         opengl->type   = GL_UNSIGNED_SHORT_5_6_5;
 640         break;
 641     case AV_PIX_FMT_RGB48:
 642         opengl->format = GL_RGB;
 643         opengl->type   = GL_UNSIGNED_SHORT;
 644         break;
 645     case AV_PIX_FMT_RGBA64:     case AV_PIX_FMT_BGRA64:
 646         opengl->format = GL_RGBA;
 647         opengl->type   = GL_UNSIGNED_SHORT;
 648         break;
 649     }
 650 }
 651
 652 static void opengl_compute_display_area(AVFormatContext *s)
 653 {
 654     AVRational sar, dar; /* sample and display aspect ratios */
 655     OpenGLContext *opengl = s->priv_data;
 656     AVStream *st = s->streams[0];
 657     AVCodecContext *encctx = st->codec;
 658
 659     /* compute overlay width and height from the codec context information */
 660     sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 };
 661     dar = av_mul_q(sar, (AVRational){ encctx->width, encctx->height });
 662
 663     /* we suppose the screen has a 1/1 sample aspect ratio */
 664     /* fit in the window */
 665     if (av_cmp_q(dar, (AVRational){ opengl->window_width, opengl->window_height }) > 0) {
 666         /* fit in width */
 667         opengl->picture_width = opengl->window_width;
 668         opengl->picture_height = av_rescale(opengl->picture_width, dar.den, dar.num);
 669     } else {
 670         /* fit in height */
 671         opengl->picture_height = opengl->window_height;
 672         opengl->picture_width = av_rescale(opengl->picture_height, dar.num, dar.den);
 673     }
 674 }
 675
 676 static av_cold void opengl_get_texture_size(OpenGLContext *opengl, int in_width, int in_height,
 677                                             int *out_width, int *out_height)
 678 {
 679     if (opengl->non_pow_2_textures) {
 680         *out_width = in_width;
 681         *out_height = in_height;
 682     } else {
 683         int max = FFMIN(FFMAX(in_width, in_height), opengl->max_texture_size);
 684         unsigned power_of_2 = 1;
 685         while (power_of_2 < max)
 686             power_of_2 *= 2;
 687         *out_height = power_of_2;
 688         *out_width = power_of_2;
 689         av_log(opengl, AV_LOG_DEBUG, "Texture size calculated from %dx%d into %dx%d\n",
 690                in_width, in_height, *out_width, *out_height);
 691     }
 692 }
 693
 694 static av_cold void opengl_fill_color_map(OpenGLContext *opengl)
 695 {
 696     const AVPixFmtDescriptor *desc;
 697     int shift;
 698     enum AVPixelFormat pix_fmt = opengl->pix_fmt;
 699
 700     /* We need order of components, not exact position, some minor HACKs here */
 701     if (pix_fmt == AV_PIX_FMT_RGB565 || pix_fmt == AV_PIX_FMT_BGR555 ||
 702         pix_fmt == AV_PIX_FMT_BGR8   || pix_fmt == AV_PIX_FMT_RGB8)
 703         pix_fmt = AV_PIX_FMT_RGB24;
 704     else if (pix_fmt == AV_PIX_FMT_BGR565 || pix_fmt == AV_PIX_FMT_RGB555)
 705         pix_fmt = AV_PIX_FMT_BGR24;
 706
 707     desc = av_pix_fmt_desc_get(pix_fmt);
 708     if (!(desc->flags & AV_PIX_FMT_FLAG_RGB))
 709         return;
 710
 711 #define FILL_COMPONENT(i) { \
 712         shift = desc->comp[i].depth_minus1 >> 3; \
 713         opengl->color_map[(i << 2) + ((desc->comp[i].offset_plus1 - 1) >> shift)] = 1.0; \
 714     }
 715
 716     memset(opengl->color_map, 0, sizeof(opengl->color_map));
 717     FILL_COMPONENT(0);
 718     FILL_COMPONENT(1);
 719     FILL_COMPONENT(2);
 720     if (desc->flags & AV_PIX_FMT_FLAG_ALPHA)
 721         FILL_COMPONENT(3);
 722
 723 #undef FILL_COMPONENT
 724 }
 725
 726 static av_cold GLuint opengl_load_shader(OpenGLContext *opengl, GLenum type, const char *source)
 727 {
 728     GLuint shader = opengl->glprocs.glCreateShader(type);
 729     GLint result;
 730     if (!shader) {
 731         av_log(opengl, AV_LOG_ERROR, "glCreateShader() failed\n");
 732         return 0;
 733     }
 734     opengl->glprocs.glShaderSource(shader, 1, &source, NULL);
 735     opengl->glprocs.glCompileShader(shader);
 736
 737     opengl->glprocs.glGetShaderiv(shader, FF_GL_COMPILE_STATUS, &result);
 738     if (!result) {
 739         char *log;
 740         opengl->glprocs.glGetShaderiv(shader, FF_GL_INFO_LOG_LENGTH, &result);
 741         if (result) {
 742             if ((log = av_malloc(result))) {
 743                 opengl->glprocs.glGetShaderInfoLog(shader, result, NULL, log);
 744                 av_log(opengl, AV_LOG_ERROR, "Compile error: %s\n", log);
 745                 av_free(log);
 746             }
 747         }
 748         goto fail;
 749     }
 750     OPENGL_ERROR_CHECK(opengl);
 751     return shader;
 752   fail:
 753     opengl->glprocs.glDeleteShader(shader);
 754     return 0;
 755 }
 756
 757 static av_cold int opengl_compile_shaders(OpenGLContext *opengl, enum AVPixelFormat pix_fmt)
 758 {
 759     GLuint vertex_shader = 0, fragment_shader = 0;
 760     GLint result;
 761     const char *fragment_shader_code = opengl_get_fragment_shader_code(pix_fmt);
 762
 763     if (!fragment_shader_code) {
 764         av_log(opengl, AV_LOG_ERROR, "Provided pixel format '%s' is not supported\n",
 765                av_get_pix_fmt_name(pix_fmt));
 766         return AVERROR(EINVAL);
 767     }
 768
 769     vertex_shader = opengl_load_shader(opengl, FF_GL_VERTEX_SHADER,
 770                                        FF_OPENGL_VERTEX_SHADER);
 771     if (!vertex_shader) {
 772         av_log(opengl, AV_LOG_ERROR, "Vertex shader loading failed.\n");
 773         goto fail;
 774     }
 775     fragment_shader = opengl_load_shader(opengl, FF_GL_FRAGMENT_SHADER,
 776                                          fragment_shader_code);
 777     if (!fragment_shader) {
 778         av_log(opengl, AV_LOG_ERROR, "Fragment shader loading failed.\n");
 779         goto fail;
 780     }
 781
 782     opengl->program = opengl->glprocs.glCreateProgram();
 783     if (!opengl->program)
 784         goto fail;
 785
 786     opengl->glprocs.glAttachShader(opengl->program, vertex_shader);
 787     opengl->glprocs.glAttachShader(opengl->program, fragment_shader);
 788     opengl->glprocs.glLinkProgram(opengl->program);
 789
 790     opengl->glprocs.glGetProgramiv(opengl->program, FF_GL_LINK_STATUS, &result);
 791     if (!result) {
 792         char *log;
 793         opengl->glprocs.glGetProgramiv(opengl->program, FF_GL_INFO_LOG_LENGTH, &result);
 794         if (result) {
 795             log = av_malloc(result);
 796             if (!log)
 797                 goto fail;
 798             opengl->glprocs.glGetProgramInfoLog(opengl->program, result, NULL, log);
 799             av_log(opengl, AV_LOG_ERROR, "Link error: %s\n", log);
 800             av_free(log);
 801         }
 802         goto fail;
 803     }
 804
 805     opengl->position_attrib = opengl->glprocs.glGetAttribLocation(opengl->program, "a_position");
 806     opengl->texture_coords_attrib = opengl->glprocs.glGetAttribLocation(opengl->program, "a_textureCoords");
 807     opengl->projection_matrix_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_projectionMatrix");
 808     opengl->model_view_matrix_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_modelViewMatrix");
 809     opengl->color_map_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_colorMap");
 810     opengl->texture_location[0] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture0");
 811     opengl->texture_location[1] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture1");
 812     opengl->texture_location[2] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture2");
 813     opengl->texture_location[3] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture3");
 814     opengl->chroma_div_w_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_chroma_div_w");
 815     opengl->chroma_div_h_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_chroma_div_h");
 816
 817     OPENGL_ERROR_CHECK(opengl);
 818     return 0;
 819   fail:
 820     opengl->glprocs.glDeleteShader(vertex_shader);
 821     opengl->glprocs.glDeleteShader(fragment_shader);
 822     opengl->glprocs.glDeleteProgram(opengl->program);
 823     opengl->program = 0;
 824     return AVERROR_EXTERNAL;
 825 }
 826
 827 static av_cold int opengl_configure_texture(OpenGLContext *opengl, GLuint texture,
 828                                             GLsizei width, GLsizei height)
 829 {
 830     if (texture) {
 831         int new_width, new_height;
 832         opengl_get_texture_size(opengl, width, height, &new_width, &new_height);
 833         glBindTexture(GL_TEXTURE_2D, texture);
 834         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 835         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 836         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 837         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 838         glTexImage2D(GL_TEXTURE_2D, 0, opengl->format, new_width, new_height, 0,
 839                      opengl->format, opengl->type, NULL);
 840         OPENGL_ERROR_CHECK(NULL);
 841     }
 842     return 0;
 843   fail:
 844     return AVERROR_EXTERNAL;
 845 }
 846
 847 static av_cold int opengl_prepare_vertex(AVFormatContext *s)
 848 {
 849     OpenGLContext *opengl = s->priv_data;
 850     int tex_w, tex_h;
 851
 852     if (opengl->window_width > opengl->max_viewport_width || opengl->window_height > opengl->max_viewport_height) {
 853         opengl->window_width = FFMAX(opengl->window_width, opengl->max_viewport_width);
 854         opengl->window_height = FFMAX(opengl->window_height, opengl->max_viewport_height);
 855         av_log(opengl, AV_LOG_WARNING, "Too big viewport requested, limited to %dx%d", opengl->window_width, opengl->window_height);
 856     }
 857     glViewport(0, 0, opengl->window_width, opengl->window_height);
 858     opengl_make_ortho(opengl->projection_matrix,
 859                       - (float)opengl->window_width  / 2.0f, (float)opengl->window_width  / 2.0f,
 860                       - (float)opengl->window_height / 2.0f, (float)opengl->window_height / 2.0f,
 861                       1.0f, -1.0f);
 862     opengl_make_identity(opengl->model_view_matrix);
 863
 864     opengl_compute_display_area(s);
 865
 866     opengl->vertex[0].z = opengl->vertex[1].z = opengl->vertex[2].z = opengl->vertex[3].z = 0.0f;
 867     opengl->vertex[0].x = opengl->vertex[1].x = - (float)opengl->picture_width / 2.0f;
 868     opengl->vertex[2].x = opengl->vertex[3].x =   (float)opengl->picture_width / 2.0f;
 869     opengl->vertex[1].y = opengl->vertex[2].y = - (float)opengl->picture_height / 2.0f;
 870     opengl->vertex[0].y = opengl->vertex[3].y =   (float)opengl->picture_height / 2.0f;
 871
 872     opengl_get_texture_size(opengl, opengl->width, opengl->height, &tex_w, &tex_h);
 873
 874     opengl->vertex[0].s0 = 0.0f;
 875     opengl->vertex[0].t0 = 0.0f;
 876     opengl->vertex[1].s0 = 0.0f;
 877     opengl->vertex[1].t0 = (float)opengl->height / (float)tex_h;
 878     opengl->vertex[2].s0 = (float)opengl->width  / (float)tex_w;
 879     opengl->vertex[2].t0 = (float)opengl->height / (float)tex_h;
 880     opengl->vertex[3].s0 = (float)opengl->width  / (float)tex_w;
 881     opengl->vertex[3].t0 = 0.0f;
 882
 883     opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, opengl->vertex_buffer);
 884     opengl->glprocs.glBufferData(FF_GL_ARRAY_BUFFER, sizeof(opengl->vertex), opengl->vertex, FF_GL_STATIC_DRAW);
 885     opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, 0);
 886     OPENGL_ERROR_CHECK(opengl);
 887     return 0;
 888   fail:
 889     return AVERROR_EXTERNAL;
 890 }
 891
 892 static int opengl_prepare(OpenGLContext *opengl)
 893 {
 894     int i;
 895     opengl->glprocs.glUseProgram(opengl->program);
 896     opengl->glprocs.glUniformMatrix4fv(opengl->projection_matrix_location, 1, GL_FALSE, opengl->projection_matrix);
 897     opengl->glprocs.glUniformMatrix4fv(opengl->model_view_matrix_location, 1, GL_FALSE, opengl->model_view_matrix);
 898     for (i = 0; i < 4; i++)
 899         if (opengl->texture_location[i] != -1) {
 900             opengl->glprocs.glActiveTexture(GL_TEXTURE0 + i);
 901             glBindTexture(GL_TEXTURE_2D, opengl->texture_name[i]);
 902             opengl->glprocs.glUniform1i(opengl->texture_location[i], i);
 903         }
 904     if (opengl->color_map_location != -1)
 905         opengl->glprocs.glUniformMatrix4fv(opengl->color_map_location, 1, GL_FALSE, opengl->color_map);
 906     if (opengl->chroma_div_h_location != -1)
 907         opengl->glprocs.glUniform1f(opengl->chroma_div_h_location, opengl->chroma_div_h);
 908     if (opengl->chroma_div_w_location != -1)
 909         opengl->glprocs.glUniform1f(opengl->chroma_div_w_location, opengl->chroma_div_w);
 910
 911     OPENGL_ERROR_CHECK(opengl);
 912     return 0;
 913   fail:
 914     return AVERROR_EXTERNAL;
 915 }
 916
 917 static av_cold int opengl_write_trailer(AVFormatContext *h)
 918 {
 919     OpenGLContext *opengl = h->priv_data;
 920
 921     if (opengl->no_window &&
 922         avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0) < 0)
 923         av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
 924
 925     glDeleteTextures(4, opengl->texture_name);
 926     if (opengl && opengl->glprocs.glDeleteBuffers)
 927         opengl->glprocs.glDeleteBuffers(2, &opengl->index_buffer);
 928
 929 #if HAVE_SDL
 930     if (!opengl->no_window)
 931         SDL_Quit();
 932 #endif
 933     if (opengl->no_window &&
 934         avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER, NULL , 0) < 0)
 935         av_log(opengl, AV_LOG_ERROR, "Application failed to release window buffer.\n");
 936
 937     return 0;
 938 }
 939
 940 static av_cold int opengl_init_context(OpenGLContext *opengl)
 941 {
 942     int i, ret;
 943     const AVPixFmtDescriptor *desc;
 944
 945     if ((ret = opengl_compile_shaders(opengl, opengl->pix_fmt)) < 0)
 946         goto fail;
 947
 948     desc = av_pix_fmt_desc_get(opengl->pix_fmt);
 949     av_assert0(desc->nb_components > 0 && desc->nb_components <= 4);
 950     glGenTextures(desc->nb_components, opengl->texture_name);
 951
 952     opengl->glprocs.glGenBuffers(2, &opengl->index_buffer);
 953     if (!opengl->index_buffer || !opengl->vertex_buffer) {
 954         av_log(opengl, AV_LOG_ERROR, "Buffer generation failed.\n");
 955         ret = AVERROR_EXTERNAL;
 956         goto fail;
 957     }
 958
 959     opengl_configure_texture(opengl, opengl->texture_name[0], opengl->width, opengl->height);
 960     if (desc->nb_components > 1) {
 961         int has_alpha = desc->flags & AV_PIX_FMT_FLAG_ALPHA;
 962         int num_planes = desc->nb_components - (has_alpha ? 1 : 0);
 963         if (opengl->non_pow_2_textures) {
 964             opengl->chroma_div_w = 1.0f;
 965             opengl->chroma_div_h = 1.0f;
 966         } else {
 967             opengl->chroma_div_w = 1 << desc->log2_chroma_w;
 968             opengl->chroma_div_h = 1 << desc->log2_chroma_h;
 969         }
 970         for (i = 1; i < num_planes; i++)
 971             if (opengl->non_pow_2_textures)
 972                 opengl_configure_texture(opengl, opengl->texture_name[i],
 973                         FF_CEIL_RSHIFT(opengl->width, desc->log2_chroma_w),
 974                         FF_CEIL_RSHIFT(opengl->height, desc->log2_chroma_h));
 975             else
 976                 opengl_configure_texture(opengl, opengl->texture_name[i], opengl->width, opengl->height);
 977         if (has_alpha)
 978             opengl_configure_texture(opengl, opengl->texture_name[3], opengl->width, opengl->height);
 979     }
 980
 981     opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, opengl->index_buffer);
 982     opengl->glprocs.glBufferData(FF_GL_ELEMENT_ARRAY_BUFFER, sizeof(g_index), g_index, FF_GL_STATIC_DRAW);
 983     opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, 0);
 984
 985     glEnable(GL_BLEND);
 986     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 987
 988     glClearColor((float)opengl->background[0] / 255.0f, (float)opengl->background[1] / 255.0f,
 989                  (float)opengl->background[2] / 255.0f, 1.0f);
 990
 991     ret = AVERROR_EXTERNAL;
 992     OPENGL_ERROR_CHECK(opengl);
 993
 994     return 0;
 995   fail:
 996     return ret;
 997 }
 998
 999 static av_cold int opengl_write_header(AVFormatContext *h)
1000 {
1001     OpenGLContext *opengl = h->priv_data;
1002     AVStream *st;
1003     int ret;
1004
1005     if (h->nb_streams != 1 ||
1006         h->streams[0]->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1007         h->streams[0]->codec->codec_id != AV_CODEC_ID_RAWVIDEO) {
1008         av_log(opengl, AV_LOG_ERROR, "Only a single video stream is supported.\n");
1009         return AVERROR(EINVAL);
1010     }
1011     st = h->streams[0];
1012     opengl->width = st->codec->width;
1013     opengl->height = st->codec->height;
1014     opengl->pix_fmt = st->codec->pix_fmt;
1015
1016     if (!opengl->window_title && !opengl->no_window)
1017         opengl->window_title = av_strdup(h->filename);
1018
1019     if (!opengl->no_window) {
1020 #if HAVE_SDL
1021         if ((ret = opengl_sdl_create_window(h)) < 0)
1022             goto fail;
1023 #else
1024         av_log(opengl, AV_LOG_ERROR, "FFmpeg is compiled without SDL. Cannot create default window.\n");
1025         ret = AVERROR(ENOSYS);
1026         goto fail;
1027 #endif
1028     } else {
1029         if ((ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_CREATE_WINDOW_BUFFER, NULL , 0)) < 0) {
1030             av_log(opengl, AV_LOG_ERROR, "Application failed to create window buffer.\n");
1031             goto fail;
1032         }
1033         if ((ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0)) < 0) {
1034             av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
1035             goto fail;
1036         }
1037     }
1038
1039     if ((ret = opengl_read_limits(opengl)) < 0)
1040         goto fail;
1041
1042     if (opengl->width > opengl->max_texture_size || opengl->height > opengl->max_texture_size) {
1043         av_log(opengl, AV_LOG_ERROR, "Too big picture %dx%d, max supported size is %dx%d\n",
1044                opengl->width, opengl->height, opengl->max_texture_size, opengl->max_texture_size);
1045         ret = AVERROR(EINVAL);
1046         goto fail;
1047     }
1048
1049     if (!opengl->no_window) {
1050 #if HAVE_SDL
1051         if ((ret = opengl_sdl_load_procedures(opengl)) < 0)
1052             goto fail;
1053 #endif
1054     } else if ((ret = opengl_load_procedures(opengl)) < 0)
1055         goto fail;
1056
1057     opengl_fill_color_map(opengl);
1058     opengl_get_texture_params(opengl);
1059
1060     if ((ret = opengl_init_context(opengl)) < 0)
1061         goto fail;
1062
1063     if ((ret = opengl_prepare_vertex(h)) < 0)
1064         goto fail;
1065
1066     glClear(GL_COLOR_BUFFER_BIT);
1067
1068 #if HAVE_SDL
1069     if (!opengl->no_window)
1070         SDL_GL_SwapBuffers();
1071 #endif
1072     if (opengl->no_window &&
1073         (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER, NULL , 0)) < 0) {
1074         av_log(opengl, AV_LOG_ERROR, "Application failed to display window buffer.\n");
1075         goto fail;
1076     }
1077
1078     ret = AVERROR_EXTERNAL;
1079     OPENGL_ERROR_CHECK(opengl);
1080     return 0;
1081
1082   fail:
1083     opengl_write_trailer(h);
1084     return ret;
1085 }
1086
1087 static uint8_t* opengl_get_plane_pointer(OpenGLContext *opengl, AVPacket *pkt, int comp_index,
1088                                          const AVPixFmtDescriptor *desc)
1089 {
1090     uint8_t *data = pkt->data;
1091     int wordsize = opengl_type_size(opengl->type);
1092     int width_chroma = FF_CEIL_RSHIFT(opengl->width, desc->log2_chroma_w);
1093     int height_chroma = FF_CEIL_RSHIFT(opengl->height, desc->log2_chroma_h);
1094     int plane = desc->comp[comp_index].plane;
1095
1096     switch(plane) {
1097     case 0:
1098         break;
1099     case 1:
1100         data += opengl->width * opengl->height * wordsize;
1101         break;
1102     case 2:
1103         data += opengl->width * opengl->height * wordsize;
1104         data += width_chroma * height_chroma * wordsize;
1105         break;
1106     case 3:
1107         data += opengl->width * opengl->height * wordsize;
1108         data += 2 * width_chroma * height_chroma * wordsize;
1109         break;
1110     default:
1111         return NULL;
1112     }
1113     return data;
1114 }
1115
1116 static int opengl_draw(AVFormatContext *h, AVPacket *pkt, int repaint)
1117 {
1118     OpenGLContext *opengl = h->priv_data;
1119     enum AVPixelFormat pix_fmt = h->streams[0]->codec->pix_fmt;
1120     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
1121     int ret;
1122
1123 #if HAVE_SDL
1124     if (!opengl->no_window && (ret = opengl_sdl_process_events(h)) < 0)
1125         goto fail;
1126 #endif
1127     if (opengl->no_window &&
1128         (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0)) < 0) {
1129         av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
1130         goto fail;
1131     }
1132
1133     glClear(GL_COLOR_BUFFER_BIT);
1134
1135     if (!repaint) {
1136         glBindTexture(GL_TEXTURE_2D, opengl->texture_name[0]);
1137         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, opengl->width, opengl->height, opengl->format, opengl->type,
1138                         opengl_get_plane_pointer(opengl, pkt, 0, desc));
1139         if (desc->flags & AV_PIX_FMT_FLAG_PLANAR) {
1140             int width_chroma = FF_CEIL_RSHIFT(opengl->width, desc->log2_chroma_w);
1141             int height_chroma = FF_CEIL_RSHIFT(opengl->height, desc->log2_chroma_h);
1142             glBindTexture(GL_TEXTURE_2D, opengl->texture_name[1]);
1143             glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width_chroma, height_chroma, opengl->format, opengl->type,
1144                             opengl_get_plane_pointer(opengl, pkt, 1, desc));
1145             glBindTexture(GL_TEXTURE_2D, opengl->texture_name[2]);
1146             glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width_chroma, height_chroma, opengl->format, opengl->type,
1147                             opengl_get_plane_pointer(opengl, pkt, 2, desc));
1148             if (desc->flags & AV_PIX_FMT_FLAG_ALPHA) {
1149                 glBindTexture(GL_TEXTURE_2D, opengl->texture_name[3]);
1150                 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, opengl->width, opengl->height, opengl->format, opengl->type,
1151                                 opengl_get_plane_pointer(opengl, pkt, 3, desc));
1152             }
1153         }
1154     }
1155     ret = AVERROR_EXTERNAL;
1156     OPENGL_ERROR_CHECK(opengl);
1157
1158     if ((ret = opengl_prepare(opengl)) < 0)
1159         goto fail;
1160
1161     opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, opengl->vertex_buffer);
1162     opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, opengl->index_buffer);
1163     opengl->glprocs.glVertexAttribPointer(opengl->position_attrib, 3, GL_FLOAT, GL_FALSE, sizeof(OpenGLVertexInfo), 0);
1164     opengl->glprocs.glEnableVertexAttribArray(opengl->position_attrib);
1165     opengl->glprocs.glVertexAttribPointer(opengl->texture_coords_attrib, 2, GL_FLOAT, GL_FALSE, sizeof(OpenGLVertexInfo), 12);
1166     opengl->glprocs.glEnableVertexAttribArray(opengl->texture_coords_attrib);
1167
1168     glDrawElements(GL_TRIANGLES, FF_ARRAY_ELEMS(g_index), GL_UNSIGNED_SHORT, 0);
1169
1170     ret = AVERROR_EXTERNAL;
1171     OPENGL_ERROR_CHECK(opengl);
1172
1173 #if HAVE_SDL
1174     if (!opengl->no_window)
1175         SDL_GL_SwapBuffers();
1176 #endif
1177     if (opengl->no_window &&
1178         (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER, NULL , 0)) < 0) {
1179         av_log(opengl, AV_LOG_ERROR, "Application failed to display window buffer.\n");
1180         goto fail;
1181     }
1182
1183     return 0;
1184   fail:
1185     return ret;
1186 }
1187
1188 static int opengl_write_packet(AVFormatContext *h, AVPacket *pkt)
1189 {
1190     return opengl_draw(h, pkt, 0);
1191 }
1192
1193 #define OFFSET(x) offsetof(OpenGLContext, x)
1194 #define ENC AV_OPT_FLAG_ENCODING_PARAM
1195 static const AVOption options[] = {
1196     { "background",   "set background color",   OFFSET(background),   AV_OPT_TYPE_COLOR,  {.str = "black"}, CHAR_MIN, CHAR_MAX, ENC },
1197     { "no_window",    "disable default window", OFFSET(no_window),    AV_OPT_TYPE_INT,    {.i64 = 0}, INT_MIN, INT_MAX, ENC },
1198     { "window_title", "set window title",       OFFSET(window_title), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, ENC },
1199     { NULL }
1200 };
1201
1202 static const AVClass opengl_class = {
1203     .class_name = "opengl outdev",
1204     .item_name  = av_default_item_name,
1205     .option     = options,
1206     .version    = LIBAVUTIL_VERSION_INT,
1207 };
1208
1209 AVOutputFormat ff_opengl_muxer = {
1210     .name           = "opengl",
1211     .long_name      = NULL_IF_CONFIG_SMALL("OpenGL output"),
1212     .priv_data_size = sizeof(OpenGLContext),
1213     .audio_codec    = AV_CODEC_ID_NONE,
1214     .video_codec    = AV_CODEC_ID_RAWVIDEO,
1215     .write_header   = opengl_write_header,
1216     .write_packet   = opengl_write_packet,
1217     .write_trailer  = opengl_write_trailer,
1218     .control_message = opengl_control_message,
1219     .flags          = AVFMT_NOFILE | AVFMT_VARIABLE_FPS | AVFMT_NOTIMESTAMPS,
1220     .priv_class     = &opengl_class,
1221 };