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 
228  int warned;
229 } OpenGLContext;
230 
231 static const struct OpenGLFormatDesc {
232  enum AVPixelFormat fixel_format;
233  const char * const * fragment_shader;
234  GLenum format;
235  GLenum type;
236 } opengl_format_desc[] = {
237  { AV_PIX_FMT_YUV420P, &FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
238  { AV_PIX_FMT_YUV444P, &FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
239  { AV_PIX_FMT_YUV422P, &FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
240  { AV_PIX_FMT_YUV410P, &FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
241  { AV_PIX_FMT_YUV411P, &FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
242  { AV_PIX_FMT_YUV440P, &FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
243  { AV_PIX_FMT_YUV420P16, &FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
244  { AV_PIX_FMT_YUV422P16, &FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
245  { AV_PIX_FMT_YUV444P16, &FF_OPENGL_FRAGMENT_SHADER_YUV_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
246  { AV_PIX_FMT_YUVA420P, &FF_OPENGL_FRAGMENT_SHADER_YUVA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
247  { AV_PIX_FMT_YUVA444P, &FF_OPENGL_FRAGMENT_SHADER_YUVA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
248  { AV_PIX_FMT_YUVA422P, &FF_OPENGL_FRAGMENT_SHADER_YUVA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
249  { AV_PIX_FMT_YUVA420P16, &FF_OPENGL_FRAGMENT_SHADER_YUVA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
250  { AV_PIX_FMT_YUVA422P16, &FF_OPENGL_FRAGMENT_SHADER_YUVA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
251  { AV_PIX_FMT_YUVA444P16, &FF_OPENGL_FRAGMENT_SHADER_YUVA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
252  { AV_PIX_FMT_RGB24, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGB, GL_UNSIGNED_BYTE },
253  { AV_PIX_FMT_BGR24, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGB, GL_UNSIGNED_BYTE },
254  { AV_PIX_FMT_0RGB, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
255  { AV_PIX_FMT_RGB0, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
256  { AV_PIX_FMT_0BGR, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
257  { AV_PIX_FMT_BGR0, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
258  { AV_PIX_FMT_RGB565, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGB, GL_UNSIGNED_SHORT_5_6_5 },
259  { AV_PIX_FMT_BGR565, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGB, GL_UNSIGNED_SHORT_5_6_5 },
260  { AV_PIX_FMT_RGB555, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGBA, FF_GL_UNSIGNED_SHORT_1_5_5_5_REV },
261  { AV_PIX_FMT_BGR555, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGBA, FF_GL_UNSIGNED_SHORT_1_5_5_5_REV },
262  { AV_PIX_FMT_RGB8, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGB, FF_GL_UNSIGNED_BYTE_3_3_2 },
263  { AV_PIX_FMT_BGR8, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGB, FF_GL_UNSIGNED_BYTE_2_3_3_REV },
264  { AV_PIX_FMT_RGB48, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGB, GL_UNSIGNED_SHORT },
265  { AV_PIX_FMT_BGR48, &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET, GL_RGB, GL_UNSIGNED_SHORT },
266  { AV_PIX_FMT_ARGB, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
267  { AV_PIX_FMT_RGBA, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
268  { AV_PIX_FMT_ABGR, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
269  { AV_PIX_FMT_BGRA, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
270  { AV_PIX_FMT_RGBA64, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_SHORT },
271  { AV_PIX_FMT_BGRA64, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_SHORT },
272  { AV_PIX_FMT_GBRP, &FF_OPENGL_FRAGMENT_SHADER_RGB_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
273  { AV_PIX_FMT_GBRP16, &FF_OPENGL_FRAGMENT_SHADER_RGB_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
274  { AV_PIX_FMT_GBRAP, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
275  { AV_PIX_FMT_GBRAP16, &FF_OPENGL_FRAGMENT_SHADER_RGBA_PLANAR, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
276  { AV_PIX_FMT_GRAY8, &FF_OPENGL_FRAGMENT_SHADER_GRAY, FF_GL_RED_COMPONENT, GL_UNSIGNED_BYTE },
277  { AV_PIX_FMT_GRAY16, &FF_OPENGL_FRAGMENT_SHADER_GRAY, FF_GL_RED_COMPONENT, GL_UNSIGNED_SHORT },
278  { AV_PIX_FMT_NONE, NULL }
279 };
280 
281 static av_cold int opengl_prepare_vertex(AVFormatContext *s);
282 static int opengl_draw(AVFormatContext *h, void *intput, int repaint, int is_pkt);
283 static av_cold int opengl_init_context(OpenGLContext *opengl);
284 
285 static av_cold void opengl_deinit_context(OpenGLContext *opengl)
286 {
287  glDeleteTextures(4, opengl->texture_name);
288  opengl->texture_name[0] = opengl->texture_name[1] =
289  opengl->texture_name[2] = opengl->texture_name[3] = 0;
290  if (opengl->glprocs.glUseProgram)
291  opengl->glprocs.glUseProgram(0);
292  if (opengl->glprocs.glDeleteProgram) {
293  opengl->glprocs.glDeleteProgram(opengl->program);
294  opengl->program = 0;
295  }
296  if (opengl->glprocs.glDeleteShader) {
297  opengl->glprocs.glDeleteShader(opengl->vertex_shader);
298  opengl->glprocs.glDeleteShader(opengl->fragment_shader);
299  opengl->vertex_shader = opengl->fragment_shader = 0;
300  }
301  if (opengl->glprocs.glBindBuffer) {
302  opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, 0);
303  opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, 0);
304  }
305  if (opengl->glprocs.glDeleteBuffers) {
306  opengl->glprocs.glDeleteBuffers(2, &opengl->index_buffer);
307  opengl->vertex_buffer = opengl->index_buffer = 0;
308  }
309 }
310 
311 static int opengl_resize(AVFormatContext *h, int width, int height)
312 {
313  int ret = 0;
314  OpenGLContext *opengl = h->priv_data;
315  opengl->window_width = width;
316  opengl->window_height = height;
317  if (opengl->inited) {
318  if (opengl->no_window &&
319  (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0)) < 0) {
320  av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
321  goto end;
322  }
323  if ((ret = opengl_prepare_vertex(h)) < 0)
324  goto end;
325  ret = opengl_draw(h, NULL, 1, 0);
326  }
327  end:
328  return ret;
329 }
330 
331 static int opengl_control_message(AVFormatContext *h, int type, void *data, size_t data_size)
332 {
333  OpenGLContext *opengl = h->priv_data;
334  switch(type) {
335  case AV_APP_TO_DEV_WINDOW_SIZE:
336  if (data) {
337  AVDeviceRect *message = data;
338  return opengl_resize(h, message->width, message->height);
339  }
340  return AVERROR(EINVAL);
341  case AV_APP_TO_DEV_WINDOW_REPAINT:
342  return opengl_resize(h, opengl->window_width, opengl->window_height);
343  }
344  return AVERROR(ENOSYS);
345 }
346 
347 #if CONFIG_SDL2
348 static int opengl_sdl_process_events(AVFormatContext *h)
349 {
350  OpenGLContext *opengl = h->priv_data;
351  AVDeviceRect message;
352  SDL_Event event;
353  SDL_PumpEvents();
354  while (SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) > 0) {
355  switch (event.type) {
356  case SDL_QUIT:
357  return AVERROR(EIO);
358  case SDL_KEYDOWN:
359  switch (event.key.keysym.sym) {
360  case SDLK_ESCAPE:
361  case SDLK_q:
362  return AVERROR(EIO);
363  }
364  return 0;
365  case SDL_WINDOWEVENT:
366  switch(event.window.event) {
367  case SDL_WINDOWEVENT_RESIZED:
368  case SDL_WINDOWEVENT_SIZE_CHANGED:
369  SDL_GL_GetDrawableSize(opengl->window, &message.width, &message.height);
370  return opengl_control_message(h, AV_APP_TO_DEV_WINDOW_SIZE, &message, sizeof(AVDeviceRect));
371  default:
372  break;
373  }
374  }
375  }
376  return 0;
377 }
378 
379 static int av_cold opengl_sdl_create_window(AVFormatContext *h)
380 {
381  OpenGLContext *opengl = h->priv_data;
382  AVDeviceRect message;
383  if (SDL_Init(SDL_INIT_VIDEO)) {
384  av_log(opengl, AV_LOG_ERROR, "Unable to initialize SDL: %s\n", SDL_GetError());
385  return AVERROR_EXTERNAL;
386  }
387  opengl->window = SDL_CreateWindow(opengl->window_title,
388  SDL_WINDOWPOS_UNDEFINED,
389  SDL_WINDOWPOS_UNDEFINED,
390  opengl->window_width, opengl->window_height,
391  SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL);
392  if (!opengl->window) {
393  av_log(opengl, AV_LOG_ERROR, "Unable to create default window: %s\n", SDL_GetError());
394  return AVERROR_EXTERNAL;
395  }
396  opengl->glcontext = SDL_GL_CreateContext(opengl->window);
397  if (!opengl->glcontext) {
398  av_log(opengl, AV_LOG_ERROR, "Unable to create OpenGL context on default window: %s\n", SDL_GetError());
399  return AVERROR_EXTERNAL;
400  }
401  SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
402  SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
403  SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
404  SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
405  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
406  av_log(opengl, AV_LOG_INFO, "SDL driver: '%s'.\n", SDL_GetCurrentVideoDriver());
407  SDL_GL_GetDrawableSize(opengl->window, &message.width, &message.height);
408  return opengl_control_message(h, AV_APP_TO_DEV_WINDOW_SIZE, &message, sizeof(AVDeviceRect));
409 }
410 
411 static int av_cold opengl_sdl_load_procedures(OpenGLContext *opengl)
412 {
413  FFOpenGLFunctions *procs = &opengl->glprocs;
414 
415 #define LOAD_OPENGL_FUN(name, type) \
416  procs->name = (type)SDL_GL_GetProcAddress(#name); \
417  if (!procs->name) { \
418  av_log(opengl, AV_LOG_ERROR, "Cannot load OpenGL function: '%s'\n", #name); \
419  return AVERROR(ENOSYS); \
420  }
421 
422  LOAD_OPENGL_FUN(glActiveTexture, FF_PFNGLACTIVETEXTUREPROC)
423  LOAD_OPENGL_FUN(glGenBuffers, FF_PFNGLGENBUFFERSPROC)
424  LOAD_OPENGL_FUN(glDeleteBuffers, FF_PFNGLDELETEBUFFERSPROC)
425  LOAD_OPENGL_FUN(glBufferData, FF_PFNGLBUFFERDATAPROC)
426  LOAD_OPENGL_FUN(glBindBuffer, FF_PFNGLBINDBUFFERPROC)
427  LOAD_OPENGL_FUN(glGetAttribLocation, FF_PFNGLGETATTRIBLOCATIONPROC)
428  LOAD_OPENGL_FUN(glGetUniformLocation, FF_PFNGLGETUNIFORMLOCATIONPROC)
429  LOAD_OPENGL_FUN(glUniform1f, FF_PFNGLUNIFORM1FPROC)
430  LOAD_OPENGL_FUN(glUniform1i, FF_PFNGLUNIFORM1IPROC)
431  LOAD_OPENGL_FUN(glUniformMatrix4fv, FF_PFNGLUNIFORMMATRIX4FVPROC)
432  LOAD_OPENGL_FUN(glCreateProgram, FF_PFNGLCREATEPROGRAMPROC)
433  LOAD_OPENGL_FUN(glDeleteProgram, FF_PFNGLDELETEPROGRAMPROC)
434  LOAD_OPENGL_FUN(glUseProgram, FF_PFNGLUSEPROGRAMPROC)
435  LOAD_OPENGL_FUN(glLinkProgram, FF_PFNGLLINKPROGRAMPROC)
436  LOAD_OPENGL_FUN(glGetProgramiv, FF_PFNGLGETPROGRAMIVPROC)
437  LOAD_OPENGL_FUN(glGetProgramInfoLog, FF_PFNGLGETPROGRAMINFOLOGPROC)
438  LOAD_OPENGL_FUN(glAttachShader, FF_PFNGLATTACHSHADERPROC)
439  LOAD_OPENGL_FUN(glCreateShader, FF_PFNGLCREATESHADERPROC)
440  LOAD_OPENGL_FUN(glDeleteShader, FF_PFNGLDELETESHADERPROC)
441  LOAD_OPENGL_FUN(glCompileShader, FF_PFNGLCOMPILESHADERPROC)
442  LOAD_OPENGL_FUN(glShaderSource, FF_PFNGLSHADERSOURCEPROC)
443  LOAD_OPENGL_FUN(glGetShaderiv, FF_PFNGLGETSHADERIVPROC)
444  LOAD_OPENGL_FUN(glGetShaderInfoLog, FF_PFNGLGETSHADERINFOLOGPROC)
445  LOAD_OPENGL_FUN(glEnableVertexAttribArray, FF_PFNGLENABLEVERTEXATTRIBARRAYPROC)
446  LOAD_OPENGL_FUN(glVertexAttribPointer, FF_PFNGLVERTEXATTRIBPOINTERPROC)
447 
448  return 0;
449 
450 #undef LOAD_OPENGL_FUN
451 }
452 #endif /* CONFIG_SDL2 */
453 
454 #if defined(__APPLE__)
455 static int av_cold opengl_load_procedures(OpenGLContext *opengl)
456 {
457  FFOpenGLFunctions *procs = &opengl->glprocs;
458 
459 #if CONFIG_SDL2
460  if (!opengl->no_window)
461  return opengl_sdl_load_procedures(opengl);
462 #endif
463 
464  procs->glActiveTexture = glActiveTexture;
465  procs->glGenBuffers = glGenBuffers;
466  procs->glDeleteBuffers = glDeleteBuffers;
467  procs->glBufferData = glBufferData;
468  procs->glBindBuffer = glBindBuffer;
469  procs->glGetAttribLocation = glGetAttribLocation;
470  procs->glGetUniformLocation = glGetUniformLocation;
471  procs->glUniform1f = glUniform1f;
472  procs->glUniform1i = glUniform1i;
473  procs->glUniformMatrix4fv = glUniformMatrix4fv;
474  procs->glCreateProgram = glCreateProgram;
475  procs->glDeleteProgram = glDeleteProgram;
476  procs->glUseProgram = glUseProgram;
477  procs->glLinkProgram = glLinkProgram;
478  procs->glGetProgramiv = glGetProgramiv;
479  procs->glGetProgramInfoLog = glGetProgramInfoLog;
480  procs->glAttachShader = glAttachShader;
481  procs->glCreateShader = glCreateShader;
482  procs->glDeleteShader = glDeleteShader;
483  procs->glCompileShader = glCompileShader;
484  procs->glShaderSource = glShaderSource;
485  procs->glGetShaderiv = glGetShaderiv;
486  procs->glGetShaderInfoLog = glGetShaderInfoLog;
487  procs->glEnableVertexAttribArray = glEnableVertexAttribArray;
488  procs->glVertexAttribPointer = (FF_PFNGLVERTEXATTRIBPOINTERPROC) glVertexAttribPointer;
489  return 0;
490 }
491 #else
492 static int av_cold opengl_load_procedures(OpenGLContext *opengl)
493 {
494  FFOpenGLFunctions *procs = &opengl->glprocs;
495 
496 #if HAVE_GLXGETPROCADDRESS
497 #define SelectedGetProcAddress glXGetProcAddress
498 #elif HAVE_WGLGETPROCADDRESS
499 #define SelectedGetProcAddress wglGetProcAddress
500 #endif
501 
502 #define LOAD_OPENGL_FUN(name, type) \
503  procs->name = (type)SelectedGetProcAddress(#name); \
504  if (!procs->name) { \
505  av_log(opengl, AV_LOG_ERROR, "Cannot load OpenGL function: '%s'\n", #name); \
506  return AVERROR(ENOSYS); \
507  }
508 
509 #if CONFIG_SDL2
510  if (!opengl->no_window)
511  return opengl_sdl_load_procedures(opengl);
512 #endif
513 
514  LOAD_OPENGL_FUN(glActiveTexture, FF_PFNGLACTIVETEXTUREPROC)
515  LOAD_OPENGL_FUN(glGenBuffers, FF_PFNGLGENBUFFERSPROC)
516  LOAD_OPENGL_FUN(glDeleteBuffers, FF_PFNGLDELETEBUFFERSPROC)
517  LOAD_OPENGL_FUN(glBufferData, FF_PFNGLBUFFERDATAPROC)
518  LOAD_OPENGL_FUN(glBindBuffer, FF_PFNGLBINDBUFFERPROC)
519  LOAD_OPENGL_FUN(glGetAttribLocation, FF_PFNGLGETATTRIBLOCATIONPROC)
520  LOAD_OPENGL_FUN(glGetUniformLocation, FF_PFNGLGETUNIFORMLOCATIONPROC)
521  LOAD_OPENGL_FUN(glUniform1f, FF_PFNGLUNIFORM1FPROC)
522  LOAD_OPENGL_FUN(glUniform1i, FF_PFNGLUNIFORM1IPROC)
523  LOAD_OPENGL_FUN(glUniformMatrix4fv, FF_PFNGLUNIFORMMATRIX4FVPROC)
524  LOAD_OPENGL_FUN(glCreateProgram, FF_PFNGLCREATEPROGRAMPROC)
525  LOAD_OPENGL_FUN(glDeleteProgram, FF_PFNGLDELETEPROGRAMPROC)
526  LOAD_OPENGL_FUN(glUseProgram, FF_PFNGLUSEPROGRAMPROC)
527  LOAD_OPENGL_FUN(glLinkProgram, FF_PFNGLLINKPROGRAMPROC)
528  LOAD_OPENGL_FUN(glGetProgramiv, FF_PFNGLGETPROGRAMIVPROC)
529  LOAD_OPENGL_FUN(glGetProgramInfoLog, FF_PFNGLGETPROGRAMINFOLOGPROC)
530  LOAD_OPENGL_FUN(glAttachShader, FF_PFNGLATTACHSHADERPROC)
531  LOAD_OPENGL_FUN(glCreateShader, FF_PFNGLCREATESHADERPROC)
532  LOAD_OPENGL_FUN(glDeleteShader, FF_PFNGLDELETESHADERPROC)
533  LOAD_OPENGL_FUN(glCompileShader, FF_PFNGLCOMPILESHADERPROC)
534  LOAD_OPENGL_FUN(glShaderSource, FF_PFNGLSHADERSOURCEPROC)
535  LOAD_OPENGL_FUN(glGetShaderiv, FF_PFNGLGETSHADERIVPROC)
536  LOAD_OPENGL_FUN(glGetShaderInfoLog, FF_PFNGLGETSHADERINFOLOGPROC)
537  LOAD_OPENGL_FUN(glEnableVertexAttribArray, FF_PFNGLENABLEVERTEXATTRIBARRAYPROC)
538  LOAD_OPENGL_FUN(glVertexAttribPointer, FF_PFNGLVERTEXATTRIBPOINTERPROC)
539 
540  return 0;
541 
542 #undef SelectedGetProcAddress
543 #undef LOAD_OPENGL_FUN
544 }
545 #endif
546 
547 static void opengl_make_identity(float matrix[16])
548 {
549  memset(matrix, 0, 16 * sizeof(float));
550  matrix[0] = matrix[5] = matrix[10] = matrix[15] = 1.0f;
551 }
552 
553 static void opengl_make_ortho(float matrix[16], float left, float right,
554  float bottom, float top, float nearZ, float farZ)
555 {
556  float ral = right + left;
557  float rsl = right - left;
558  float tab = top + bottom;
559  float tsb = top - bottom;
560  float fan = farZ + nearZ;
561  float fsn = farZ - nearZ;
562 
563  memset(matrix, 0, 16 * sizeof(float));
564  matrix[0] = 2.0f / rsl;
565  matrix[5] = 2.0f / tsb;
566  matrix[10] = -2.0f / fsn;
567  matrix[12] = -ral / rsl;
568  matrix[13] = -tab / tsb;
569  matrix[14] = -fan / fsn;
570  matrix[15] = 1.0f;
571 }
572 
573 static av_cold int opengl_read_limits(AVFormatContext *h)
574 {
575  OpenGLContext *opengl = h->priv_data;
576  static const struct{
577  const char *extension;
578  int major;
579  int minor;
580  } required_extensions[] = {
581  { "GL_ARB_multitexture", 1, 3 },
582  { "GL_ARB_vertex_buffer_object", 1, 5 }, //GLX_ARB_vertex_buffer_object
583  { "GL_ARB_vertex_shader", 2, 0 },
584  { "GL_ARB_fragment_shader", 2, 0 },
585  { "GL_ARB_shader_objects", 2, 0 },
586  { NULL, 0, 0 }
587  };
588  int i, major, minor;
589  const char *extensions, *version;
590 
591  version = glGetString(GL_VERSION);
592  extensions = glGetString(GL_EXTENSIONS);
593  if (!version || !extensions) {
594  av_log(h, AV_LOG_ERROR, "No OpenGL context initialized for the current thread\n");
595  return AVERROR(ENOSYS);
596  }
597 
598  av_log(h, AV_LOG_DEBUG, "OpenGL version: %s\n", version);
599  if (sscanf(version, "%d.%d", &major, &minor) != 2)
600  return AVERROR(ENOSYS);
601 
602  for (i = 0; required_extensions[i].extension; i++) {
603  if (major < required_extensions[i].major &&
604  (major == required_extensions[i].major && minor < required_extensions[i].minor) &&
605  !strstr(extensions, required_extensions[i].extension)) {
606  av_log(h, AV_LOG_ERROR, "Required extension %s is not supported.\n",
607  required_extensions[i].extension);
608  av_log(h, AV_LOG_DEBUG, "Supported extensions are: %s\n", extensions);
609  return AVERROR(ENOSYS);
610  }
611  }
612  glGetIntegerv(GL_MAX_TEXTURE_SIZE, &opengl->max_texture_size);
613  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, &opengl->max_viewport_width);
614  opengl->non_pow_2_textures = major >= 2 || strstr(extensions, "GL_ARB_texture_non_power_of_two");
615 #if defined(GL_ES_VERSION_2_0)
616  opengl->unpack_subimage = !!strstr(extensions, "GL_EXT_unpack_subimage");
617 #else
618  opengl->unpack_subimage = 1;
619 #endif
620 
621  av_log(h, AV_LOG_DEBUG, "Non Power of 2 textures support: %s\n", opengl->non_pow_2_textures ? "Yes" : "No");
622  av_log(h, AV_LOG_DEBUG, "Unpack Subimage extension support: %s\n", opengl->unpack_subimage ? "Yes" : "No");
623  av_log(h, AV_LOG_DEBUG, "Max texture size: %dx%d\n", opengl->max_texture_size, opengl->max_texture_size);
624  av_log(h, AV_LOG_DEBUG, "Max viewport size: %dx%d\n",
625  opengl->max_viewport_width, opengl->max_viewport_height);
626 
627  OPENGL_ERROR_CHECK(opengl);
628  return 0;
629  fail:
630  return AVERROR_EXTERNAL;
631 }
632 
633 static const char* opengl_get_fragment_shader_code(enum AVPixelFormat format)
634 {
635  int i;
636  for (i = 0; i < FF_ARRAY_ELEMS(opengl_format_desc); i++) {
637  if (opengl_format_desc[i].fixel_format == format)
638  return *opengl_format_desc[i].fragment_shader;
639  }
640  return NULL;
641 }
642 
643 static int opengl_type_size(GLenum type)
644 {
645  switch(type) {
646  case GL_UNSIGNED_SHORT:
647  case FF_GL_UNSIGNED_SHORT_1_5_5_5_REV:
648  case GL_UNSIGNED_SHORT_5_6_5:
649  return 2;
650  case GL_UNSIGNED_BYTE:
651  case FF_GL_UNSIGNED_BYTE_3_3_2:
652  case FF_GL_UNSIGNED_BYTE_2_3_3_REV:
653  default:
654  break;
655  }
656  return 1;
657 }
658 
659 static av_cold void opengl_get_texture_params(OpenGLContext *opengl)
660 {
661  int i;
662  for (i = 0; i < FF_ARRAY_ELEMS(opengl_format_desc); i++) {
663  if (opengl_format_desc[i].fixel_format == opengl->pix_fmt) {
664  opengl->format = opengl_format_desc[i].format;
665  opengl->type = opengl_format_desc[i].type;
666  break;
667  }
668  }
669 }
670 
671 static void opengl_compute_display_area(AVFormatContext *s)
672 {
673  AVRational sar, dar; /* sample and display aspect ratios */
674  OpenGLContext *opengl = s->priv_data;
675  AVStream *st = s->streams[0];
676  AVCodecParameters *par = st->codecpar;
677 
678  /* compute overlay width and height from the codec context information */
679  sar = st->sample_aspect_ratio.num ? st->sample_aspect_ratio : (AVRational){ 1, 1 };
680  dar = av_mul_q(sar, (AVRational){ par->width, par->height });
681 
682  /* we suppose the screen has a 1/1 sample aspect ratio */
683  /* fit in the window */
684  if (av_cmp_q(dar, (AVRational){ opengl->window_width, opengl->window_height }) > 0) {
685  /* fit in width */
686  opengl->picture_width = opengl->window_width;
687  opengl->picture_height = av_rescale(opengl->picture_width, dar.den, dar.num);
688  } else {
689  /* fit in height */
690  opengl->picture_height = opengl->window_height;
691  opengl->picture_width = av_rescale(opengl->picture_height, dar.num, dar.den);
692  }
693 }
694 
695 static av_cold void opengl_get_texture_size(OpenGLContext *opengl, int in_width, int in_height,
696  int *out_width, int *out_height)
697 {
698  if (opengl->non_pow_2_textures) {
699  *out_width = in_width;
700  *out_height = in_height;
701  } else {
702  int max = FFMIN(FFMAX(in_width, in_height), opengl->max_texture_size);
703  unsigned power_of_2 = 1;
704  while (power_of_2 < max)
705  power_of_2 *= 2;
706  *out_height = power_of_2;
707  *out_width = power_of_2;
708  av_log(opengl, AV_LOG_DEBUG, "Texture size calculated from %dx%d into %dx%d\n",
709  in_width, in_height, *out_width, *out_height);
710  }
711 }
712 
713 static av_cold void opengl_fill_color_map(OpenGLContext *opengl)
714 {
715  const AVPixFmtDescriptor *desc;
716  int shift;
717  enum AVPixelFormat pix_fmt = opengl->pix_fmt;
718 
719  /* We need order of components, not exact position, some minor HACKs here */
720  if (pix_fmt == AV_PIX_FMT_RGB565 || pix_fmt == AV_PIX_FMT_BGR555 ||
721  pix_fmt == AV_PIX_FMT_BGR8 || pix_fmt == AV_PIX_FMT_RGB8)
722  pix_fmt = AV_PIX_FMT_RGB24;
723  else if (pix_fmt == AV_PIX_FMT_BGR565 || pix_fmt == AV_PIX_FMT_RGB555)
724  pix_fmt = AV_PIX_FMT_BGR24;
725 
726  desc = av_pix_fmt_desc_get(pix_fmt);
727  if (!(desc->flags & AV_PIX_FMT_FLAG_RGB))
728  return;
729 
730 #define FILL_COMPONENT(i) { \
731  shift = (desc->comp[i].depth - 1) >> 3; \
732  opengl->color_map[(i << 2) + (desc->comp[i].offset >> shift)] = 1.0; \
733  }
734 
735  memset(opengl->color_map, 0, sizeof(opengl->color_map));
736  FILL_COMPONENT(0);
737  FILL_COMPONENT(1);
738  FILL_COMPONENT(2);
739  if (desc->flags & AV_PIX_FMT_FLAG_ALPHA)
740  FILL_COMPONENT(3);
741 
742 #undef FILL_COMPONENT
743 }
744 
745 static av_cold GLuint opengl_load_shader(OpenGLContext *opengl, GLenum type, const char *source)
746 {
747  GLuint shader = opengl->glprocs.glCreateShader(type);
748  GLint result;
749  if (!shader) {
750  av_log(opengl, AV_LOG_ERROR, "glCreateShader() failed\n");
751  return 0;
752  }
753  opengl->glprocs.glShaderSource(shader, 1, &source, NULL);
754  opengl->glprocs.glCompileShader(shader);
755 
756  opengl->glprocs.glGetShaderiv(shader, FF_GL_COMPILE_STATUS, &result);
757  if (!result) {
758  char *log;
759  opengl->glprocs.glGetShaderiv(shader, FF_GL_INFO_LOG_LENGTH, &result);
760  if (result) {
761  if ((log = av_malloc(result))) {
762  opengl->glprocs.glGetShaderInfoLog(shader, result, NULL, log);
763  av_log(opengl, AV_LOG_ERROR, "Compile error: %s\n", log);
764  av_free(log);
765  }
766  }
767  goto fail;
768  }
769  OPENGL_ERROR_CHECK(opengl);
770  return shader;
771  fail:
772  opengl->glprocs.glDeleteShader(shader);
773  return 0;
774 }
775 
776 static av_cold int opengl_compile_shaders(OpenGLContext *opengl, enum AVPixelFormat pix_fmt)
777 {
778  GLint result;
779  const char *fragment_shader_code = opengl_get_fragment_shader_code(pix_fmt);
780 
781  if (!fragment_shader_code) {
782  av_log(opengl, AV_LOG_ERROR, "Provided pixel format '%s' is not supported\n",
783  av_get_pix_fmt_name(pix_fmt));
784  return AVERROR(EINVAL);
785  }
786 
787  opengl->vertex_shader = opengl_load_shader(opengl, FF_GL_VERTEX_SHADER,
788  FF_OPENGL_VERTEX_SHADER);
789  if (!opengl->vertex_shader) {
790  av_log(opengl, AV_LOG_ERROR, "Vertex shader loading failed.\n");
791  goto fail;
792  }
793  opengl->fragment_shader = opengl_load_shader(opengl, FF_GL_FRAGMENT_SHADER,
794  fragment_shader_code);
795  if (!opengl->fragment_shader) {
796  av_log(opengl, AV_LOG_ERROR, "Fragment shader loading failed.\n");
797  goto fail;
798  }
799 
800  opengl->program = opengl->glprocs.glCreateProgram();
801  if (!opengl->program)
802  goto fail;
803 
804  opengl->glprocs.glAttachShader(opengl->program, opengl->vertex_shader);
805  opengl->glprocs.glAttachShader(opengl->program, opengl->fragment_shader);
806  opengl->glprocs.glLinkProgram(opengl->program);
807 
808  opengl->glprocs.glGetProgramiv(opengl->program, FF_GL_LINK_STATUS, &result);
809  if (!result) {
810  char *log;
811  opengl->glprocs.glGetProgramiv(opengl->program, FF_GL_INFO_LOG_LENGTH, &result);
812  if (result) {
813  log = av_malloc(result);
814  if (!log)
815  goto fail;
816  opengl->glprocs.glGetProgramInfoLog(opengl->program, result, NULL, log);
817  av_log(opengl, AV_LOG_ERROR, "Link error: %s\n", log);
818  av_free(log);
819  }
820  goto fail;
821  }
822 
823  opengl->position_attrib = opengl->glprocs.glGetAttribLocation(opengl->program, "a_position");
824  opengl->texture_coords_attrib = opengl->glprocs.glGetAttribLocation(opengl->program, "a_textureCoords");
825  opengl->projection_matrix_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_projectionMatrix");
826  opengl->model_view_matrix_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_modelViewMatrix");
827  opengl->color_map_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_colorMap");
828  opengl->texture_location[0] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture0");
829  opengl->texture_location[1] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture1");
830  opengl->texture_location[2] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture2");
831  opengl->texture_location[3] = opengl->glprocs.glGetUniformLocation(opengl->program, "u_texture3");
832  opengl->chroma_div_w_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_chroma_div_w");
833  opengl->chroma_div_h_location = opengl->glprocs.glGetUniformLocation(opengl->program, "u_chroma_div_h");
834 
835  OPENGL_ERROR_CHECK(opengl);
836  return 0;
837  fail:
838  opengl->glprocs.glDeleteShader(opengl->vertex_shader);
839  opengl->glprocs.glDeleteShader(opengl->fragment_shader);
840  opengl->glprocs.glDeleteProgram(opengl->program);
841  opengl->fragment_shader = opengl->vertex_shader = opengl->program = 0;
842  return AVERROR_EXTERNAL;
843 }
844 
845 static av_cold int opengl_configure_texture(OpenGLContext *opengl, GLuint texture,
846  GLsizei width, GLsizei height)
847 {
848  if (texture) {
849  int new_width, new_height;
850  opengl_get_texture_size(opengl, width, height, &new_width, &new_height);
851  glBindTexture(GL_TEXTURE_2D, texture);
852  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
853  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
854  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
855  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
856  glTexImage2D(GL_TEXTURE_2D, 0, opengl->format, new_width, new_height, 0,
857  opengl->format, opengl->type, NULL);
858  OPENGL_ERROR_CHECK(NULL);
859  }
860  return 0;
861  fail:
862  return AVERROR_EXTERNAL;
863 }
864 
865 static av_cold int opengl_prepare_vertex(AVFormatContext *s)
866 {
867  OpenGLContext *opengl = s->priv_data;
868  int tex_w, tex_h;
869 
870  if (opengl->window_width > opengl->max_viewport_width || opengl->window_height > opengl->max_viewport_height) {
871  opengl->window_width = FFMIN(opengl->window_width, opengl->max_viewport_width);
872  opengl->window_height = FFMIN(opengl->window_height, opengl->max_viewport_height);
873  av_log(opengl, AV_LOG_WARNING, "Too big viewport requested, limited to %dx%d", opengl->window_width, opengl->window_height);
874  }
875  glViewport(0, 0, opengl->window_width, opengl->window_height);
876  opengl_make_ortho(opengl->projection_matrix,
877  - (float)opengl->window_width / 2.0f, (float)opengl->window_width / 2.0f,
878  - (float)opengl->window_height / 2.0f, (float)opengl->window_height / 2.0f,
879  1.0f, -1.0f);
880  opengl_make_identity(opengl->model_view_matrix);
881 
882  opengl_compute_display_area(s);
883 
884  opengl->vertex[0].z = opengl->vertex[1].z = opengl->vertex[2].z = opengl->vertex[3].z = 0.0f;
885  opengl->vertex[0].x = opengl->vertex[1].x = - (float)opengl->picture_width / 2.0f;
886  opengl->vertex[2].x = opengl->vertex[3].x = (float)opengl->picture_width / 2.0f;
887  opengl->vertex[1].y = opengl->vertex[2].y = - (float)opengl->picture_height / 2.0f;
888  opengl->vertex[0].y = opengl->vertex[3].y = (float)opengl->picture_height / 2.0f;
889 
890  opengl_get_texture_size(opengl, opengl->width, opengl->height, &tex_w, &tex_h);
891 
892  opengl->vertex[0].s0 = 0.0f;
893  opengl->vertex[0].t0 = 0.0f;
894  opengl->vertex[1].s0 = 0.0f;
895  opengl->vertex[1].t0 = (float)opengl->height / (float)tex_h;
896  opengl->vertex[2].s0 = (float)opengl->width / (float)tex_w;
897  opengl->vertex[2].t0 = (float)opengl->height / (float)tex_h;
898  opengl->vertex[3].s0 = (float)opengl->width / (float)tex_w;
899  opengl->vertex[3].t0 = 0.0f;
900 
901  opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, opengl->vertex_buffer);
902  opengl->glprocs.glBufferData(FF_GL_ARRAY_BUFFER, sizeof(opengl->vertex), opengl->vertex, FF_GL_STATIC_DRAW);
903  opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, 0);
904  OPENGL_ERROR_CHECK(opengl);
905  return 0;
906  fail:
907  return AVERROR_EXTERNAL;
908 }
909 
910 static int opengl_prepare(OpenGLContext *opengl)
911 {
912  int i;
913  opengl->glprocs.glUseProgram(opengl->program);
914  opengl->glprocs.glUniformMatrix4fv(opengl->projection_matrix_location, 1, GL_FALSE, opengl->projection_matrix);
915  opengl->glprocs.glUniformMatrix4fv(opengl->model_view_matrix_location, 1, GL_FALSE, opengl->model_view_matrix);
916  for (i = 0; i < 4; i++)
917  if (opengl->texture_location[i] != -1) {
918  opengl->glprocs.glActiveTexture(GL_TEXTURE0 + i);
919  glBindTexture(GL_TEXTURE_2D, opengl->texture_name[i]);
920  opengl->glprocs.glUniform1i(opengl->texture_location[i], i);
921  }
922  if (opengl->color_map_location != -1)
923  opengl->glprocs.glUniformMatrix4fv(opengl->color_map_location, 1, GL_FALSE, opengl->color_map);
924  if (opengl->chroma_div_h_location != -1)
925  opengl->glprocs.glUniform1f(opengl->chroma_div_h_location, opengl->chroma_div_h);
926  if (opengl->chroma_div_w_location != -1)
927  opengl->glprocs.glUniform1f(opengl->chroma_div_w_location, opengl->chroma_div_w);
928 
929  OPENGL_ERROR_CHECK(opengl);
930  return 0;
931  fail:
932  return AVERROR_EXTERNAL;
933 }
934 
935 static int opengl_create_window(AVFormatContext *h)
936 {
937  OpenGLContext *opengl = h->priv_data;
938  int ret;
939 
940  if (!opengl->no_window) {
941 #if CONFIG_SDL2
942  if ((ret = opengl_sdl_create_window(h)) < 0) {
943  av_log(opengl, AV_LOG_ERROR, "Cannot create default SDL window.\n");
944  return ret;
945  }
946 #else
947  av_log(opengl, AV_LOG_ERROR, "FFmpeg is compiled without SDL. Cannot create default window.\n");
948  return AVERROR(ENOSYS);
949 #endif
950  } else {
951  AVDeviceRect message;
952  message.x = message.y = 0;
953  message.width = opengl->window_width;
954  message.height = opengl->window_height;
955  if ((ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_CREATE_WINDOW_BUFFER,
956  &message , sizeof(message))) < 0) {
957  av_log(opengl, AV_LOG_ERROR, "Application failed to create window buffer.\n");
958  return ret;
959  }
960  if ((ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0)) < 0) {
961  av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
962  return ret;
963  }
964  }
965  return 0;
966 }
967 
968 static int opengl_release_window(AVFormatContext *h)
969 {
970  int ret;
971  OpenGLContext *opengl = h->priv_data;
972  if (!opengl->no_window) {
973 #if CONFIG_SDL2
974  SDL_GL_DeleteContext(opengl->glcontext);
975  SDL_DestroyWindow(opengl->window);
976  SDL_Quit();
977 #endif
978  } else if ((ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER, NULL , 0)) < 0) {
979  av_log(opengl, AV_LOG_ERROR, "Application failed to release window buffer.\n");
980  return ret;
981  }
982  return 0;
983 }
984 
985 static av_cold int opengl_write_trailer(AVFormatContext *h)
986 {
987  OpenGLContext *opengl = h->priv_data;
988 
989  if (opengl->no_window &&
990  avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0) < 0)
991  av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
992 
993  opengl_deinit_context(opengl);
994  opengl_release_window(h);
995 
996  return 0;
997 }
998 
999 static av_cold int opengl_init_context(OpenGLContext *opengl)
1000 {
1001  int i, ret;
1002  const AVPixFmtDescriptor *desc;
1003 
1004  if ((ret = opengl_compile_shaders(opengl, opengl->pix_fmt)) < 0)
1005  goto fail;
1006 
1007  desc = av_pix_fmt_desc_get(opengl->pix_fmt);
1008  av_assert0(desc->nb_components > 0 && desc->nb_components <= 4);
1009  glGenTextures(desc->nb_components, opengl->texture_name);
1010 
1011  opengl->glprocs.glGenBuffers(2, &opengl->index_buffer);
1012  if (!opengl->index_buffer || !opengl->vertex_buffer) {
1013  av_log(opengl, AV_LOG_ERROR, "Buffer generation failed.\n");
1014  ret = AVERROR_EXTERNAL;
1015  goto fail;
1016  }
1017 
1018  opengl_configure_texture(opengl, opengl->texture_name[0], opengl->width, opengl->height);
1019  if (desc->nb_components > 1) {
1020  int has_alpha = desc->flags & AV_PIX_FMT_FLAG_ALPHA;
1021  int num_planes = desc->nb_components - (has_alpha ? 1 : 0);
1022  if (opengl->non_pow_2_textures) {
1023  opengl->chroma_div_w = 1.0f;
1024  opengl->chroma_div_h = 1.0f;
1025  } else {
1026  opengl->chroma_div_w = 1 << desc->log2_chroma_w;
1027  opengl->chroma_div_h = 1 << desc->log2_chroma_h;
1028  }
1029  for (i = 1; i < num_planes; i++)
1030  if (opengl->non_pow_2_textures)
1031  opengl_configure_texture(opengl, opengl->texture_name[i],
1032  AV_CEIL_RSHIFT(opengl->width, desc->log2_chroma_w),
1033  AV_CEIL_RSHIFT(opengl->height, desc->log2_chroma_h));
1034  else
1035  opengl_configure_texture(opengl, opengl->texture_name[i], opengl->width, opengl->height);
1036  if (has_alpha)
1037  opengl_configure_texture(opengl, opengl->texture_name[3], opengl->width, opengl->height);
1038  }
1039 
1040  opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, opengl->index_buffer);
1041  opengl->glprocs.glBufferData(FF_GL_ELEMENT_ARRAY_BUFFER, sizeof(g_index), g_index, FF_GL_STATIC_DRAW);
1042  opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, 0);
1043 
1044  glEnable(GL_BLEND);
1045  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1046 
1047  glClearColor((float)opengl->background[0] / 255.0f, (float)opengl->background[1] / 255.0f,
1048  (float)opengl->background[2] / 255.0f, 1.0f);
1049 
1050  ret = AVERROR_EXTERNAL;
1051  OPENGL_ERROR_CHECK(opengl);
1052 
1053  return 0;
1054  fail:
1055  return ret;
1056 }
1057 
1058 static av_cold int opengl_write_header(AVFormatContext *h)
1059 {
1060  OpenGLContext *opengl = h->priv_data;
1061  AVCodecParameters *par = h->streams[0]->codecpar;
1062  AVStream *st;
1063  int ret;
1064 
1065  if (!opengl->warned) {
1066  av_log(opengl, AV_LOG_WARNING,
1067  "The opengl output device is deprecated due to being fundamentally incompatible with libavformat API. "
1068  "For monitoring purposes in ffmpeg you can output to a file or use pipes and a video player.\n"
1069  "Example: ffmpeg -i INPUT -f nut -c:v rawvideo - | ffplay -\n"
1070  );
1071  opengl->warned = 1;
1072  }
1073 
1074  if (h->nb_streams != 1 ||
1075  par->codec_type != AVMEDIA_TYPE_VIDEO ||
1076  (par->codec_id != AV_CODEC_ID_WRAPPED_AVFRAME && par->codec_id != AV_CODEC_ID_RAWVIDEO)) {
1077  av_log(opengl, AV_LOG_ERROR, "Only a single raw or wrapped avframe video stream is supported.\n");
1078  return AVERROR(EINVAL);
1079  }
1080  st = h->streams[0];
1081  opengl->width = st->codecpar->width;
1082  opengl->height = st->codecpar->height;
1083  opengl->pix_fmt = st->codecpar->format;
1084  if (!opengl->window_width)
1085  opengl->window_width = opengl->width;
1086  if (!opengl->window_height)
1087  opengl->window_height = opengl->height;
1088 
1089  if (!opengl->window_title && !opengl->no_window)
1090  opengl->window_title = av_strdup(h->url);
1091 
1092  if ((ret = opengl_create_window(h)))
1093  goto fail;
1094 
1095  if ((ret = opengl_read_limits(h)) < 0)
1096  goto fail;
1097 
1098  if (opengl->width > opengl->max_texture_size || opengl->height > opengl->max_texture_size) {
1099  av_log(opengl, AV_LOG_ERROR, "Too big picture %dx%d, max supported size is %dx%d\n",
1100  opengl->width, opengl->height, opengl->max_texture_size, opengl->max_texture_size);
1101  ret = AVERROR(EINVAL);
1102  goto fail;
1103  }
1104 
1105  if ((ret = opengl_load_procedures(opengl)) < 0)
1106  goto fail;
1107 
1108  opengl_fill_color_map(opengl);
1109  opengl_get_texture_params(opengl);
1110 
1111  if ((ret = opengl_init_context(opengl)) < 0)
1112  goto fail;
1113 
1114  if ((ret = opengl_prepare_vertex(h)) < 0)
1115  goto fail;
1116 
1117  glClear(GL_COLOR_BUFFER_BIT);
1118 
1119 #if CONFIG_SDL2
1120  if (!opengl->no_window)
1121  SDL_GL_SwapWindow(opengl->window);
1122 #endif
1123  if (opengl->no_window &&
1124  (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER, NULL , 0)) < 0) {
1125  av_log(opengl, AV_LOG_ERROR, "Application failed to display window buffer.\n");
1126  goto fail;
1127  }
1128 
1129  ret = AVERROR_EXTERNAL;
1130  OPENGL_ERROR_CHECK(opengl);
1131 
1132  opengl->inited = 1;
1133  return 0;
1134 
1135  fail:
1136  opengl_write_trailer(h);
1137  return ret;
1138 }
1139 
1140 static uint8_t* opengl_get_plane_pointer(OpenGLContext *opengl, AVPacket *pkt, int comp_index,
1141  const AVPixFmtDescriptor *desc)
1142 {
1143  uint8_t *data = pkt->data;
1144  int wordsize = opengl_type_size(opengl->type);
1145  int width_chroma = AV_CEIL_RSHIFT(opengl->width, desc->log2_chroma_w);
1146  int height_chroma = AV_CEIL_RSHIFT(opengl->height, desc->log2_chroma_h);
1147  int plane = desc->comp[comp_index].plane;
1148 
1149  switch(plane) {
1150  case 0:
1151  break;
1152  case 1:
1153  data += opengl->width * opengl->height * wordsize;
1154  break;
1155  case 2:
1156  data += opengl->width * opengl->height * wordsize;
1157  data += width_chroma * height_chroma * wordsize;
1158  break;
1159  case 3:
1160  data += opengl->width * opengl->height * wordsize;
1161  data += 2 * width_chroma * height_chroma * wordsize;
1162  break;
1163  default:
1164  return NULL;
1165  }
1166  return data;
1167 }
1168 
1169 #define LOAD_TEXTURE_DATA(comp_index, sub) \
1170 { \
1171  int width = sub ? AV_CEIL_RSHIFT(opengl->width, desc->log2_chroma_w) : opengl->width; \
1172  int height = sub ? AV_CEIL_RSHIFT(opengl->height, desc->log2_chroma_h): opengl->height; \
1173  uint8_t *data; \
1174  int plane = desc->comp[comp_index].plane; \
1175  \
1176  glBindTexture(GL_TEXTURE_2D, opengl->texture_name[comp_index]); \
1177  if (!is_pkt) { \
1178  GLint length = ((AVFrame *)input)->linesize[plane]; \
1179  int bytes_per_pixel = opengl_type_size(opengl->type); \
1180  if (!(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) \
1181  bytes_per_pixel *= desc->nb_components; \
1182  data = ((AVFrame *)input)->data[plane]; \
1183  if (!(length % bytes_per_pixel) && \
1184  (opengl->unpack_subimage || ((length / bytes_per_pixel) == width))) { \
1185  length /= bytes_per_pixel; \
1186  if (length != width) \
1187  glPixelStorei(FF_GL_UNPACK_ROW_LENGTH, length); \
1188  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, \
1189  opengl->format, opengl->type, data); \
1190  if (length != width) \
1191  glPixelStorei(FF_GL_UNPACK_ROW_LENGTH, 0); \
1192  } else { \
1193  int h; \
1194  for (h = 0; h < height; h++) { \
1195  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, h, width, 1, \
1196  opengl->format, opengl->type, data); \
1197  data += length; \
1198  } \
1199  } \
1200  } else { \
1201  data = opengl_get_plane_pointer(opengl, input, comp_index, desc); \
1202  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, \
1203  opengl->format, opengl->type, data); \
1204  } \
1205 }
1206 
1207 static int opengl_draw(AVFormatContext *h, void *input, int repaint, int is_pkt)
1208 {
1209  OpenGLContext *opengl = h->priv_data;
1210  enum AVPixelFormat pix_fmt = h->streams[0]->codecpar->format;
1211  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
1212  int ret;
1213 
1214 #if CONFIG_SDL2
1215  /* At this point, opengl->glcontext implies opengl->glcontext */
1216  if (opengl->glcontext)
1217  SDL_GL_MakeCurrent(opengl->window, opengl->glcontext);
1218 
1219  if (!opengl->no_window && (ret = opengl_sdl_process_events(h)) < 0)
1220  goto fail;
1221 #endif
1222  if (opengl->no_window &&
1223  (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER, NULL , 0)) < 0) {
1224  av_log(opengl, AV_LOG_ERROR, "Application failed to prepare window buffer.\n");
1225  goto fail;
1226  }
1227 
1228  glClear(GL_COLOR_BUFFER_BIT);
1229 
1230  if (!repaint) {
1231  if (is_pkt)
1232  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1233  LOAD_TEXTURE_DATA(0, 0)
1234  if (desc->flags & AV_PIX_FMT_FLAG_PLANAR) {
1235  LOAD_TEXTURE_DATA(1, 1)
1236  LOAD_TEXTURE_DATA(2, 1)
1237  if (desc->flags & AV_PIX_FMT_FLAG_ALPHA)
1238  LOAD_TEXTURE_DATA(3, 0)
1239  }
1240  }
1241  ret = AVERROR_EXTERNAL;
1242  OPENGL_ERROR_CHECK(opengl);
1243 
1244  if ((ret = opengl_prepare(opengl)) < 0)
1245  goto fail;
1246 
1247  opengl->glprocs.glBindBuffer(FF_GL_ARRAY_BUFFER, opengl->vertex_buffer);
1248  opengl->glprocs.glBindBuffer(FF_GL_ELEMENT_ARRAY_BUFFER, opengl->index_buffer);
1249  opengl->glprocs.glVertexAttribPointer(opengl->position_attrib, 3, GL_FLOAT, GL_FALSE, sizeof(OpenGLVertexInfo), 0);
1250  opengl->glprocs.glEnableVertexAttribArray(opengl->position_attrib);
1251  opengl->glprocs.glVertexAttribPointer(opengl->texture_coords_attrib, 2, GL_FLOAT, GL_FALSE, sizeof(OpenGLVertexInfo), 12);
1252  opengl->glprocs.glEnableVertexAttribArray(opengl->texture_coords_attrib);
1253 
1254  glDrawElements(GL_TRIANGLES, FF_ARRAY_ELEMS(g_index), GL_UNSIGNED_SHORT, 0);
1255 
1256  ret = AVERROR_EXTERNAL;
1257  OPENGL_ERROR_CHECK(opengl);
1258 
1259 #if CONFIG_SDL2
1260  if (!opengl->no_window)
1261  SDL_GL_SwapWindow(opengl->window);
1262 #endif
1263  if (opengl->no_window &&
1264  (ret = avdevice_dev_to_app_control_message(h, AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER, NULL , 0)) < 0) {
1265  av_log(opengl, AV_LOG_ERROR, "Application failed to display window buffer.\n");
1266  goto fail;
1267  }
1268 
1269  return 0;
1270  fail:
1271  return ret;
1272 }
1273 
1274 static int opengl_write_packet(AVFormatContext *h, AVPacket *pkt)
1275 {
1276  AVCodecParameters *par = h->streams[0]->codecpar;
1277  if (par->codec_id == AV_CODEC_ID_WRAPPED_AVFRAME) {
1278  AVFrame *frame = (AVFrame *)pkt->data;
1279  return opengl_draw(h, frame, 0, 0);
1280  } else {
1281  return opengl_draw(h, pkt, 0, 1);
1282  }
1283 }
1284 
1285 static int opengl_write_frame(AVFormatContext *h, int stream_index,
1286  AVFrame **frame, unsigned flags)
1287 {
1288  if ((flags & AV_WRITE_UNCODED_FRAME_QUERY))
1289  return 0;
1290  return opengl_draw(h, *frame, 0, 0);
1291 }
1292 
1293 #define OFFSET(x) offsetof(OpenGLContext, x)
1294 #define ENC AV_OPT_FLAG_ENCODING_PARAM
1295 static const AVOption options[] = {
1296  { "background", "set background color", OFFSET(background), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, ENC },
1297  { "no_window", "disable default window", OFFSET(no_window), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, ENC },
1298  { "window_title", "set window title", OFFSET(window_title), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, ENC },
1299  { "window_size", "set window size", OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, ENC },
1300  { NULL }
1301 };
1302 
1303 static const AVClass opengl_class = {
1304  .class_name = "opengl outdev",
1305  .item_name = av_default_item_name,
1306  .option = options,
1307  .version = LIBAVUTIL_VERSION_INT,
1308  .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT,
1309 };
1310 
1311 const FFOutputFormat ff_opengl_muxer = {
1312  .p.name = "opengl",
1313  .p.long_name = NULL_IF_CONFIG_SMALL("OpenGL output"),
1314  .p.audio_codec = AV_CODEC_ID_NONE,
1315  .p.video_codec = AV_CODEC_ID_WRAPPED_AVFRAME,
1316  .p.flags = AVFMT_NOFILE | AVFMT_VARIABLE_FPS | AVFMT_NOTIMESTAMPS,
1317  .p.priv_class = &opengl_class,
1318  .priv_data_size = sizeof(OpenGLContext),
1319  .write_header = opengl_write_header,
1320  .write_packet = opengl_write_packet,
1321  .write_uncoded_frame = opengl_write_frame,
1322  .write_trailer = opengl_write_trailer,
1323  .control_message = opengl_control_message,
1324 };
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:522
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:501
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:71
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:1295
AVOutputFormat::name
const char * name
Definition: avformat.h:510
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:1311
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:2962
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:482
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:479
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:999
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:344
pixdesc.h
opengl_control_message
static int opengl_control_message(AVFormatContext *h, int type, void *data, size_t data_size)
Definition: opengl_enc.c:331
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:521
OpenGLFormatDesc::type
GLenum type
Definition: opengl_enc.c:235
opengl_get_fragment_shader_code
static const char * opengl_get_fragment_shader_code(enum AVPixelFormat format)
Definition: opengl_enc.c:633
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:346
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:33
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:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
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:106
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:745
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:65
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:364
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
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:179
FFOpenGLFunctions::glCreateProgram
FF_PFNGLCREATEPROGRAMPROC glCreateProgram
Definition: opengl_enc.c:136
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:523
opengl_compute_display_area
static void opengl_compute_display_area(AVFormatContext *s)
Definition: opengl_enc.c:671
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:232
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:462
opengl_write_frame
static int opengl_write_frame(AVFormatContext *h, int stream_index, AVFrame **frame, unsigned flags)
Definition: opengl_enc.c:1285
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:845
OFFSET
#define OFFSET(x)
Definition: opengl_enc.c:1293
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:90
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:910
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:695
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:490
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:553
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:108
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:231
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:491
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
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:134
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:1274
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:489
opengl_make_identity
static void opengl_make_identity(float matrix[16])
Definition: opengl_enc.c:547
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:73
AV_CODEC_ID_WRAPPED_AVFRAME
@ AV_CODEC_ID_WRAPPED_AVFRAME
Passthrough codec, AVFrames wrapped in AVPacket.
Definition: codec_id.h:600
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
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:310
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
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:497
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
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:468
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:469
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:1294
opengl_read_limits
static av_cold int opengl_read_limits(AVFormatContext *h)
Definition: opengl_enc.c:573
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
OpenGLContext::warned
int warned
Definition: opengl_enc.c:228
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:250
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:245
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:61
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)3R 3G 2B(lsb)
Definition: pixfmt.h:93
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:265
opengl_fill_color_map
static av_cold void opengl_fill_color_map(OpenGLContext *opengl)
Definition: opengl_enc.c:713
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:81
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
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:776
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:285
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:75
opengl_prepare_vertex
static av_cold int opengl_prepare_vertex(AVFormatContext *s)
Definition: opengl_enc.c:865
opengl_load_procedures
static int av_cold opengl_load_procedures(OpenGLContext *opengl)
Definition: opengl_enc.c:492
opengl_draw
static int opengl_draw(AVFormatContext *h, void *intput, int repaint, int is_pkt)
Definition: opengl_enc.c:1207
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:464
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:471
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:1140
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
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:821
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:174
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:263
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:99
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:968
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:473
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:935
OpenGLContext::background
uint8_t background[4]
Background color.
Definition: opengl_enc.c:183
AVCodecParameters::height
int height
Definition: codec_par.h:135
opengl_class
static const AVClass opengl_class
Definition: opengl_enc.c:1303
opengl_get_texture_params
static av_cold void opengl_get_texture_params(OpenGLContext *opengl)
Definition: opengl_enc.c:659
LOAD_TEXTURE_DATA
#define LOAD_TEXTURE_DATA(comp_index, sub)
Definition: opengl_enc.c:1169
common.h
OpenGLVertexInfo::y
float y
Definition: opengl_enc.c:162
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:466
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:470
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:209
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:465
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:743
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:264
OpenGLFormatDesc::format
GLenum format
Definition: opengl_enc.c:234
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:311
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:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
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:239
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:643
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:78
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:165
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:985
desc
const char * desc
Definition: libsvtav1.c:75
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:77
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:1058
AVCodecParameters::format
int format
Definition: codec_par.h:92
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:499
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:80
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:262
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:79
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:239
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:233
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:173
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:2882
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 Sep 26 2024 23:15:28 for FFmpeg by   doxygen 1.8.17