This file is indexed.

/usr/include/ogmrip/ogmrip-plugin.h is in libogmrip-dev 1.0.1-1build2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
/* OGMRip - A library for DVD ripping and encoding
 * Copyright (C) 2004-2012 Olivier Rolland <billl@users.sourceforge.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#ifndef __OGMRIP_PLUGIN_H__
#define __OGMRIP_PLUGIN_H__

#include <ogmrip-enums.h>

#include <glib-object.h>
#include <gmodule.h>

G_BEGIN_DECLS

#define OGMRIP_PLUGIN_ERROR ogmrip_plugin_error_quark ()

/**
 * OGMRipPluginError:
 * @OGMRIP_PLUGIN_ERROR_REQ: Some requirements are not met
 *
 * Error codes returned by ogmrip_init_plugin().
 */
typedef enum
{
  OGMRIP_PLUGIN_ERROR_REQ
} OGMRipPluginError;

/**
 * OGMRipPluginFunc:
 * @type: The type of the plugin
 * @name: The name of the plugin
 * @description: The description of the plugin
 * @data: The user data
 *
 * Specifies the type of functions passed to ogmrip_plugin_foreach_container(),
 * ogmrip_plugin_foreach_video_codec(), ogmrip_plugin_foreach_audio_codec(),
 * and ogmrip_plugin_foreach_subp_codec().
 */
typedef void (* OGMRipPluginFunc)    (GType         type,
                                      const gchar   *name,
                                      const gchar   *description,
                                      gpointer      data);

/**
 * OGMRipPluginCmpFunc:
 * @type: The type of the plugin
 * @name: The name of the plugin
 * @description: The description of the plugin
 * @data: The user data
 *
 * Specifieѕ the type of functions passed to ogmrip_plugin_find_container(),
 * ogmrip_plugin_find_video_codec(), ogmrip_plugin_find_audio_codec(), and
 * ogmrip_plugin_find_subp_codec().
 *
 * Returns: 0 when the expected plugin is found
 */
typedef gint (* OGMRipPluginCmpFunc) (GType         type,
                                      const gchar   *name,
                                      const gchar   *description,
                                      gconstpointer data);

/**
 * OGMRipVideoPlugin:
 * @module: For internal use only
 * @type: The type of the codec
 * @name: The name of the codec
 * @description: The description of the codec
 * @format: The codec output format
 * @passes: The number of passes supported by the codec
 * @threads: The number of threads supported by the codec
 *
 * A structure describing a video codec plugin
 */

typedef struct _OGMRipVideoPlugin OGMRipVideoPlugin;

struct _OGMRipVideoPlugin
{
  GModule *module;
  /*< public >*/
  GType type;
  gchar *name;
  gchar *description;
  OGMRipFormatType format;
  gint passes;
  gint threads;
};

/**
 * OGMRipAudioPlugin:
 * @module: For internal use only
 * @type: The type of the codec
 * @name: The name of the codec
 * @description: The description of the codec
 * @format: The codec output format
 *
 * A structure describing an audio codec plugin
 */

typedef struct _OGMRipAudioPlugin OGMRipAudioPlugin;

struct _OGMRipAudioPlugin
{
  GModule *module;
  /*< public >*/
  GType type;
  gchar *name;
  gchar *description;
  OGMRipFormatType format;
};

/**
 * OGMRipSubpPlugin:
 * @module: For internal use only
 * @type: The type of the codec
 * @name: The name of the codec
 * @description: The description of the codec
 * @format: The codec output format
 * @text: Whether the codec outputs text subtitles
 *
 * A structure describing a subtitle codec plugin
 */

typedef struct _OGMRipSubpPlugin  OGMRipSubpPlugin;

struct _OGMRipSubpPlugin
{
  GModule *module;
  /*< public >*/
  GType type;
  gchar *name;
  gchar *description;
  OGMRipFormatType format;
  gboolean text;
};

/**
 * OGMRipContainerPlugin:
 * @module: For internal use only
 * @type: The type of the container
 * @name: The name of the container
 * @description: The description of the container
 * @video: Whether the container requires a video stream
 * @bframes: Whether the container supports B-frames
 * @max_audio: The maximum number of audio streams that can be embedded in the container
 * @max_subp: The maximum number of subtitle streams that can be embedded in the container
 * @formats: A NULL terminated array of #OGMRipFormatType supported by the container
 *
 * A structure describing a container plugin
 */

typedef struct _OGMRipContainerPlugin  OGMRipContainerPlugin;

struct _OGMRipContainerPlugin
{
  GModule *module;
  /*< public >*/
  GType type;
  gchar *name;
  gchar *description;
  gboolean video;
  gboolean bframes;
  gint max_audio;
  gint max_subp;
  gint *formats;
};

