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