FFmpeg
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 <stddef.h>
29 
30 #include "config.h"
31 
32 #if HAVE_WINDOWS_H
33 #include <windows.h>
34 #endif
35 #if HAVE_OPENGL_GL3_H
36 #include <OpenGL/gl3.h>
37 #elif HAVE_ES2_GL_H
38 #include <ES2/gl.h>
39 #else
40 #include <GL/gl.h>
41 #include <GL/glext.h>
42 #endif
43 #if HAVE_GLXGETPROCADDRESS
44 #include <GL/glx.h>
45 #endif
46 
47 #if CONFIG_SDL2
48 #include <SDL.h>
49 #endif
50 
51 #include "libavutil/common.h"
52 #include "libavutil/frame.h"
53 #include "libavutil/pixdesc.h"
54 #include "libavutil/log.h"
55 #include "libavutil/opt.h"
56 #include "libavutil/avassert.h"
57 #include "libavformat/avformat.h"
58 #include "libavformat/internal.h"
59 #include "libavformat/mux.h"
60 #include "libavdevice/avdevice.h"
61 #include "opengl_enc_shaders.h"
62 
63 #ifndef APIENTRY
64 #define APIENTRY
65 #endif
66 
67 /* FF_GL_RED_COMPONENT is used for planar pixel types.
68  * Only red component is sampled in shaders.
69  * On some platforms GL_RED is not available and GL_LUMINANCE have to be used,
70  * but since OpenGL 3.0 GL_LUMINANCE is deprecated.
71  * GL_RED produces RGBA = value, 0, 0, 1.
72  * GL_LUMINANCE produces RGBA = value, value, value, 1.
73  * Note: GL_INTENSITY may also be used which produce RGBA = value, value, value, value. */
74 #if defined(GL_RED)
75 #define FF_GL_RED_COMPONENT GL_RED
76 #elif defined(GL_LUMINANCE)
77 #define FF_GL_RED_COMPONENT GL_LUMINANCE
78 #else
79 #define FF_GL_RED_COMPONENT 0x1903; //GL_RED
80 #endif
81 
82 /* Constants not defined for iOS */
83 #define FF_GL_UNSIGNED_BYTE_3_3_2 0x8032
84 #define FF_GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
85 #define FF_GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
86 #define FF_GL_UNPACK_ROW_LENGTH 0x0CF2
87 
88 /* MinGW exposes only OpenGL 1.1 API */
89 #define FF_GL_ARRAY_BUFFER 0x8892
90 #define FF_GL_ELEMENT_ARRAY_BUFFER 0x8893
91 #define FF_GL_STATIC_DRAW 0x88E4
92 #define FF_GL_FRAGMENT_SHADER 0x8B30
93 #define FF_GL_VERTEX_SHADER 0x8B31
94 #define FF_GL_COMPILE_STATUS 0x8B81
95 #define FF_GL_LINK_STATUS 0x8B82
96 #define FF_GL_INFO_LOG_LENGTH 0x8B84
97 typedef void (APIENTRY *FF_PFNGLACTIVETEXTUREPROC) (GLenum texture);
98 typedef void (APIENTRY *FF_PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
99 typedef void (APIENTRY *FF_PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
100 typedef void (APIENTRY *FF_PFNGLBUFFERDATAPROC) (GLenum target, ptrdiff_t size, const GLvoid *data, GLenum usage);
101 typedef void (APIENTRY *FF_PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
102 typedef GLint (APIENTRY *FF_PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const char *name);
103 typedef void (APIENTRY *FF_PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index);
104 typedef void (APIENTRY *FF_PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, uintptr_t pointer);
105 typedef GLint (APIENTRY *FF_PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const char *name);
106 typedef void (APIENTRY *FF_PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0);
107 typedef void (APIENTRY *FF_PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
108 typedef void (APIENTRY *FF_PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
109 typedef GLuint (APIENTRY *FF_PFNGLCREATEPROGRAMPROC) (void);
110 typedef void (APIENTRY *FF_PFNGLDELETEPROGRAMPROC) (GLuint program);
111 typedef void (APIENTRY *FF_PFNGLUSEPROGRAMPROC) (GLuint program);
112 typedef void (APIENTRY *FF_PFNGLLINKPROGRAMPROC) (GLuint program);
113 typedef void (APIENTRY *FF_PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params);
114 typedef void (APIENTRY *FF_PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, char *infoLog);
115 typedef void (APIENTRY *FF_PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
116 typedef GLuint (APIENTRY *FF_PFNGLCREATESHADERPROC) (GLenum type);
117 typedef void (APIENTRY *FF_PFNGLDELETESHADERPROC) (GLuint shader);
118 typedef void (APIENTRY *FF_PFNGLCOMPILESHADERPROC) (GLuint shader);
119 typedef void (APIENTRY *FF_PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const char* *string, const GLint *length);
120 typedef void (APIENTRY *FF_PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
121 typedef void (APIENTRY *FF_PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, char *infoLog);
122 
123 typedef struct FFOpenGLFunctions {
124  FF_PFNGLACTIVETEXTUREPROC glActiveTexture; //Require GL ARB multitexture
125  FF_PFNGLGENBUFFERSPROC glGenBuffers; //Require GL_ARB_vertex_buffer_object
126  FF_PFNGLDELETEBUFFERSPROC glDeleteBuffers; //Require GL_ARB_vertex_buffer_object
127  FF_PFNGLBUFFERDATAPROC glBufferData; //Require GL_ARB_vertex_buffer_object
128  FF_PFNGLBINDBUFFERPROC glBindBuffer; //Require GL_ARB_vertex_buffer_object
129  FF_PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation; //Require GL_ARB_vertex_shader
130  FF_PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray; //Require GL_ARB_vertex_shader
131  FF_PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer; //Require GL_ARB_vertex_shader
132  FF_PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation; //Require GL_ARB_shader_objects
133  FF_PFNGLUNIFORM1FPROC glUniform1f; //Require GL_ARB_shader_objects
134  FF_PFNGLUNIFORM1IPROC glUniform1i; //Require GL_ARB_shader_objects
135  FF_PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv; //Require GL_ARB_shader_objects
136  FF_PFNGLCREATEPROGRAMPROC glCreateProgram; //Require GL_ARB_shader_objects
137  FF_PFNGLDELETEPROGRAMPROC glDeleteProgram; //Require GL_ARB_shader_objects
138  FF_PFNGLUSEPROGRAMPROC glUseProgram; //Require GL_ARB_shader_objects
139  FF_PFNGLLINKPROGRAMPROC glLinkProgram; //Require GL_ARB_shader_objects
140  FF_PFNGLGETPROGRAMIVPROC glGetProgramiv; //Require GL_ARB_shader_objects
141  FF_PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog; //Require GL_ARB_shader_objects
142  FF_PFNGLATTACHSHADERPROC glAttachShader; //Require GL_ARB_shader_objects
143  FF_PFNGLCREATESHADERPROC glCreateShader; //Require GL_ARB_shader_objects
144  FF_PFNGLDELETESHADERPROC glDeleteShader; //Require GL_ARB_shader_objects
145  FF_PFNGLCOMPILESHADERPROC glCompileShader; //Require GL_ARB_shader_objects
146  FF_PFNGLSHADERSOURCEPROC glShaderSource; //Require GL_ARB_shader_objects
147  FF_PFNGLGETSHADERIVPROC glGetShaderiv; //Require GL_ARB_shader_objects
148  FF_PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog; //Require GL_ARB_shader_objects
149 } FFOpenGLFunctions;
150 
151 #define OPENGL_ERROR_CHECK(ctx) \
152 {\
153  GLenum err_code; \
154  if ((err_code = glGetError()) != GL_NO_ERROR) { \
155  av_log(ctx, AV_LOG_ERROR, "OpenGL error occurred in '%s', line %d: %d\n", __func__, __LINE__, err_code); \
156  goto fail; \
157  } \
158 }\
159 
160 typedef struct OpenGLVertexInfo
161 {
162  float x, y, z; ///<Position
163  float s0, t0; ///<Texture coords
164 } OpenGLVertexInfo;
165 
166 /* defines 2 triangles to display */
167 static const GLushort g_index[6] =
168 {
169  0, 1, 2,
170  0, 3, 2,
171 };
172 
173 typedef struct OpenGLContext {
174  AVClass *class; ///< class for private options
175 
176 #if CONFIG_SDL2
177  SDL_Window *window;
178  SDL_GLContext glcontext;
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_BGR48, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGB, GL_UNSIGNED_SHORT },
264  { AV_PIX_FMT_ARGB, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
265  { AV_PIX_FMT_RGBA, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
266  { AV_PIX_FMT_ABGR, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
267  { AV_PIX_FMT_BGRA, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
268  { AV_PIX_FMT_RGBA64, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_SHORT },
269  { AV_PIX_FMT_BGRA64, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_SHORT },
270  { AV_PIX_FMT_GBRP, &FF_OPENGL_FRAGMENT_SHADER_RGB_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
271  { AV_PIX_FMT_GBRP16, &FF_OPENGL_FRAGMENT_SHADER_RGB_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
272  { AV_PIX_FMT_GBRAP, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
273  { AV_PIX_FMT_GBRAP16, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
274  { AV_PIX_FMT_GRAY8, &FF_OPENGL_FRAGMENT_SHADER_GRAY, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
275  { AV_PIX_FMT_GRAY16, &FF_OPENGL_FRAGMENT_SHADER_GRAY, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
276  { AV_PIX_FMT_NONE, NULL }
277 };
278 
279 static av_cold int opengl_prepare_vertex(AVFormatContext *s);
280 static int opengl_draw(AVFormatContext *h, void *intput, int repaint, int is_pkt);
281 static av_cold int opengl_init_context(OpenGLContext *opengl);
282 
283 static av_cold void opengl_deinit_context(OpenGLContext *opengl)
284 {
285  glDeleteTextures(4, opengl->texture_name);
286  opengl->texture_name[0] = opengl->texture_name[1] =
287  opengl->texture_name[2] = opengl->texture_name[3] = 0;
288  if (opengl->glprocs.glUseProgram)
289  opengl->glprocs.glUseProgram(0);
290  if (opengl->glprocs.glDeleteProgram) {
291  opengl->glprocs.glDeleteProgram(opengl->program);
292  opengl->program = 0;
293  }
294  if (opengl->glprocs.glDeleteShader) {
295  opengl->glprocs.glDeleteShader(opengl->vertex_shader);
296  opengl->glprocs.glDeleteShader(opengl->fragment_shader);
297  opengl->vertex_shader = opengl->fragment_shader = 0;
298  }
299  if (opengl->glprocs.glBindBuffer) {
300  opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, 0);
301  opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, 0);
302  }
303  if (opengl->glprocs.glDeleteBuffers) {
304  opengl->glprocs.glDeleteBuffers(2, &opengl->index_buffer);
305  opengl->vertex_buffer = opengl->index_buffer = 0;
306  }
307 }
308 
309 static int opengl_resize(AVFormatContext *h, int width, int height)
310 {
311  int ret = 0;
312  OpenGLContext *opengl = h->priv_data;
313  opengl->window_width = width;
314  opengl->window_height = height;
315  if (opengl->inited) {
316  if (opengl->no_window &&
317  (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0)) < 0) {
318  av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
319  goto end;
320  }
321  if ((ret = opengl_prepare_vertex(h)) < 0)
322  goto end;
323  ret = opengl_draw(h, NULL, 1, 0);
324  }
325  end:
326  return ret;
327 }
328 
329 static int opengl_control_message(AVFormatContext *h, int type, void *data, size_t data_size)
330 {
331  OpenGLContext *opengl = h->priv_data;
332  switch(type) {
333  case AV_APP_TO_DEV_WINDOW_SIZE:
334  if (data) {
335  AVDeviceRect *message = data;
336  return opengl_resize(h, message->width, message->height);
337  }
338  return AVERROR(EINVAL);
339  case AV_APP_TO_DEV_WINDOW_REPAINT:
340  return opengl_resize(h, opengl->window_width, opengl->window_height);
341  }
342  return AVERROR(ENOSYS);
343 }
344 
345 #if CONFIG_SDL2
346 static int opengl_sdl_process_events(AVFormatContext *h)
347 {
348  OpenGLContext *opengl = h->priv_data;
349  AVDeviceRect message;
350  SDL_Event event;
351  SDL_PumpEvents();
352  while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) > 0) {
353  switch (event.type) {
354  case SDL_QUIT:
355  return AVERROR(EIO);
356  case SDL_KEYDOWN:
357  switch (event.key.keysym.sym) {
358  case SDLK_ESCAPE:
359  case SDLK_q:
360  return AVERROR(EIO);
361  }
362  return 0;
363  case SDL_WINDOWEVENT:
364  switch(event.window.event) {
365  case SDL_WINDOWEVENT_RESIZED:
366  case SDL_WINDOWEVENT_SIZE_CHANGED:
367  SDL_GL_GetDrawableSize(opengl->window, &message.width, &message.height);
368  return opengl_control_message(h, AV_APP_TO_DEV_WINDOW_SIZE, &message, sizeof(AVDeviceRect));
369  default:
370  break;
371  }
372  }
373  }
374  return 0;
375 }
376 
377 static int av_cold opengl_sdl_create_window(AVFormatContext *h)
378 {
379  OpenGLContext *opengl = h->priv_data;
380  AVDeviceRect message;
381  if (SDL_Init(SDL_INIT_VIDEO)) {
382  av_log(opengl, AV_LOG_ERROR, "Unable to initialize SDL: %s\n", SDL_GetError());
383  return AVERROR_EXTERNAL;
384  }
385  opengl->window = SDL_CreateWindow(opengl->window_title,
386  SDL_WINDOWPOS_UNDEFINED,
387  SDL_WINDOWPOS_UNDEFINED,
388  opengl->window_width, opengl->window_height,
389  SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL);
390  if (!opengl->window) {
391  av_log(opengl, AV_LOG_ERROR, "Unable to create default window: %s\n", SDL_GetError());
392  return AVERROR_EXTERNAL;
393  }
394  opengl->glcontext = SDL_GL_CreateContext(opengl->window);
395  if (!opengl->glcontext) {
396  av_log(opengl, AV_LOG_ERROR, "Unable to create OpenGL context on default window: %s\n", SDL_GetError());
397  return AVERROR_EXTERNAL;
398  }
399  SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
400  SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
401  SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
402  SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
403  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
404  av_log(opengl, AV_LOG_INFO, "SDL driver: '%s'.\n", SDL_GetCurrentVideoDriver());
405  SDL_GL_GetDrawableSize(opengl->window, &message.width, &message.height);
406  return opengl_control_message(h, AV_APP_TO_DEV_WINDOW_SIZE, &message, sizeof(AVDeviceRect));
407 }
408 
409 static int av_cold opengl_sdl_load_procedures(OpenGLContext *opengl)
410 {
411  FFOpenGLFunctions *procs = &opengl->glprocs;
412 
413 #define LOAD_OPENGL_FUN(name, type) \
414  procs->name = (type)SDL_GL_GetProcAddress(#name); \
415  if (!procs->name) { \
416  av_log(opengl, AV_LOG_ERROR, "Cannot load OpenGL function: '%s'\n", #name); \
417  return AVERROR(ENOSYS); \
418  }
419 
420  LOAD_OPENGL_FUN(glActiveTexture, FF_PFNGLACTIVETEXTUREPROC)
421  LOAD_OPENGL_FUN(glGenBuffers, FF_PFNGLGENBUFFERSPROC)
422  LOAD_OPENGL_FUN(glDeleteBuffers, FF_PFNGLDELETEBUFFERSPROC)
423  LOAD_OPENGL_FUN(glBufferData, FF_PFNGLBUFFERDATAPROC)
424  LOAD_OPENGL_FUN(glBindBuffer, FF_PFNGLBINDBUFFERPROC)
425  LOAD_OPENGL_FUN(glGetAttribLocation, FF_PFNGLGETATTRIBLOCATIONPROC)
426  LOAD_OPENGL_FUN(glGetUniformLocation, FF_PFNGLGETUNIFORMLOCATIONPROC)
427  LOAD_OPENGL_FUN(glUniform1f, FF_PFNGLUNIFORM1FPROC)
428  LOAD_OPENGL_FUN(glUniform1i, FF_PFNGLUNIFORM1IPROC)
429  LOAD_OPENGL_FUN(glUniformMatrix4fv, FF_PFNGLUNIFORMMATRIX4FVPROC)
430  LOAD_OPENGL_FUN(glCreateProgram, FF_PFNGLCREATEPROGRAMPROC)
431  LOAD_OPENGL_FUN(glDeleteProgram, FF_PFNGLDELETEPROGRAMPROC)
432  LOAD_OPENGL_FUN(glUseProgram, FF_PFNGLUSEPROGRAMPROC)
433  LOAD_OPENGL_FUN(glLinkProgram, FF_PFNGLLINKPROGRAMPROC)
434  LOAD_OPENGL_FUN(glGetProgramiv, FF_PFNGLGETPROGRAMIVPROC)
435  LOAD_OPENGL_FUN(glGetProgramInfoLog, FF_PFNGLGETPROGRAMINFOLOGPROC)
436  LOAD_OPENGL_FUN(glAttachShader, FF_PFNGLATTACHSHADERPROC)
437  LOAD_OPENGL_FUN(glCreateShader, FF_PFNGLCREATESHADERPROC)
438  LOAD_OPENGL_FUN(glDeleteShader, FF_PFNGLDELETESHADERPROC)
439  LOAD_OPENGL_FUN(glCompileShader, FF_PFNGLCOMPILESHADERPROC)
440  LOAD_OPENGL_FUN(glShaderSource, FF_PFNGLSHADERSOURCEPROC)
441  LOAD_OPENGL_FUN(glGetShaderiv, FF_PFNGLGETSHADERIVPROC)
442  LOAD_OPENGL_FUN(glGetShaderInfoLog, FF_PFNGLGETSHADERINFOLOGPROC)
443  LOAD_OPENGL_FUN(glEnableVertexAttribArray, FF_PFNGLENABLEVERTEXATTRIBARRAYPROC)
444  LOAD_OPENGL_FUN(glVertexAttribPointer, FF_PFNGLVERTEXATTRIBPOINTERPROC)
445 
446  return 0;
447 
448 #undef LOAD_OPENGL_FUN
449 }
450 #endif /* CONFIG_SDL2 */
451 
452 #if defined(__APPLE__)
453 static int av_cold opengl_load_procedures(OpenGLContext *opengl)
454 {
455  FFOpenGLFunctions *procs = &opengl->glprocs;
456 
457 #if CONFIG_SDL2
458  if (!opengl->no_window)
459  return opengl_sdl_load_procedures(opengl);
460 #endif
461 
462  procs->glActiveTexture = glActiveTexture;
463  procs->glGenBuffers = glGenBuffers;
464  procs->glDeleteBuffers = glDeleteBuffers;
465  procs->glBufferData = glBufferData;
466  procs->glBindBuffer = glBindBuffer;
467  procs->glGetAttribLocation = glGetAttribLocation;
468  procs->glGetUniformLocation = glGetUniformLocation;
469  procs->glUniform1f = glUniform1f;
470  procs->glUniform1i = glUniform1i;
471  procs->glUniformMatrix4fv = glUniformMatrix4fv;
472  procs->glCreateProgram = glCreateProgram;
473  procs->glDeleteProgram = glDeleteProgram;
474  procs->glUseProgram = glUseProgram;
475  procs->glLinkProgram = glLinkProgram;
476  procs->glGetProgramiv = glGetProgramiv;
477  procs->glGetProgramInfoLog = glGetProgramInfoLog;
478  procs->glAttachShader = glAttachShader;
479  procs->glCreateShader = glCreateShader;
480  procs->glDeleteShader = glDeleteShader;
481  procs->glCompileShader = glCompileShader;
482  procs->glShaderSource = glShaderSource;
483  procs->glGetShaderiv = glGetShaderiv;
484  procs->glGetShaderInfoLog = glGetShaderInfoLog;
485  procs->glEnableVertexAttribArray = glEnableVertexAttribArray;
486  procs->glVertexAttribPointer = (FF_PFNGLVERTEXATTRIBPOINTERPROC) glVertexAttribPointer;
487  return 0;
488 }
489 #else
490 static int av_cold opengl_load_procedures(OpenGLContext *opengl)
491 {
492  FFOpenGLFunctions *procs = &opengl->glprocs;
493 
494 #if HAVE_GLXGETPROCADDRESS
495 #define SelectedGetProcAddress glXGetProcAddress
496 #elif HAVE_WGLGETPROCADDRESS
497 #define SelectedGetProcAddress wglGetProcAddress
498 #endif
499 
500 #define LOAD_OPENGL_FUN(name, type) \
501  procs->name = (type)SelectedGetProcAddress(#name); \
502  if (!procs->name) { \
503  av_log(opengl, AV_LOG_ERROR, "Cannot load OpenGL function: '%s'\n", #name); \
504  return AVERROR(ENOSYS); \
505  }
506 
507 #if CONFIG_SDL2
508  if (!opengl->no_window)
509  return opengl_sdl_load_procedures(opengl);
510 #endif
511 
512  LOAD_OPENGL_FUN(glActiveTexture, FF_PFNGLACTIVETEXTUREPROC)
513  LOAD_OPENGL_FUN(glGenBuffers, FF_PFNGLGENBUFFERSPROC)
514  LOAD_OPENGL_FUN(glDeleteBuffers, FF_PFNGLDELETEBUFFERSPROC)
515  LOAD_OPENGL_FUN(glBufferData, FF_PFNGLBUFFERDATAPROC)
516  LOAD_OPENGL_FUN(glBindBuffer, FF_PFNGLBINDBUFFERPROC)
517  LOAD_OPENGL_FUN(glGetAttribLocation, FF_PFNGLGETATTRIBLOCATIONPROC)
518  LOAD_OPENGL_FUN(glGetUniformLocation, FF_PFNGLGETUNIFORMLOCATIONPROC)
519  LOAD_OPENGL_FUN(glUniform1f, FF_PFNGLUNIFORM1FPROC)
520  LOAD_OPENGL_FUN(glUniform1i, FF_PFNGLUNIFORM1IPROC)
521  LOAD_OPENGL_FUN(glUniformMatrix4fv, FF_PFNGLUNIFORMMATRIX4FVPROC)
522  LOAD_OPENGL_FUN(glCreateProgram, FF_PFNGLCREATEPROGRAMPROC)
523  LOAD_OPENGL_FUN(glDeleteProgram, FF_PFNGLDELETEPROGRAMPROC)
524  LOAD_OPENGL_FUN(glUseProgram, FF_PFNGLUSEPROGRAMPROC)
525  LOAD_OPENGL_FUN(glLinkProgram, FF_PFNGLLINKPROGRAMPROC)
526  LOAD_OPENGL_FUN(glGetProgramiv, FF_PFNGLGETPROGRAMIVPROC)
527  LOAD_OPENGL_FUN(glGetProgramInfoLog, FF_PFNGLGETPROGRAMINFOLOGPROC)
528  LOAD_OPENGL_FUN(glAttachShader, FF_PFNGLATTACHSHADERPROC)
529  LOAD_OPENGL_FUN(glCreateShader, FF_PFNGLCREATESHADERPROC)
530  LOAD_OPENGL_FUN(glDeleteShader, FF_PFNGLDELETESHADERPROC)
531  LOAD_OPENGL_FUN(glCompileShader, FF_PFNGLCOMPILESHADERPROC)
532  LOAD_OPENGL_FUN(glShaderSource, FF_PFNGLSHADERSOURCEPROC)
533  LOAD_OPENGL_FUN(glGetShaderiv, FF_PFNGLGETSHADERIVPROC)
534  LOAD_OPENGL_FUN(glGetShaderInfoLog, FF_PFNGLGETSHADERINFOLOGPROC)
535  LOAD_OPENGL_FUN(glEnableVertexAttribArray, FF_PFNGLENABLEVERTEXATTRIBARRAYPROC)
536  LOAD_OPENGL_FUN(glVertexAttribPointer, FF_PFNGLVERTEXATTRIBPOINTERPROC)
537 
538  return 0;
539 
540 #undef SelectedGetProcAddress
541 #undef LOAD_OPENGL_FUN
542 }
543 #endif
544 
545 static void opengl_make_identity(float matrix[16])
546 {
547  memset(matrix, 0, 16 * sizeof(float));
548  matrix[0] = matrix[5] = matrix[10] = matrix[15] = 1.0f;
549 }
550 
551 static void opengl_make_ortho(float matrix[16], float left, float right,
552  float bottom, float top, float nearZ, float farZ)
553 {
554  float ral = right + left;
555  float rsl = right - left;
556  float tab = top + bottom;
557  float tsb = top - bottom;
558  float fan = farZ + nearZ;
559  float fsn = farZ - nearZ;
560 
561  memset(matrix, 0, 16 * sizeof(float));
562  matrix[0] = 2.0f / rsl;
563  matrix[5] = 2.0f / tsb;
564  matrix[10] = -2.0f / fsn;
565  matrix[12] = -ral / rsl;
566  matrix[13] = -tab / tsb;
567  matrix[14] = -fan / fsn;
568  matrix[15] = 1.0f;
569 }
570 
571 static av_cold int opengl_read_limits(AVFormatContext *h)
572 {
573  OpenGLContext *opengl = h->priv_data;
574  static const struct{
575  const char *extension;
576  int major;
577  int minor;
578  } required_extensions[] = {
579  { "GL_ARB_multitexture", 1, 3 },
580  { "GL_ARB_vertex_buffer_object", 1, 5 }, //GLX_ARB_vertex_buffer_object
581  { "GL_ARB_vertex_shader", 2, 0 },
582  { "GL_ARB_fragment_shader", 2, 0 },
583  { "GL_ARB_shader_objects", 2, 0 },
584  { NULL, 0, 0 }
585  };
586  int i, major, minor;
587  const char *extensions, *version;
588 
589  version = glGetString(GL_VERSION);
590  extensions = glGetString(GL_EXTENSIONS);
591  if (!version || !extensions) {
592  av_log(h, AV_LOG_ERROR, "No OpenGL context initialized for the current thread\n");
593  return AVERROR(ENOSYS);
594  }
595 
596  av_log(h, AV_LOG_DEBUG, "OpenGL version: %s\n", version);
597  if (sscanf(version, "%d.%d", &major, &minor) != 2)
598  return AVERROR(ENOSYS);
599 
600  for (i = 0; required_extensions[i].extension; i++) {
601  if (major < required_extensions[i].major &&
602  (major == required_extensions[i].major && minor < required_extensions[i].minor) &&
603  !strstr(extensions, required_extensions[i].extension)) {
604  av_log(h, AV_LOG_ERROR, "Required extension %s is not supported.\n",
605  required_extensions[i].extension);
606  av_log(h, AV_LOG_DEBUG, "Supported extensions are: %s\n", extensions);
607  return AVERROR(ENOSYS);
608  }
609  }
610  glGetIntegerv(GL_MAX_TEXTURE_SIZE, &opengl->max_texture_size);
611  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, &opengl->max_viewport_width);
612  opengl->non_pow_2_textures = major >= 2 || strstr(extensions, "GL_ARB_texture_non_power_of_two");
613 #if defined(GL_ES_VERSION_2_0)
614  opengl->unpack_subimage = !!strstr(extensions, "GL_EXT_unpack_subimage");
615 #else
616  opengl->unpack_subimage = 1;
617 #endif
618 
619  av_log(h, AV_LOG_DEBUG, "Non Power of 2 textures support: %s\n", opengl->non_pow_2_textures ? "Yes" : "No");
620  av_log(h, AV_LOG_DEBUG, "Unpack Subimage extension support: %s\n", opengl->unpack_subimage ? "Yes" : "No");
621  av_log(h, AV_LOG_DEBUG, "Max texture size: %dx%d\n", opengl->max_texture_size, opengl->max_texture_size);
622  av_log(h, AV_LOG_DEBUG, "Max viewport size: %dx%d\n",
623  opengl->max_viewport_width, opengl->max_viewport_height);
624 
625  OPENGL_ERROR_CHECK(opengl);
626  return 0;
627  fail:
628  return AVERROR_EXTERNAL;
629 }
630 
631 static const char* opengl_get_fragment_shader_code(enum AVPixelFormat format)
632 {
633  int i;
634  for (i = 0; i < FF_ARRAY_ELEMS(opengl_format_desc); i++) {
635  if (opengl_format_desc[i].fixel_format == format)
636  return *opengl_format_desc[i].fragment_shader;
637  }
638  return NULL;
639 }
640 
641 static int opengl_type_size(GLenum type)
642 {
643  switch(type) {
644  case GL_UNSIGNED_SHORT:
645  case FF_GL_UNSIGNED_SHORT_1_5_5_5_REV:
646  case GL_UNSIGNED_SHORT_5_6_5:
647  return 2;
648  case GL_UNSIGNED_BYTE:
649  case FF_GL_UNSIGNED_BYTE_3_3_2:
650  case FF_GL_UNSIGNED_BYTE_2_3_3_REV:
651  default:
652  break;
653  }
654  return 1;
655 }
656 
657 static av_cold void opengl_get_texture_params(OpenGLContext *opengl)
658 {
659  int i;
660  for (i = 0; i < FF_ARRAY_ELEMS(opengl_format_desc); i++) {
661  if (opengl_format_desc[i].fixel_format == opengl->pix_fmt) {
662  opengl->format = opengl_format_desc[i].format;
663  opengl->type = opengl_format_desc[i].type;
664  break;
665  }
666  }
667 }
668 
669 static void opengl_compute_display_area(AVFormatContext *s)
670 {
671  AVRational sar, dar; /* sample and display aspect ratios */
672  OpenGLContext *opengl = s->priv_data;
673  AVStream *st = s->streams[0];
674  AVCodecParameters *par = st->codecpar;
675 
676  /* compute overlay width and height from the codec context information */
677  sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 };
678  dar = av_mul_q(sar, (AVRational){ par->width, par->height });
679 
680  /* we suppose the screen has a 1/1 sample aspect ratio */
681  /* fit in the window */
682  if (av_cmp_q(dar, (AVRational){ opengl->window_width, opengl->window_height }) > 0) {
683  /* fit in width */
684  opengl->picture_width = opengl->window_width;
685  opengl->picture_height = av_rescale(opengl->picture_width, dar.den, dar.num);
686  } else {
687  /* fit in height */
688  opengl->picture_height = opengl->window_height;
689  opengl->picture_width = av_rescale(opengl->picture_height, dar.num, dar.den);
690  }
691 }
692 
693 static av_cold void opengl_get_texture_size(OpenGLContext *opengl, int in_width, int in_height,
694  int *out_width, int *out_height)
695 {
696  if (opengl->non_pow_2_textures) {
697  *out_width = in_width;
698  *out_height = in_height;
699  } else {
700  int max = FFMIN(FFMAX(in_width, in_height), opengl->max_texture_size);
701  unsigned power_of_2 = 1;
702  while (power_of_2 < max)
703  power_of_2 *= 2;
704  *out_height = power_of_2;
705  *out_width = power_of_2;
706  av_log(opengl, AV_LOG_DEBUG, "Texture size calculated from %dx%d into %dx%d\n",
707  in_width, in_height, *out_width, *out_height);
708  }
709 }
710 
711 static av_cold void opengl_fill_color_map(OpenGLContext *opengl)
712 {
713  const AVPixFmtDescriptor *desc;
714  int shift;
715  enum AVPixelFormat pix_fmt = opengl->pix_fmt;
716 
717  /* We need order of components, not exact position, some minor HACKs here */
718  if (pix_fmt == AV_PIX_FMT_RGB565 || pix_fmt == AV_PIX_FMT_BGR555 ||
719  pix_fmt == AV_PIX_FMT_BGR8 || pix_fmt == AV_PIX_FMT_RGB8)
720  pix_fmt = AV_PIX_FMT_RGB24;
721  else if (pix_fmt == AV_PIX_FMT_BGR565 || pix_fmt == AV_PIX_FMT_RGB555)
722  pix_fmt = AV_PIX_FMT_BGR24;
723 
724  desc = av_pix_fmt_desc_get(pix_fmt);
725  if (!(desc->flags & AV_PIX_FMT_FLAG_RGB))
726  return;
727 
728 #define FILL_COMPONENT(i) { \
729  shift = (desc->comp[i].depth - 1) >> 3; \
730  opengl->color_map[(i << 2) + (desc->comp[i].offset >> shift)] = 1.0; \
731  }
732 
733  memset(opengl->color_map, 0, sizeof(opengl->color_map));
734  FILL_COMPONENT(0);
735  FILL_COMPONENT(1);
736  FILL_COMPONENT(2);
737  if (desc->flags & AV_PIX_FMT_FLAG_ALPHA)
738  FILL_COMPONENT(3);
739 
740 #undef FILL_COMPONENT
741 }
742 
743 static av_cold GLuint opengl_load_shader(OpenGLContext *opengl, GLenum type, const char *source)
744 {
745  GLuint shader = opengl->glprocs.glCreateShader(type);
746  GLint result;
747  if (!shader) {
748  av_log(opengl, AV_LOG_ERROR, "glCreateShader() failed\n");
749  return 0;
750  }
751  opengl->glprocs.glShaderSource(shader, 1, &source, NULL);
752  opengl->glprocs.glCompileShader(shader);
753 
754  opengl->glprocs.glGetShaderiv(shader, FF_GL_COMPILE_STATUS, &result);
755  if (!result) {
756  char *log;
757  opengl->glprocs.glGetShaderiv(shader, FF_GL_INFO_LOG_LENGTH, &result);
758  if (result) {
759  if ((log = av_malloc(result))) {
760  opengl->glprocs.glGetShaderInfoLog(shader, result, NULL, log);
761  av_log(opengl, AV_LOG_ERROR, "Compile error: %s\n", log);
762  av_free(log);
763  }
764  }
765  goto fail;
766  }
767  OPENGL_ERROR_CHECK(opengl);
768  return shader;
769  fail:
770  opengl->glprocs.glDeleteShader(shader);
771  return 0;
772 }
773 
774 static av_cold int opengl_compile_shaders(OpenGLContext *opengl, enum AVPixelFormat pix_fmt)
775 {
776  GLint result;
777  const char *fragment_shader_code = opengl_get_fragment_shader_code(pix_fmt);
778 
779  if (!fragment_shader_code) {
780  av_log(opengl, AV_LOG_ERROR, "Provided pixel format '%s' is not supported\n",
781  av_get_pix_fmt_name(pix_fmt));
782  return AVERROR(EINVAL);
783  }
784 
785  opengl->vertex_shader = opengl_load_shader(opengl, FF_GL_VERTEX_SHADER,
786  FF_OPENGL_VERTEX_SHADER);
787  if (!opengl->vertex_shader) {
788  av_log(opengl, AV_LOG_ERROR, "Vertex shader loading failed.\n");
789  goto fail;
790  }
791  opengl->fragment_shader = opengl_load_shader(opengl, FF_GL_FRAGMENT_SHADER,
792  fragment_shader_code);
793  if (!opengl->fragment_shader) {
794  av_log(opengl, AV_LOG_ERROR, "Fragment shader loading failed.\n");
795  goto fail;
796  }
797 
798  opengl->program = opengl->glprocs.glCreateProgram();
799  if (!opengl->program)
800  goto fail;
801 
802  opengl->glprocs.glAttachShader(opengl->program, opengl->vertex_shader);
803  opengl->glprocs.glAttachShader(opengl->program, opengl->fragment_shader);
804  opengl->glprocs.glLinkProgram(opengl->program);
805 
806  opengl->glprocs.glGetProgramiv(opengl->program, FF_GL_LINK_STATUS, &result);
807  if (!result) {
808  char *log;
809  opengl->glprocs.glGetProgramiv(opengl->program, FF_GL_INFO_LOG_LENGTH, &result);
810  if (result) {
811  log = av_malloc(result);
812  if (!log)
813  goto fail;
814  opengl->glprocs.glGetProgramInfoLog(opengl->program, result, NULL, log);
815  av_log(opengl, AV_LOG_ERROR, "Link error: %s\n", log);
816  av_free(log);
817  }
818  goto fail;
819  }
820 
821  opengl->position_attrib = opengl->glprocs.glGetAttribLocation(opengl->program, "a_position");
822  opengl->texture_coords_attrib = opengl->glprocs.glGetAttribLocation(opengl->program, "a_textureCoords");
823  opengl->projection_matrix_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_projectionMatrix");
824  opengl->model_view_matrix_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_modelViewMatrix");
825  opengl->color_map_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_colorMap");
826  opengl->texture_location[0] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture0");
827  opengl->texture_location[1] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture1");
828  opengl->texture_location[2] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture2");
829  opengl->texture_location[3] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture3");
830  opengl->chroma_div_w_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_chroma_div_w");
831  opengl->chroma_div_h_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_chroma_div_h");
832 
833  OPENGL_ERROR_CHECK(opengl);
834  return 0;
835  fail:
836  opengl->glprocs.glDeleteShader(opengl->vertex_shader);
837  opengl->glprocs.glDeleteShader(opengl->fragment_shader);
838  opengl->glprocs.glDeleteProgram(opengl->program);
839  opengl->fragment_shader = opengl->vertex_shader = opengl->program = 0;
840  return AVERROR_EXTERNAL;
841 }
842 
843 static av_cold int opengl_configure_texture(OpenGLContext *opengl, GLuint texture,
844  GLsizei width, GLsizei height)
845 {
846  if (texture) {
847  int new_width, new_height;
848  opengl_get_texture_size(opengl, width, height, &new_width, &new_height);
849  glBindTexture(GL_TEXTURE_2D, texture);
850  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
851  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
852  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
853  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
854  glTexImage2D(GL_TEXTURE_2D, 0, opengl->format, new_width, new_height, 0,
855  opengl->format, opengl->type, NULL);
856  OPENGL_ERROR_CHECK(NULL);
857  }
858  return 0;
859  fail:
860  return AVERROR_EXTERNAL;
861 }
862 
863 static av_cold int opengl_prepare_vertex(AVFormatContext *s)
864 {
865  OpenGLContext *opengl = s->priv_data;
866  int tex_w, tex_h;
867 
868  if (opengl->window_width > opengl->max_viewport_width || opengl->window_height > opengl->max_viewport_height) {
869  opengl->window_width = FFMIN(opengl->window_width, opengl->max_viewport_width);
870  opengl->window_height = FFMIN(opengl->window_height, opengl->max_viewport_height);
871  av_log(opengl, AV_LOG_WARNING, "Too big viewport requested, limited to %dx%d", opengl->window_width, opengl->window_height);
872  }
873  glViewport(0, 0, opengl->window_width, opengl->window_height);
874  opengl_make_ortho(opengl->projection_matrix,
875  - (float)opengl->window_width / 2.0f, (float)opengl->window_width / 2.0f,
876  - (float)opengl->window_height / 2.0f, (float)opengl->window_height / 2.0f,
877  1.0f, -1.0f);
878  opengl_make_identity(opengl->model_view_matrix);
879 
880  opengl_compute_display_area(s);
881 
882  opengl->vertex[0].z = opengl->vertex[1].z = opengl->vertex[2].z = opengl->vertex[3].z = 0.0f;
883  opengl->vertex[0].x = opengl->vertex[1].x = - (float)opengl->picture_width / 2.0f;
884  opengl->vertex[2].x = opengl->vertex[3].x = (float)opengl->picture_width / 2.0f;
885  opengl->vertex[1].y = opengl->vertex[2].y = - (float)opengl->picture_height / 2.0f;
886  opengl->vertex[0].y = opengl->vertex[3].y = (float)opengl->picture_height / 2.0f;
887 
888  opengl_get_texture_size(opengl, opengl->width, opengl->height, &tex_w, &tex_h);
889 
890  opengl->vertex[0].s0 = 0.0f;
891  opengl->vertex[0].t0 = 0.0f;
892  opengl->vertex[1].s0 = 0.0f;
893  opengl->vertex[1].t0 = (float)opengl->height / (float)tex_h;
894  opengl->vertex[2].s0 = (float)opengl->width / (float)tex_w;
895  opengl->vertex[2].t0 = (float)opengl->height / (float)tex_h;
896  opengl->vertex[3].s0 = (float)opengl->width / (float)tex_w;
897  opengl->vertex[3].t0 = 0.0f;
898 
899  opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, opengl->vertex_buffer);
900  opengl->glprocs.glBufferData(FF_GL_ARRAY_BUFFER, sizeof(opengl->vertex), opengl->vertex, FF_GL_STATIC_DRAW);
901  opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, 0);
902  OPENGL_ERROR_CHECK(opengl);
903  return 0;
904  fail:
905  return AVERROR_EXTERNAL;
906 }
907 
908 static int opengl_prepare(OpenGLContext *opengl)
909 {
910  int i;
911  opengl->glprocs.glUseProgram(opengl->program);
912  opengl->glprocs.glUniformMatrix4fv(opengl->projection_matrix_location, 1, GL_FALSE, opengl->projection_matrix);
913  opengl->glprocs.glUniformMatrix4fv(opengl->model_view_matrix_location, 1, GL_FALSE, opengl->model_view_matrix);
914  for (i = 0; i < 4; i++)
915  if (opengl->texture_location[i] != -1) {
916  opengl->glprocs.glActiveTexture(GL_TEXTURE0 + i);
917  glBindTexture(GL_TEXTURE_2D, opengl->texture_name[i]);
918  opengl->glprocs.glUniform1i(opengl->texture_location[i], i);
919  }
920  if (opengl->color_map_location != -1)
921  opengl->glprocs.glUniformMatrix4fv(opengl->color_map_location, 1, GL_FALSE, opengl->color_map);
922  if (opengl->chroma_div_h_location != -1)
923  opengl->glprocs.glUniform1f(opengl->chroma_div_h_location, opengl->chroma_div_h);
924  if (opengl->chroma_div_w_location != -1)
925  opengl->glprocs.glUniform1f(opengl->chroma_div_w_location, opengl->chroma_div_w);
926 
927  OPENGL_ERROR_CHECK(opengl);
928  return 0;
929  fail:
930  return AVERROR_EXTERNAL;
931 }
932 
933 static int opengl_create_window(AVFormatContext *h)
934 {
935  OpenGLContext *opengl = h->priv_data;
936  int ret;
937 
938  if (!opengl->no_window) {
939 #if CONFIG_SDL2
940  if ((ret = opengl_sdl_create_window(h)) < 0) {
941  av_log(opengl, AV_LOG_ERROR, "Cannot create default SDL window.\n");
942  return ret;
943  }
944 #else
945  av_log(opengl, AV_LOG_ERROR, "FFmpeg is compiled without SDL. Cannot create default window.\n");
946  return AVERROR(ENOSYS);
947 #endif
948  } else {
949  AVDeviceRect message;
950  message.x = message.y = 0;
951  message.width = opengl->window_width;
952  message.height = opengl->window_height;
953  if ((ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_CREATE_WINDOW_BUFFER,
954  &message , sizeof(message))) < 0) {
955  av_log(opengl, AV_LOG_ERROR, "Application failed to create window buffer.\n");
956  return ret;
957  }
958  if ((ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0)) < 0) {
959  av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
960  return ret;
961  }
962  }
963  return 0;
964 }
965 
966 static int opengl_release_window(AVFormatContext *h)
967 {
968  int ret;
969  OpenGLContext *opengl = h->priv_data;
970  if (!opengl->no_window) {
971 #if CONFIG_SDL2
972  SDL_GL_DeleteContext(opengl->glcontext);
973  SDL_DestroyWindow(opengl->window);
974  SDL_Quit();
975 #endif
976  } else if ((ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER, NULL , 0)) < 0) {
977  av_log(opengl, AV_LOG_ERROR, "Application failed to release window buffer.\n");
978  return ret;
979  }
980  return 0;
981 }
982 
983 static av_cold int opengl_write_trailer(AVFormatContext *h)
984 {
985  OpenGLContext *opengl = h->priv_data;
986 
987  if (opengl->no_window &&
988  avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0) < 0)
989  av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
990 
991  opengl_deinit_context(opengl);
992  opengl_release_window(h);
993 
994  return 0;
995 }
996 
997 static av_cold int opengl_init_context(OpenGLContext *opengl)
998 {
999  int i, ret;
1000  const AVPixFmtDescriptor *desc;
1001 
1002  if ((ret = opengl_compile_shaders(opengl, opengl->pix_fmt)) < 0)
1003  goto fail;
1004 
1005  desc = av_pix_fmt_desc_get(opengl->pix_fmt);
1006  av_assert0(desc->nb_components > 0 && desc->nb_components <= 4);
1007  glGenTextures(desc->nb_components, opengl->texture_name);
1008 
1009  opengl->glprocs.glGenBuffers(2, &opengl->index_buffer);
1010  if (!opengl->index_buffer || !opengl->vertex_buffer) {
1011  av_log(opengl, AV_LOG_ERROR, "Buffer generation failed.\n");
1012  ret = AVERROR_EXTERNAL;
1013  goto fail;
1014  }
1015 
1016  opengl_configure_texture(opengl, opengl->texture_name[0], opengl->width, opengl->height);
1017  if (desc->nb_components > 1) {
1018  int has_alpha = desc->flags & AV_PIX_FMT_FLAG_ALPHA;
1019  int num_planes = desc->nb_components - (has_alpha ? 1 : 0);
1020  if (opengl->non_pow_2_textures) {
1021  opengl->chroma_div_w = 1.0f;
1022  opengl->chroma_div_h = 1.0f;
1023  } else {
1024  opengl->chroma_div_w = 1 << desc->log2_chroma_w;
1025  opengl->chroma_div_h = 1 << desc->log2_chroma_h;
1026  }
1027  for (i = 1; i < num_planes; i++)
1028  if (opengl->non_pow_2_textures)
1029  opengl_configure_texture(opengl, opengl->texture_name[i],
1030  AV_CEIL_RSHIFT(opengl->width, desc->log2_chroma_w),
1031  AV_CEIL_RSHIFT(opengl->height, desc->log2_chroma_h));
1032  else
1033  opengl_configure_texture(opengl, opengl->texture_name[i], opengl->width, opengl->height);
1034  if (has_alpha)
1035  opengl_configure_texture(opengl, opengl->texture_name[3], opengl->width, opengl->height);
1036  }
1037 
1038  opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, opengl->index_buffer);
1039  opengl->glprocs.glBufferData(FF_GL_ELEMENT_ARRAY_BUFFER, sizeof(g_index), g_index, FF_GL_STATIC_DRAW);
1040  opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, 0);
1041 
1042  glEnable(GL_BLEND);
1043  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1044 
1045  glClearColor((float)opengl->background[0] / 255.0f, (float)opengl->background[1] / 255.0f,
1046  (float)opengl->background[2] / 255.0f, 1.0f);
1047 
1048  ret = AVERROR_EXTERNAL;
1049  OPENGL_ERROR_CHECK(opengl);
1050 
1051  return 0;
1052  fail:
1053  return ret;
1054 }
1055 
1056 static av_cold int opengl_write_header(AVFormatContext *h)
1057 {
1058  OpenGLContext *opengl = h->priv_data;
1059  AVCodecParameters *par = h->streams[0]->codecpar;
1060  AVStream *st;
1061  int ret;
1062 
1063  if (h->nb_streams != 1 ||
1064  par->codec_type != AVMEDIA_TYPE_VIDEO ||
1065  (par->codec_id != AV_CODEC_ID_WRAPPED_AVFRAME && par->codec_id != AV_CODEC_ID_RAWVIDEO)) {
1066  av_log(opengl, AV_LOG_ERROR, "Only a single raw or wrapped avframe video stream is supported.\n");
1067  return AVERROR(EINVAL);
1068  }
1069  st = h->streams[0];
1070  opengl->width = st->codecpar->width;
1071  opengl->height = st->codecpar->height;
1072  opengl->pix_fmt = st->codecpar->format;
1073  if (!opengl->window_width)
1074  opengl->window_width = opengl->width;
1075  if (!opengl->window_height)
1076  opengl->window_height = opengl->height;
1077 
1078  if (!opengl->window_title && !opengl->no_window)
1079  opengl->window_title = av_strdup(h->url);
1080 
1081  if ((ret = opengl_create_window(h)))
1082  goto fail;
1083 
1084  if ((ret = opengl_read_limits(h)) < 0)
1085  goto fail;
1086 
1087  if (opengl->width > opengl->max_texture_size || opengl->height > opengl->max_texture_size) {
1088  av_log(opengl, AV_LOG_ERROR, "Too big picture %dx%d, max supported size is %dx%d\n",
1089  opengl->width, opengl->height, opengl->max_texture_size, opengl->max_texture_size);
1090  ret = AVERROR(EINVAL);
1091  goto fail;
1092  }
1093 
1094  if ((ret = opengl_load_procedures(opengl)) < 0)
1095  goto fail;
1096 
1097  opengl_fill_color_map(opengl);
1098  opengl_get_texture_params(opengl);
1099 
1100  if ((ret = opengl_init_context(opengl)) < 0)
1101  goto fail;
1102 
1103  if ((ret = opengl_prepare_vertex(h)) < 0)
1104  goto fail;
1105 
1106  glClear(GL_COLOR_BUFFER_BIT);
1107 
1108 #if CONFIG_SDL2
1109  if (!opengl->no_window)
1110  SDL_GL_SwapWindow(opengl->window);
1111 #endif
1112  if (opengl->no_window &&
1113  (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER, NULL , 0)) < 0) {
1114  av_log(opengl, AV_LOG_ERROR, "Application failed to display window buffer.\n");
1115  goto fail;
1116  }
1117 
1118  ret = AVERROR_EXTERNAL;
1119  OPENGL_ERROR_CHECK(opengl);
1120 
1121  opengl->inited = 1;
1122  return 0;
1123 
1124  fail:
1125  opengl_write_trailer(h);
1126  return ret;
1127 }
1128 
1129 static uint8_t* opengl_get_plane_pointer(OpenGLContext *opengl, AVPacket *pkt, int comp_index,
1130  const AVPixFmtDescriptor *desc)
1131 {
1132  uint8_t *data = pkt->data;
1133  int wordsize = opengl_type_size(opengl->type);
1134  int width_chroma = AV_CEIL_RSHIFT(opengl->width, desc->log2_chroma_w);
1135  int height_chroma = AV_CEIL_RSHIFT(opengl->height, desc->log2_chroma_h);
1136  int plane = desc->comp[comp_index].plane;
1137 
1138  switch(plane) {
1139  case 0:
1140  break;
1141  case 1:
1142  data += opengl->width * opengl->height * wordsize;
1143  break;
1144  case 2:
1145  data += opengl->width * opengl->height * wordsize;
1146  data += width_chroma * height_chroma * wordsize;
1147  break;
1148  case 3:
1149  data += opengl->width * opengl->height * wordsize;
1150  data += 2 * width_chroma * height_chroma * wordsize;
1151  break;
1152  default:
1153  return NULL;
1154  }
1155  return data;
1156 }
1157 
1158 #define LOAD_TEXTURE_DATA(comp_index, sub) \
1159 { \
1160  int width = sub ? AV_CEIL_RSHIFT(opengl->width, desc->log2_chroma_w) : opengl->width; \
1161  int height = sub ? AV_CEIL_RSHIFT(opengl->height, desc->log2_chroma_h): opengl->height; \
1162  uint8_t *data; \
1163  int plane = desc->comp[comp_index].plane; \
1164  \
1165  glBindTexture(GL_TEXTURE_2D, opengl->texture_name[comp_index]); \
1166  if (!is_pkt) { \
1167  GLint length = ((AVFrame *)input)->linesize[plane]; \
1168  int bytes_per_pixel = opengl_type_size(opengl->type); \
1169  if (!(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) \
1170  bytes_per_pixel *= desc->nb_components; \
1171  data = ((AVFrame *)input)->data[plane]; \
1172  if (!(length % bytes_per_pixel) && \
1173  (opengl->unpack_subimage || ((length / bytes_per_pixel) == width))) { \
1174  length /= bytes_per_pixel; \
1175  if (length != width) \
1176  glPixelStorei(FF_GL_UNPACK_ROW_LENGTH, length); \
1177  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, \
1178  opengl->format, opengl->type, data); \
1179  if (length != width) \
1180  glPixelStorei(FF_GL_UNPACK_ROW_LENGTH, 0); \
1181  } else { \
1182  int h; \
1183  for (h = 0; h < height; h++) { \
1184  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, h, width, 1, \
1185  opengl->format, opengl->type, data); \
1186  data += length; \
1187  } \
1188  } \
1189  } else { \
1190  data = opengl_get_plane_pointer(opengl, input, comp_index, desc); \
1191  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, \
1192  opengl->format, opengl->type, data); \
1193  } \
1194 }
1195 
1196 static int opengl_draw(AVFormatContext *h, void *input, int repaint, int is_pkt)
1197 {
1198  OpenGLContext *opengl = h->priv_data;
1199  enum AVPixelFormat pix_fmt = h->streams[0]->codecpar->format;
1200  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
1201  int ret;
1202 
1203 #if CONFIG_SDL2
1204  /* At this point, opengl->glcontext implies opengl->glcontext */
1205  if (opengl->glcontext)
1206  SDL_GL_MakeCurrent(opengl->window, opengl->glcontext);
1207 
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 CONFIG_SDL2
1249  if (!opengl->no_window)
1250  SDL_GL_SwapWindow(opengl->window);
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  AVCodecParameters *par = h->streams[0]->codecpar;
1266  if (par->codec_id == AV_CODEC_ID_WRAPPED_AVFRAME) {
1267  AVFrame *frame = (AVFrame *)pkt->data;
1268  return opengl_draw(h, frame, 0, 0);
1269  } else {
1270  return opengl_draw(h, pkt, 0, 1);
1271  }
1272 }
1273 
1274 static int opengl_write_frame(AVFormatContext *h, int stream_index,
1275  AVFrame **frame, unsigned flags)
1276 {
1277  if ((flags & AV_WRITE_UNCODED_FRAME_QUERY))
1278  return 0;
1279  return opengl_draw(h, *frame, 0, 0);
1280 }
1281 
1282 #define OFFSET(x) offsetof(OpenGLContext, x)
1283 #define ENC AV_OPT_FLAG_ENCODING_PARAM
1284 static const AVOption options[] = {
1285  { "background", "set background color", OFFSET(background), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, ENC },
1286  { "no_window", "disable default window", OFFSET(no_window), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, ENC },
1287  { "window_title", "set window title", OFFSET(window_title), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, ENC },
1288  { "window_size", "set window size", OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, ENC },
1289  { NULL }
1290 };
1291 
1292 static const AVClass opengl_class = {
1293  .class_name = "opengl outdev",
1294  .item_name = av_default_item_name,
1295  .option = options,
1296  .version = LIBAVUTIL_VERSION_INT,
1297  .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT,
1298 };
1299 
1300 const FFOutputFormat ff_opengl_muxer = {
1301  .p.name = "opengl",
1302  .p.long_name = NULL_IF_CONFIG_SMALL("OpenGL output"),
1303  .p.audio_codec = AV_CODEC_ID_NONE,
1304  .p.video_codec = AV_CODEC_ID_WRAPPED_AVFRAME,
1305  .p.flags = AVFMT_NOFILE | AVFMT_VARIABLE_FPS | AVFMT_NOTIMESTAMPS,
1306  .p.priv_class = &opengl_class,
1307  .priv_data_size = sizeof(OpenGLContext),
1308  .write_header = opengl_write_header,
1309  .write_packet = opengl_write_packet,
1310  .write_uncoded_frame = opengl_write_frame,
1311  .write_trailer = opengl_write_trailer,
1312  .control_message = opengl_control_message,
1313 };
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:512
OpenGLContext::vertex_buffer
GLuint vertex_buffer
Vertex buffer.
Definition: opengl_enc.c:200
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:491
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
OpenGLContext::width
int width
Stream width.
Definition: opengl_enc.c:220
FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET
static const char *const FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET
Fragment shader for packet RGBA formats.
Definition: opengl_enc_shaders.h:44
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
FF_PFNGLSHADERSOURCEPROC
void(APIENTRY * FF_PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const char **string, const GLint *length)
Definition: opengl_enc.c:119
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
options
static const AVOption options[]
Definition: opengl_enc.c:1284
AVOutputFormat::name
const char * name
Definition: avformat.h:511
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
FF_PFNGLCREATESHADERPROC
GLuint(APIENTRY * FF_PFNGLCREATESHADERPROC)(GLenum type)
Definition: opengl_enc.c:116
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
ff_opengl_muxer
const FFOutputFormat ff_opengl_muxer
Definition: opengl_enc.c:1300
message
Definition: api-threadmessage-test.c:46
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
OpenGLContext::chroma_div_h_location
GLint chroma_div_h_location
Definition: opengl_enc.c:206
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2964
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:483
opengl_enc_shaders.h
matrix
Definition: vc1dsp.c:42
FFOpenGLFunctions::glGetProgramiv
FF_PFNGLGETPROGRAMIVPROC glGetProgramiv
Definition: opengl_enc.c:140
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:480
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
OpenGLContext::texture_location
GLint texture_location[4]
Definition: opengl_enc.c:207
opengl_init_context
static av_cold int opengl_init_context(OpenGLContext *opengl)
Definition: opengl_enc.c:997
normalize.log
log
Definition: normalize.py:21
AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER
@ AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER
Prepare window buffer message.
Definition: avdevice.h:235
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
opengl_control_message
static int opengl_control_message(AVFormatContext *h, int type, void *data, size_t data_size)
Definition: opengl_enc.c:329
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:511
OpenGLFormatDesc::type
GLenum type
Definition: opengl_enc.c:233
opengl_get_fragment_shader_code
static const char * opengl_get_fragment_shader_code(enum AVPixelFormat format)
Definition: opengl_enc.c:631
AVPacket::data
uint8_t * data
Definition: packet.h:491
AVOption
AVOption.
Definition: opt.h:251
OpenGLContext::max_viewport_width
GLint max_viewport_width
Maximum viewport size.
Definition: opengl_enc.c:189
data
const char data[16]
Definition: mxf.c:148
avdevice_dev_to_app_control_message
int avdevice_dev_to_app_control_message(struct AVFormatContext *s, enum AVDevToAppMessageType type, void *data, size_t data_size)
Send control message from device to application.
Definition: avdevice.c:32
FF_OPENGL_VERTEX_SHADER
static const char *const FF_OPENGL_VERTEX_SHADER
Definition: opengl_enc_shaders.h:26
g_index
static const GLushort g_index[6]
Definition: opengl_enc.c:167
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
OpenGLContext::vertex_shader
GLuint vertex_shader
Vertex shader.
Definition: opengl_enc.c:196
OpenGLContext::no_window
int no_window
0 for create default window
Definition: opengl_enc.c:184
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
max
#define max(a, b)
Definition: cuda_runtime.h:33
FF_PFNGLDELETEBUFFERSPROC
void(APIENTRY * FF_PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers)
Definition: opengl_enc.c:99
FF_PFNGLATTACHSHADERPROC
void(APIENTRY * FF_PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader)
Definition: opengl_enc.c:115
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
OpenGLContext::color_map
GLfloat color_map[16]
RGBA color map matrix.
Definition: opengl_enc.c:213
opengl_load_shader
static av_cold GLuint opengl_load_shader(OpenGLContext *opengl, GLenum type, const char *source)
Definition: opengl_enc.c:743
AV_APP_TO_DEV_WINDOW_REPAINT
@ AV_APP_TO_DEV_WINDOW_REPAINT
Repaint request message.
Definition: avdevice.h:150
FF_OPENGL_FRAGMENT_SHADER_GRAY
static const char *const FF_OPENGL_FRAGMENT_SHADER_GRAY
Definition: opengl_enc_shaders.h:176
FF_PFNGLCOMPILESHADERPROC
void(APIENTRY * FF_PFNGLCOMPILESHADERPROC)(GLuint shader)
Definition: opengl_enc.c:118
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:36
FF_PFNGLGETSHADERIVPROC
void(APIENTRY * FF_PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params)
Definition: opengl_enc.c:120
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
OpenGLVertexInfo::z
float z
Position.
Definition: opengl_enc.c:162
FF_GL_UNSIGNED_SHORT_1_5_5_5_REV
#define FF_GL_UNSIGNED_SHORT_1_5_5_5_REV
Definition: opengl_enc.c:85
OpenGLContext::chroma_div_h
GLfloat chroma_div_h
Chroma subsampling h ratio.
Definition: opengl_enc.c:215
FF_GL_UNSIGNED_BYTE_2_3_3_REV
#define FF_GL_UNSIGNED_BYTE_2_3_3_REV
Definition: opengl_enc.c:84
window
static SDL_Window * window
Definition: ffplay.c:360
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
FF_PFNGLUNIFORM1IPROC
void(APIENTRY * FF_PFNGLUNIFORM1IPROC)(GLint location, GLint v0)
Definition: opengl_enc.c:107
v0
#define v0
Definition: regdef.h:26
fail
#define fail()
Definition: checkasm.h:138
FFOpenGLFunctions::glCreateProgram
FF_PFNGLCREATEPROGRAMPROC glCreateProgram
Definition: opengl_enc.c:136
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:513
opengl_compute_display_area
static void opengl_compute_display_area(AVFormatContext *s)
Definition: opengl_enc.c:669
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
OpenGLContext::texture_name
GLuint texture_name[4]
Textures' IDs.
Definition: opengl_enc.c:198
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
OpenGLFormatDesc::fixel_format
enum AVPixelFormat fixel_format
Definition: opengl_enc.c:230
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:452
opengl_write_frame
static int opengl_write_frame(AVFormatContext *h, int stream_index, AVFrame **frame, unsigned flags)
Definition: opengl_enc.c:1274
APIENTRY
#define APIENTRY
Definition: opengl_enc.c:64
opengl_configure_texture
static av_cold int opengl_configure_texture(OpenGLContext *opengl, GLuint texture, GLsizei width, GLsizei height)
Definition: opengl_enc.c:843
OFFSET
#define OFFSET(x)
Definition: opengl_enc.c:1282
AVRational::num
int num
Numerator.
Definition: rational.h:59
FFOpenGLFunctions::glUniformMatrix4fv
FF_PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv
Definition: opengl_enc.c:135
FF_PFNGLGETSHADERINFOLOGPROC
void(APIENTRY * FF_PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, char *infoLog)
Definition: opengl_enc.c:121
OpenGLContext::fragment_shader
GLuint fragment_shader
Fragment shader for current pix_pmt.
Definition: opengl_enc.c:197
FFOpenGLFunctions::glCreateShader
FF_PFNGLCREATESHADERPROC glCreateShader
Definition: opengl_enc.c:143
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
OpenGLContext::texture_coords_attrib
GLint texture_coords_attrib
Definition: opengl_enc.c:209
opengl_prepare
static int opengl_prepare(OpenGLContext *opengl)
Definition: opengl_enc.c:908
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
opengl_get_texture_size
static av_cold void opengl_get_texture_size(OpenGLContext *opengl, int in_width, int in_height, int *out_width, int *out_height)
Definition: opengl_enc.c:693
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:480
OpenGLContext::picture_height
int picture_height
Rendered height.
Definition: opengl_enc.c:224
opengl_make_ortho
static void opengl_make_ortho(float matrix[16], float left, float right, float bottom, float top, float nearZ, float farZ)
Definition: opengl_enc.c:551
AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER
@ AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER
Display window buffer message.
Definition: avdevice.h:246
OpenGLContext::position_attrib
GLint position_attrib
Attibutes' locations.
Definition: opengl_enc.c:208
float
float
Definition: af_crystalizer.c:121
OpenGLContext::format
GLenum format
Definition: opengl_enc.c:218
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
OpenGLContext::color_map_location
GLint color_map_location
Definition: opengl_enc.c:204
LOAD_OPENGL_FUN
#define LOAD_OPENGL_FUN(name, type)
OpenGLFormatDesc
Definition: opengl_enc.c:229
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:481
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:121
OpenGLContext::unpack_subimage
int unpack_subimage
1 when GL_EXT_unpack_subimage is available
Definition: opengl_enc.c:192
FFOpenGLFunctions::glUniform1i
FF_PFNGLUNIFORM1IPROC glUniform1i
Definition: opengl_enc.c:134
FF_PFNGLBINDBUFFERPROC
void(APIENTRY * FF_PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer)
Definition: opengl_enc.c:101
AV_DEV_TO_APP_CREATE_WINDOW_BUFFER
@ AV_DEV_TO_APP_CREATE_WINDOW_BUFFER
Create window buffer message.
Definition: avdevice.h:224
OpenGLContext::window_height
int window_height
Definition: opengl_enc.c:226
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
opengl_write_packet
static int opengl_write_packet(AVFormatContext *h, AVPacket *pkt)
Definition: opengl_enc.c:1263
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:479
opengl_make_identity
static void opengl_make_identity(float matrix[16])
Definition: opengl_enc.c:545
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
FF_OPENGL_FRAGMENT_SHADER_RGB_PLANAR
static const char *const FF_OPENGL_FRAGMENT_SHADER_RGB_PLANAR
Fragment shader for planar RGB formats.
Definition: opengl_enc_shaders.h:100
FF_PFNGLBUFFERDATAPROC
void(APIENTRY * FF_PFNGLBUFFERDATAPROC)(GLenum target, ptrdiff_t size, const GLvoid *data, GLenum usage)
Definition: opengl_enc.c:100
FF_GL_FRAGMENT_SHADER
#define FF_GL_FRAGMENT_SHADER
Definition: opengl_enc.c:92
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AV_CODEC_ID_WRAPPED_AVFRAME
@ AV_CODEC_ID_WRAPPED_AVFRAME
Passthrough codec, AVFrames wrapped in AVPacket.
Definition: codec_id.h:601
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
frame
static AVFrame * frame
Definition: demux_decode.c:54
opengl_format_desc
static const struct OpenGLFormatDesc opengl_format_desc[]
FF_PFNGLUNIFORM1FPROC
void(APIENTRY * FF_PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0)
Definition: opengl_enc.c:106
window_title
static const char * window_title
Definition: ffplay.c:309
AVFormatContext
Format I/O context.
Definition: avformat.h:1115
OpenGLContext::max_viewport_height
GLint max_viewport_height
Maximum viewport size.
Definition: opengl_enc.c:190
internal.h
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:487
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
OpenGLContext::window_title
char * window_title
Title of the window.
Definition: opengl_enc.c:185
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:458
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:459
NULL
#define NULL
Definition: coverity.c:32
FF_PFNGLVERTEXATTRIBPOINTERPROC
void(APIENTRY * FF_PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, uintptr_t pointer)
Definition: opengl_enc.c:104
FFOpenGLFunctions::glGetAttribLocation
FF_PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation
Definition: opengl_enc.c:129
FF_PFNGLENABLEVERTEXATTRIBARRAYPROC
void(APIENTRY * FF_PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index)
Definition: opengl_enc.c:103
ENC
#define ENC
Definition: opengl_enc.c:1283
opengl_read_limits
static av_cold int opengl_read_limits(AVFormatContext *h)
Definition: opengl_enc.c:571
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:101
OpenGLVertexInfo::x
float x
Definition: opengl_enc.c:162
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
FF_GL_VERTEX_SHADER
#define FF_GL_VERTEX_SHADER
Definition: opengl_enc.c:93
OpenGLContext::program
GLuint program
Shader program.
Definition: opengl_enc.c:195
AV_OPT_TYPE_COLOR
@ AV_OPT_TYPE_COLOR
Definition: opt.h:240
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:235
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR
static const char *const FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR
Fragment shader for planar YUV formats.
Definition: opengl_enc_shaders.h:121
AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT
@ AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT
Definition: log.h:40
FF_OPENGL_FRAGMENT_SHADER_RGBA_PLANAR
static const char *const FF_OPENGL_FRAGMENT_SHADER_RGBA_PLANAR
Fragment shader for planar RGBA formats.
Definition: opengl_enc_shaders.h:78
FFOutputFormat
Definition: mux.h:32
OpenGLContext::pix_fmt
enum AVPixelFormat pix_fmt
Stream pixel format.
Definition: opengl_enc.c:222
FFOpenGLFunctions::glGetShaderInfoLog
FF_PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog
Definition: opengl_enc.c:148
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:258
opengl_fill_color_map
static av_cold void opengl_fill_color_map(OpenGLContext *opengl)
Definition: opengl_enc.c:711
FF_PFNGLDELETESHADERPROC
void(APIENTRY * FF_PFNGLDELETESHADERPROC)(GLuint shader)
Definition: opengl_enc.c:117
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
FF_PFNGLGETPROGRAMIVPROC
void(APIENTRY * FF_PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params)
Definition: opengl_enc.c:113
opengl_compile_shaders
static av_cold int opengl_compile_shaders(OpenGLContext *opengl, enum AVPixelFormat pix_fmt)
Definition: opengl_enc.c:774
index
int index
Definition: gxfenc.c:89
OPENGL_ERROR_CHECK
#define OPENGL_ERROR_CHECK(ctx)
Definition: opengl_enc.c:151
source
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a source
Definition: filter_design.txt:255
FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET
static const char *const FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET
Fragment shader for packet RGB formats.
Definition: opengl_enc_shaders.h:61
usage
const char * usage
Definition: floatimg_cmp.c:60
opengl_deinit_context
static av_cold void opengl_deinit_context(OpenGLContext *opengl)
Definition: opengl_enc.c:283
FFOpenGLFunctions::glUniform1f
FF_PFNGLUNIFORM1FPROC glUniform1f
Definition: opengl_enc.c:133
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
opengl_prepare_vertex
static av_cold int opengl_prepare_vertex(AVFormatContext *s)
Definition: opengl_enc.c:863
opengl_load_procedures
static int av_cold opengl_load_procedures(OpenGLContext *opengl)
Definition: opengl_enc.c:490
opengl_draw
static int opengl_draw(AVFormatContext *h, void *intput, int repaint, int is_pkt)
Definition: opengl_enc.c:1196
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
FF_GL_COMPILE_STATUS
#define FF_GL_COMPILE_STATUS
Definition: opengl_enc.c:94
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
shift
static int shift(int a, int b)
Definition: bonk.c:262
FFOpenGLFunctions::glCompileShader
FF_PFNGLCOMPILESHADERPROC glCompileShader
Definition: opengl_enc.c:145
OpenGLContext::glprocs
FFOpenGLFunctions glprocs
Definition: opengl_enc.c:180
FF_GL_STATIC_DRAW
#define FF_GL_STATIC_DRAW
Definition: opengl_enc.c:91
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:454
size
int size
Definition: twinvq_data.h:10344
FF_GL_ELEMENT_ARRAY_BUFFER
#define FF_GL_ELEMENT_ARRAY_BUFFER
Definition: opengl_enc.c:90
FF_PFNGLUSEPROGRAMPROC
void(APIENTRY * FF_PFNGLUSEPROGRAMPROC)(GLuint program)
Definition: opengl_enc.c:111
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:461
opengl_get_plane_pointer
static uint8_t * opengl_get_plane_pointer(OpenGLContext *opengl, AVPacket *pkt, int comp_index, const AVPixFmtDescriptor *desc)
Definition: opengl_enc.c:1129
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:469
OpenGLContext::chroma_div_w
GLfloat chroma_div_w
Chroma subsampling w ratio.
Definition: opengl_enc.c:214
OpenGLContext::projection_matrix_location
GLint projection_matrix_location
Uniforms' locations.
Definition: opengl_enc.c:202
FFOpenGLFunctions::glLinkProgram
FF_PFNGLLINKPROGRAMPROC glLinkProgram
Definition: opengl_enc.c:139
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:919
frame.h
avdevice.h
OpenGLContext::picture_width
int picture_width
Rendered width.
Definition: opengl_enc.c:223
height
#define height
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
OpenGLContext::index_buffer
GLuint index_buffer
Index buffer.
Definition: opengl_enc.c:199
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:256
version
version
Definition: libkvazaar.c:321
FFOpenGLFunctions::glDeleteProgram
FF_PFNGLDELETEPROGRAMPROC glDeleteProgram
Definition: opengl_enc.c:137
FF_GL_LINK_STATUS
#define FF_GL_LINK_STATUS
Definition: opengl_enc.c:95
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
OpenGLContext::height
int height
Stream height.
Definition: opengl_enc.c:221
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
OpenGLVertexInfo::s0
float s0
Definition: opengl_enc.c:163
FF_PFNGLGETPROGRAMINFOLOGPROC
void(APIENTRY * FF_PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, char *infoLog)
Definition: opengl_enc.c:114
FFOpenGLFunctions::glDeleteShader
FF_PFNGLDELETESHADERPROC glDeleteShader
Definition: opengl_enc.c:144
opengl_release_window
static int opengl_release_window(AVFormatContext *h)
Definition: opengl_enc.c:966
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:463
AVDeviceRect
Definition: avdevice.h:115
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
opengl_create_window
static int opengl_create_window(AVFormatContext *h)
Definition: opengl_enc.c:933
OpenGLContext::background
uint8_t background[4]
Background color.
Definition: opengl_enc.c:183
AVCodecParameters::height
int height
Definition: codec_par.h:122
opengl_class
static const AVClass opengl_class
Definition: opengl_enc.c:1292
opengl_get_texture_params
static av_cold void opengl_get_texture_params(OpenGLContext *opengl)
Definition: opengl_enc.c:657
LOAD_TEXTURE_DATA
#define LOAD_TEXTURE_DATA(comp_index, sub)
Definition: opengl_enc.c:1158
common.h
OpenGLVertexInfo::y
float y
Definition: opengl_enc.c:162
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:456
OpenGLContext::inited
int inited
Set to 1 when write_header was successfully called.
Definition: opengl_enc.c:182
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FFOpenGLFunctions::glGenBuffers
FF_PFNGLGENBUFFERSPROC glGenBuffers
Definition: opengl_enc.c:125
FF_GL_ARRAY_BUFFER
#define FF_GL_ARRAY_BUFFER
Definition: opengl_enc.c:89
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:460
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
FFOpenGLFunctions::glAttachShader
FF_PFNGLATTACHSHADERPROC glAttachShader
Definition: opengl_enc.c:142
write_packet
static int write_packet(Muxer *mux, OutputStream *ost, AVPacket *pkt)
Definition: ffmpeg_mux.c:61
OpenGLContext::model_view_matrix_location
GLint model_view_matrix_location
Definition: opengl_enc.c:203
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:455
FFOpenGLFunctions::glBindBuffer
FF_PFNGLBINDBUFFERPROC glBindBuffer
Definition: opengl_enc.c:128
stride
#define stride
Definition: h264pred_template.c:537
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AV_APP_TO_DEV_WINDOW_SIZE
@ AV_APP_TO_DEV_WINDOW_SIZE
Window size change message.
Definition: avdevice.h:140
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:841
OpenGLContext
Definition: opengl_enc.c:173
FF_PFNGLACTIVETEXTUREPROC
void(APIENTRY * FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
Definition: opengl_enc.c:97
FFOpenGLFunctions::glGetUniformLocation
FF_PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation
Definition: opengl_enc.c:132
AV_PIX_FMT_0BGR
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:257
OpenGLFormatDesc::format
GLenum format
Definition: opengl_enc.c:232
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
FFOpenGLFunctions::glDeleteBuffers
FF_PFNGLDELETEBUFFERSPROC glDeleteBuffers
Definition: opengl_enc.c:126
OpenGLVertexInfo
Definition: opengl_enc.c:160
avformat.h
opengl_resize
static int opengl_resize(AVFormatContext *h, int width, int height)
Definition: opengl_enc.c:309
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
FFOpenGLFunctions::glActiveTexture
FF_PFNGLACTIVETEXTUREPROC glActiveTexture
Definition: opengl_enc.c:124
FFOpenGLFunctions::glGetProgramInfoLog
FF_PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog
Definition: opengl_enc.c:141
OpenGLVertexInfo::t0
float t0
Texture coords.
Definition: opengl_enc.c:163
FFOpenGLFunctions::glBufferData
FF_PFNGLBUFFERDATAPROC glBufferData
Definition: opengl_enc.c:127
FFOpenGLFunctions::glUseProgram
FF_PFNGLUSEPROGRAMPROC glUseProgram
Definition: opengl_enc.c:138
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
FF_GL_RED_COMPONENT
#define FF_GL_RED_COMPONENT
Definition: opengl_enc.c:79
OpenGLContext::model_view_matrix
GLfloat model_view_matrix[16]
Modev view matrix.
Definition: opengl_enc.c:212
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: mux.h:210
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
opengl_type_size
static int opengl_type_size(GLenum type)
Definition: opengl_enc.c:641
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
FF_GL_UNSIGNED_BYTE_3_3_2
#define FF_GL_UNSIGNED_BYTE_3_3_2
Definition: opengl_enc.c:83
FF_GL_INFO_LOG_LENGTH
#define FF_GL_INFO_LOG_LENGTH
Definition: opengl_enc.c:96
FF_PFNGLGETUNIFORMLOCATIONPROC
GLint(APIENTRY * FF_PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const char *name)
Definition: opengl_enc.c:105
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
opengl_write_trailer
static av_cold int opengl_write_trailer(AVFormatContext *h)
Definition: opengl_enc.c:983
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FF_PFNGLLINKPROGRAMPROC
void(APIENTRY * FF_PFNGLLINKPROGRAMPROC)(GLuint program)
Definition: opengl_enc.c:112
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
FF_PFNGLUNIFORMMATRIX4FVPROC
void(APIENTRY * FF_PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
Definition: opengl_enc.c:108
FF_PFNGLCREATEPROGRAMPROC
GLuint(APIENTRY * FF_PFNGLCREATEPROGRAMPROC)(void)
Definition: opengl_enc.c:109
opengl_write_header
static av_cold int opengl_write_header(AVFormatContext *h)
Definition: opengl_enc.c:1056
AVCodecParameters::format
int format
Definition: codec_par.h:79
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
message
static int FUNC() message(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessage *current)
Definition: cbs_sei_syntax_template.c:165
FFOpenGLFunctions::glGetShaderiv
FF_PFNGLGETSHADERIVPROC glGetShaderiv
Definition: opengl_enc.c:147
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FF_OPENGL_FRAGMENT_SHADER_YUVA_PLANAR
static const char *const FF_OPENGL_FRAGMENT_SHADER_YUVA_PLANAR
Fragment shader for planar YUVA formats.
Definition: opengl_enc_shaders.h:150
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:468
OpenGLContext::chroma_div_w_location
GLint chroma_div_w_location
Definition: opengl_enc.c:205
FF_PFNGLGENBUFFERSPROC
void(APIENTRY * FF_PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers)
Definition: opengl_enc.c:98
OpenGLContext::projection_matrix
GLfloat projection_matrix[16]
Projection matrix.
Definition: opengl_enc.c:211
FILL_COMPONENT
#define FILL_COMPONENT(i)
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
FFOpenGLFunctions::glVertexAttribPointer
FF_PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer
Definition: opengl_enc.c:131
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:255
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
FFOpenGLFunctions::glEnableVertexAttribArray
FF_PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray
Definition: opengl_enc.c:130
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
OpenGLContext::vertex
OpenGLVertexInfo vertex[4]
VBO.
Definition: opengl_enc.c:201
OpenGLContext::max_texture_size
GLint max_texture_size
Maximum texture size.
Definition: opengl_enc.c:188
OpenGLContext::type
GLenum type
Definition: opengl_enc.c:219
AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER
@ AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER
Destroy window buffer message.
Definition: avdevice.h:257
h
h
Definition: vp9dsp_template.c:2038
FFOpenGLFunctions::glShaderSource
FF_PFNGLSHADERSOURCEPROC glShaderSource
Definition: opengl_enc.c:146
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
transpose
#define transpose(x)
FF_PFNGLGETATTRIBLOCATIONPROC
GLint(APIENTRY * FF_PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const char *name)
Definition: opengl_enc.c:102
OpenGLFormatDesc::fragment_shader
const char *const * fragment_shader
Definition: opengl_enc.c:231
OpenGLContext::window_width
int window_width
Definition: opengl_enc.c:225
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:166
FFOpenGLFunctions
Definition: opengl_enc.c:123
FF_PFNGLDELETEPROGRAMPROC
void(APIENTRY * FF_PFNGLDELETEPROGRAMPROC)(GLuint program)
Definition: opengl_enc.c:110
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2884
OpenGLContext::non_pow_2_textures
int non_pow_2_textures
1 when non power of 2 textures are supported
Definition: opengl_enc.c:191
mux.h
Generated on Thu Apr 18 2024 22:42:17 for FFmpeg by   doxygen 1.8.17