void     ogmrip_plugin_init        (void);
void     ogmrip_plugin_uninit      (void);
GQuark   ogmrip_plugin_error_quark (void);

/*
 * Container functions
 */

gint          ogmrip_plugin_get_n_containers        (void);
void          ogmrip_plugin_foreach_container       (OGMRipPluginFunc    func,
                                                     gpointer             data);
GType         ogmrip_plugin_find_container          (OGMRipPluginCmpFunc func,
                                                     gconstpointer        data);

GType         ogmrip_plugin_get_nth_container       (guint n);
GType         ogmrip_plugin_get_container_by_name   (const gchar *name);
gint          ogmrip_plugin_get_container_index     (GType container);
const gchar * ogmrip_plugin_get_container_name      (GType container);
gboolean      ogmrip_plugin_get_container_bframes   (GType container);
gint          ogmrip_plugin_get_container_max_audio (GType container);
gint          ogmrip_plugin_get_container_max_subp  (GType container);
GModule *     ogmrip_plugin_get_container_module    (GType container);

/*
 * Video codec functions
 */

gint          ogmrip_plugin_get_n_video_codecs      (void);
void          ogmrip_plugin_foreach_video_codec     (OGMRipPluginFunc    func,
                                                     gpointer             data);
GType         ogmrip_plugin_find_video_codec        (OGMRipPluginCmpFunc func,
                                                     gconstpointer        data);

GType         ogmrip_plugin_get_nth_video_codec     (guint n);
GType         ogmrip_plugin_get_video_codec_by_name (const gchar *name);
gint          ogmrip_plugin_get_video_codec_index   (GType codec);
const gchar * ogmrip_plugin_get_video_codec_name    (GType codec);
gint          ogmrip_plugin_get_video_codec_format  (GType codec);
gint          ogmrip_plugin_get_video_codec_passes  (GType codec);
gint          ogmrip_plugin_get_video_codec_threads (GType codec);
GModule *     ogmrip_plugin_get_video_codec_module  (GType codec);

/*
 * Audio codec functions
 */

gint          ogmrip_plugin_get_n_audio_codecs      (void);
void          ogmrip_plugin_foreach_audio_codec     (OGMRipPluginFunc    func,
                                                     gpointer            data);
GType         ogmrip_plugin_find_audio_codec        (OGMRipPluginCmpFunc func,
                                                     gconstpointer       data);

GType         ogmrip_plugin_get_nth_audio_codec     (guint n);
GType         ogmrip_plugin_get_audio_codec_by_name (const gchar *name);
gint          ogmrip_plugin_get_audio_codec_index   (GType codec);
const gchar * ogmrip_plugin_get_audio_codec_name    (GType codec);
gint          ogmrip_plugin_get_audio_codec_format  (GType codec);
GModule *     ogmrip_plugin_get_audio_codec_module  (GType codec);

/*
 * Subp codec functions
 */

gint          ogmrip_plugin_get_n_subp_codecs      (void);
void          ogmrip_plugin_foreach_subp_codec     (OGMRipPluginFunc    func,
                                                    gpointer            data);
GType         ogmrip_plugin_find_subp_codec        (OGMRipPluginCmpFunc func,
                                                    gconstpointer       data);

GType         ogmrip_plugin_get_nth_subp_codec     (guint n);
GType         ogmrip_plugin_get_subp_codec_by_name (const gchar *name);
gint          ogmrip_plugin_get_subp_codec_index   (GType codec);
const gchar * ogmrip_plugin_get_subp_codec_name    (GType codec);
gint          ogmrip_plugin_get_subp_codec_format  (GType codec);
gboolean      ogmrip_plugin_get_subp_codec_text    (GType codec);
GModule *     ogmrip_plugin_get_subp_codec_module  (GType codec);

/*
 * Compatibility functions
 */

gboolean ogmrip_plugin_can_contain_format  (GType            container,
                                            OGMRipFormatType format);
gboolean ogmrip_plugin_can_contain_video   (GType            container,
                                            GType            codec);
gboolean ogmrip_plugin_can_contain_audio   (GType            container,
                                            GType            codec);
gboolean ogmrip_plugin_can_contain_subp    (GType            container,
                                            GType            codec);

gboolean ogmrip_plugin_can_contain_n_audio (GType            container,
                                            guint            ncodec);
gboolean ogmrip_plugin_can_contain_n_subp  (GType            container,
                                            guint            ncodec);

G_END_DECLS

#endif /* __OGMRIP_PLUGIN_H__ */