FFmpeg
bktr.c
Go to the documentation of this file.
1 /*
2  * *BSD video grab interface
3  * Copyright (c) 2002 Steve O'Hara-Smith
4  * based on
5  * Linux video grab interface
6  * Copyright (c) 2000, 2001 Fabrice Bellard
7  * and
8  * simple_grab.c Copyright (c) 1999 Roger Hardiman
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 #include "libavformat/demux.h"
28 #include "libavformat/internal.h"
29 #include "libavutil/file_open.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/log.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/time.h"
35 #if HAVE_DEV_BKTR_IOCTL_METEOR_H && HAVE_DEV_BKTR_IOCTL_BT848_H
36 # include <dev/bktr/ioctl_meteor.h>
37 # include <dev/bktr/ioctl_bt848.h>
38 #elif HAVE_MACHINE_IOCTL_METEOR_H && HAVE_MACHINE_IOCTL_BT848_H
39 # include <machine/ioctl_meteor.h>
40 # include <machine/ioctl_bt848.h>
41 #elif HAVE_DEV_VIDEO_METEOR_IOCTL_METEOR_H && HAVE_DEV_VIDEO_BKTR_IOCTL_BT848_H
42 # include <dev/video/meteor/ioctl_meteor.h>
43 # include <dev/video/bktr/ioctl_bt848.h>
44 #elif HAVE_DEV_IC_BT8XX_H
45 # include <dev/ic/bt8xx.h>
46 #endif
47 #include <unistd.h>
48 #include <fcntl.h>
49 #include <sys/ioctl.h>
50 #include <sys/mman.h>
51 #include <sys/time.h>
52 #include <signal.h>
53 #include <stdint.h>
54 #include "avdevice.h"
55 
56 typedef struct VideoData {
57  AVClass *class;
58  int video_fd;
59  int tuner_fd;
60  int width, height;
61  uint64_t per_frame;
62  int standard;
63  char *framerate; /**< Set by a private option. */
64 } VideoData;
65 
66 
67 #define PAL 1
68 #define PALBDGHI 1
69 #define NTSC 2
70 #define NTSCM 2
71 #define SECAM 3
72 #define PALN 4
73 #define PALM 5
74 #define NTSCJ 6
75 
76 /* PAL is 768 x 576. NTSC is 640 x 480 */
77 #define PAL_HEIGHT 576
78 #define SECAM_HEIGHT 576
79 #define NTSC_HEIGHT 480
80 
81 #ifndef VIDEO_FORMAT
82 #define VIDEO_FORMAT NTSC
83 #endif
84 
85 static const int bktr_dev[] = { METEOR_DEV0, METEOR_DEV1, METEOR_DEV2,
86  METEOR_DEV3, METEOR_DEV_SVIDEO };
87 
88 uint8_t *video_buf;
90 uint64_t last_frame_time;
91 volatile sig_atomic_t nsignals;
92 
93 
94 static void catchsignal(int signal)
95 {
96  nsignals++;
97  return;
98 }
99 
100 static av_cold int bktr_init(const char *video_device, int width, int height,
101  int format, int *video_fd, int *tuner_fd, int idev, double frequency)
102 {
103  struct meteor_geomet geo;
104  int h_max;
105  long ioctl_frequency;
106  char *arg;
107  int c;
108  struct sigaction act, old;
109  int ret;
110  char errbuf[128];
111 
112  if (idev < 0 || idev > 4)
113  {
114  arg = getenv ("BKTR_DEV");
115  if (arg)
116  idev = atoi (arg);
117  if (idev < 0 || idev > 4)
118  idev = 1;
119  }
120 
121  if (format < 1 || format > 6)
122  {
123  arg = getenv ("BKTR_FORMAT");
124  if (arg)
125  format = atoi (arg);
126  if (format < 1 || format > 6)
128  }
129 
130  if (frequency <= 0)
131  {
132  arg = getenv ("BKTR_FREQUENCY");
133  if (arg)
134  frequency = atof (arg);
135  if (frequency <= 0)
136  frequency = 0.0;
137  }
138 
139  memset(&act, 0, sizeof(act));
140  sigemptyset(&act.sa_mask);
141  act.sa_handler = catchsignal;
142  sigaction(SIGUSR1, &act, &old);
143 
144  *tuner_fd = avpriv_open("/dev/tuner0", O_RDONLY);
145  if (*tuner_fd < 0)
146  av_log(NULL, AV_LOG_ERROR, "Warning. Tuner not opened, continuing: %s\n", strerror(errno));
147 
148  *video_fd = avpriv_open(video_device, O_RDONLY);
149  if (*video_fd < 0) {
150  ret = AVERROR(errno);
151  av_strerror(ret, errbuf, sizeof(errbuf));
152  av_log(NULL, AV_LOG_ERROR, "%s: %s\n", video_device, errbuf);
153  return ret;
154  }
155 
156  geo.rows = height;
157  geo.columns = width;
158  geo.frames = 1;
159  geo.oformat = METEOR_GEO_YUV_422 | METEOR_GEO_YUV_12;
160 
161  switch (format) {
162  case PAL: h_max = PAL_HEIGHT; c = BT848_IFORM_F_PALBDGHI; break;
163  case PALN: h_max = PAL_HEIGHT; c = BT848_IFORM_F_PALN; break;
164  case PALM: h_max = PAL_HEIGHT; c = BT848_IFORM_F_PALM; break;
165  case SECAM: h_max = SECAM_HEIGHT; c = BT848_IFORM_F_SECAM; break;
166  case NTSC: h_max = NTSC_HEIGHT; c = BT848_IFORM_F_NTSCM; break;
167  case NTSCJ: h_max = NTSC_HEIGHT; c = BT848_IFORM_F_NTSCJ; break;
168  default: h_max = PAL_HEIGHT; c = BT848_IFORM_F_PALBDGHI; break;
169  }
170 
171  if (height <= h_max / 2)
172  geo.oformat |= METEOR_GEO_EVEN_ONLY;
173 
174  if (ioctl(*video_fd, METEORSETGEO, &geo) < 0) {
175  ret = AVERROR(errno);
176  av_strerror(ret, errbuf, sizeof(errbuf));
177  av_log(NULL, AV_LOG_ERROR, "METEORSETGEO: %s\n", errbuf);
178  return ret;
179  }
180 
181  if (ioctl(*video_fd, BT848SFMT, &c) < 0) {
182  ret = AVERROR(errno);
183  av_strerror(ret, errbuf, sizeof(errbuf));
184  av_log(NULL, AV_LOG_ERROR, "BT848SFMT: %s\n", errbuf);
185  return ret;
186  }
187 
188  c = bktr_dev[idev];
189  if (ioctl(*video_fd, METEORSINPUT, &c) < 0) {
190  ret = AVERROR(errno);
191  av_strerror(ret, errbuf, sizeof(errbuf));
192  av_log(NULL, AV_LOG_ERROR, "METEORSINPUT: %s\n", errbuf);
193  return ret;
194  }
195 
196  video_buf_size = width * height * 12 / 8;
197 
198  video_buf = (uint8_t *)mmap((caddr_t)0, video_buf_size,
199  PROT_READ, MAP_SHARED, *video_fd, (off_t)0);
200  if (video_buf == MAP_FAILED) {
201  ret = AVERROR(errno);
202  av_strerror(ret, errbuf, sizeof(errbuf));
203  av_log(NULL, AV_LOG_ERROR, "mmap: %s\n", errbuf);
204  return ret;
205  }
206 
207  if (frequency != 0.0) {
208  ioctl_frequency = (unsigned long)(frequency*16);
209  if (ioctl(*tuner_fd, TVTUNER_SETFREQ, &ioctl_frequency) < 0)
210  av_log(NULL, AV_LOG_ERROR, "TVTUNER_SETFREQ: %s\n", strerror(errno));
211  }
212 
213  c = AUDIO_UNMUTE;
214  if (ioctl(*tuner_fd, BT848_SAUDIO, &c) < 0)
215  av_log(NULL, AV_LOG_ERROR, "TVTUNER_SAUDIO: %s\n", strerror(errno));
216 
217  c = METEOR_CAP_CONTINOUS;
218  ioctl(*video_fd, METEORCAPTUR, &c);
219 
220  c = SIGUSR1;
221  ioctl(*video_fd, METEORSSIGNAL, &c);
222 
223  return 0;
224 }
225 
226 static void bktr_getframe(uint64_t per_frame)
227 {
228  uint64_t curtime;
229 
230  curtime = av_gettime_relative();
231  if (!last_frame_time
232  || ((last_frame_time + per_frame) > curtime)) {
233  if (!usleep(last_frame_time + per_frame + per_frame / 8 - curtime)) {
234  if (!nsignals)
236  "SLEPT NO signals - %d microseconds late\n",
237  (int)(av_gettime_relative() - last_frame_time - per_frame));
238  }
239  }
240  nsignals = 0;
241  last_frame_time = curtime;
242 }
243 
244 
245 /* note: we support only one picture read at a time */
247 {
248  VideoData *s = s1->priv_data;
249 
250  if (av_new_packet(pkt, video_buf_size) < 0)
251  return AVERROR(EIO);
252 
253  bktr_getframe(s->per_frame);
254 
255  pkt->pts = av_gettime();
256  memcpy(pkt->data, video_buf, video_buf_size);
257 
258  return video_buf_size;
259 }
260 
262 {
263  VideoData *s = s1->priv_data;
264  AVStream *st;
266  int ret = 0;
267 
268  av_log(s1, AV_LOG_WARNING, "bktr input is deprecated and will be removed. "
269  "Please contact the developers if you are interested in maintaining it.\n");
270 
271  if (!s->framerate)
272  switch (s->standard) {
273  case PAL: s->framerate = av_strdup("pal"); break;
274  case NTSC: s->framerate = av_strdup("ntsc"); break;
275  case SECAM: s->framerate = av_strdup("25"); break;
276  default:
277  av_log(s1, AV_LOG_ERROR, "Unknown standard.\n");
278  ret = AVERROR(EINVAL);
279  goto out;
280  }
281  if ((ret = av_parse_video_rate(&framerate, s->framerate)) < 0) {
282  av_log(s1, AV_LOG_ERROR, "Could not parse framerate '%s'.\n", s->framerate);
283  goto out;
284  }
285 
286  st = avformat_new_stream(s1, NULL);
287  if (!st) {
288  ret = AVERROR(ENOMEM);
289  goto out;
290  }
291  avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in use */
292 
293  s->per_frame = ((uint64_t)1000000 * framerate.den) / framerate.num;
294 
298  st->codecpar->width = s->width;
299  st->codecpar->height = s->height;
301 
302  if (bktr_init(s1->url, s->width, s->height, s->standard,
303  &s->video_fd, &s->tuner_fd, -1, 0.0) < 0) {
304  ret = AVERROR(EIO);
305  goto out;
306  }
307 
308  nsignals = 0;
309  last_frame_time = 0;
310 
311 out:
312  return ret;
313 }
314 
316 {
317  VideoData *s = s1->priv_data;
318  int c;
319 
320  c = METEOR_CAP_STOP_CONT;
321  ioctl(s->video_fd, METEORCAPTUR, &c);
322  close(s->video_fd);
323 
324  c = AUDIO_MUTE;
325  ioctl(s->tuner_fd, BT848_SAUDIO, &c);
326  close(s->tuner_fd);
327 
328  munmap((caddr_t)video_buf, video_buf_size);
329 
330  return 0;
331 }
332 
333 #define OFFSET(x) offsetof(VideoData, x)
334 #define DEC AV_OPT_FLAG_DECODING_PARAM
335 static const AVOption options[] = {
336  { "standard", "", offsetof(VideoData, standard), AV_OPT_TYPE_INT, {.i64 = VIDEO_FORMAT}, PAL, NTSCJ, AV_OPT_FLAG_DECODING_PARAM, .unit = "standard" },
337  { "PAL", "", 0, AV_OPT_TYPE_CONST, {.i64 = PAL}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, .unit = "standard" },
338  { "NTSC", "", 0, AV_OPT_TYPE_CONST, {.i64 = NTSC}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, .unit = "standard" },
339  { "SECAM", "", 0, AV_OPT_TYPE_CONST, {.i64 = SECAM}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, .unit = "standard" },
340  { "PALN", "", 0, AV_OPT_TYPE_CONST, {.i64 = PALN}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, .unit = "standard" },
341  { "PALM", "", 0, AV_OPT_TYPE_CONST, {.i64 = PALM}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, .unit = "standard" },
342  { "NTSCJ", "", 0, AV_OPT_TYPE_CONST, {.i64 = NTSCJ}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, .unit = "standard" },
343  { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = "vga"}, 0, 0, DEC },
344  { "framerate", "", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
345  { NULL },
346 };
347 
348 static const AVClass bktr_class = {
349  .class_name = "BKTR grab indev",
350  .item_name = av_default_item_name,
351  .option = options,
352  .version = LIBAVUTIL_VERSION_INT,
354 };
355 
357  .p.name = "bktr",
358  .p.long_name = NULL_IF_CONFIG_SMALL("video grab"),
359  .p.flags = AVFMT_NOFILE,
360  .p.priv_class = &bktr_class,
361  .priv_data_size = sizeof(VideoData),
365 };
bktr_class
static const AVClass bktr_class
Definition: bktr.c:348
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
options
static const AVOption options[]
Definition: bktr.c:335
out
FILE * out
Definition: movenc.c:54
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
OFFSET
#define OFFSET(x)
Definition: bktr.c:333
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
PALM
#define PALM
Definition: bktr.c:73
NTSC_HEIGHT
#define NTSC_HEIGHT
Definition: bktr.c:79
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:346
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
last_frame_time
uint64_t last_frame_time
Definition: bktr.c:90
VideoData::tuner_fd
int tuner_fd
Definition: bktr.c:59
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:853
av_strerror
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:108
bktr_init
static av_cold int bktr_init(const char *video_device, int width, int height, int format, int *video_fd, int *tuner_fd, int idev, double frequency)
Definition: bktr.c:100
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
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
av_cold
#define av_cold
Definition: attributes.h:90
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
SECAM
#define SECAM
Definition: bktr.c:71
NTSCJ
#define NTSCJ
Definition: bktr.c:74
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:198
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:98
avpriv_open
int avpriv_open(const char *filename, int flags,...)
A wrapper for open() setting O_CLOEXEC.
Definition: file_open.c:67
PALN
#define PALN
Definition: bktr.c:72
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
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
s1
#define s1
Definition: regdef.h:38
VIDEO_FORMAT
#define VIDEO_FORMAT
Definition: bktr.c:82
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
bktr_dev
static const int bktr_dev[]
Definition: bktr.c:85
file_open.h
grab_read_packet
static int grab_read_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: bktr.c:246
arg
const char * arg
Definition: jacosubdec.c:67
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
framerate
float framerate
Definition: av1_levels.c:29
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
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
parseutils.h
time.h
AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
@ AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
Definition: log.h:41
VideoData::per_frame
uint64_t per_frame
Definition: bktr.c:61
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
grab_read_header
static int grab_read_header(AVFormatContext *s1)
Definition: bktr.c:261
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
video_buf
uint8_t * video_buf
Definition: bktr.c:88
PAL
#define PAL
Definition: bktr.c:67
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
VideoData::height
int height
Definition: bktr.c:60
avdevice.h
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:35
height
#define height
NTSC
#define NTSC
Definition: bktr.c:69
VideoData
Definition: bktr.c:56
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
av_parse_video_rate
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:181
VideoData::framerate
char * framerate
Set by a private option.
Definition: bktr.c:63
log.h
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:135
video_buf_size
size_t video_buf_size
Definition: bktr.c:89
VideoData::standard
int standard
Definition: bktr.c:62
demux.h
bktr_getframe
static void bktr_getframe(uint64_t per_frame)
Definition: bktr.c:226
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
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
VideoData::width
int width
Definition: bktr.c:60
PAL_HEIGHT
#define PAL_HEIGHT
Definition: bktr.c:77
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
catchsignal
static void catchsignal(int signal)
Definition: bktr.c:94
VideoData::video_fd
int video_fd
Definition: bktr.c:58
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
ff_bktr_demuxer
const FFInputFormat ff_bktr_demuxer
Definition: bktr.c:356
DEC
#define DEC
Definition: bktr.c:334
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:273
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::format
int format
Definition: codec_par.h:92
grab_read_close
static int grab_read_close(AVFormatContext *s1)
Definition: bktr.c:315
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
FFInputFormat
Definition: demux.h:31
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SECAM_HEIGHT
#define SECAM_HEIGHT
Definition: bktr.c:78
nsignals
volatile sig_atomic_t nsignals
Definition: bktr.c:91
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244