FFmpeg: libavutil/tests/opt.c Source File

FFmpeg
opt.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <limits.h>
20 #include <stdio.h>
21 
22 #include "libavutil/common.h"
23 #include "libavutil/channel_layout.h"
24 #include "libavutil/error.h"
25 #include "libavutil/log.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/rational.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/pixdesc.h"
30 
31  typedef struct TestContext {
32   const AVClass *class;
33   int num;
34   int toggle;
35   char *string;
36   int flags;
37   AVRational rational;
38   AVRational video_rate;
39   int w, h;
40   enum AVPixelFormat pix_fmt;
41   enum AVSampleFormat sample_fmt;
42   int64_t duration;
43   uint8_t color[4];
44   int64_t channel_layout;
45   void *binary;
46   int binary_size;
47   void *binary1;
48   int binary_size1;
49   void *binary2;
50   int binary_size2;
51   int64_t num64;
52   float flt;
53   double dbl;
54   char *escape;
55   int bool1;
56   int bool2;
57   int bool3;
58 } TestContext;
59 
60  #define OFFSET(x) offsetof(TestContext, x)
61 
62  #define TEST_FLAG_COOL 01
63  #define TEST_FLAG_LAME 02
64  #define TEST_FLAG_MU 04
65 
66  static const AVOption test_options[]= {
67  {"num", "set num", OFFSET(num), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, 1 },
68  {"toggle", "set toggle", OFFSET(toggle), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, 1 },
69  {"rational", "set rational", OFFSET(rational), AV_OPT_TYPE_RATIONAL, { .dbl = 1 }, 0, 10, 1 },
70  {"string", "set string", OFFSET(string), AV_OPT_TYPE_STRING, { .str = "default" }, CHAR_MIN, CHAR_MAX, 1 },
71  {"escape", "set escape str", OFFSET(escape), AV_OPT_TYPE_STRING, { .str = "\\=," }, CHAR_MIN, CHAR_MAX, 1 },
72  {"flags", "set flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, { .i64 = 1 }, 0, INT_MAX, 1, "flags" },
73  {"cool", "set cool flag", 0, AV_OPT_TYPE_CONST, { .i64 = TEST_FLAG_COOL }, INT_MIN, INT_MAX, 1, "flags" },
74  {"lame", "set lame flag", 0, AV_OPT_TYPE_CONST, { .i64 = TEST_FLAG_LAME }, INT_MIN, INT_MAX, 1, "flags" },
75  {"mu", "set mu flag", 0, AV_OPT_TYPE_CONST, { .i64 = TEST_FLAG_MU }, INT_MIN, INT_MAX, 1, "flags" },
76  {"size", "set size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, { .str="200x300" }, 0, 0, 1 },
77  {"pix_fmt", "set pixfmt", OFFSET(pix_fmt), AV_OPT_TYPE_PIXEL_FMT, { .i64 = AV_PIX_FMT_0BGR }, -1, INT_MAX, 1 },
78  {"sample_fmt", "set samplefmt", OFFSET(sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, { .i64 = AV_SAMPLE_FMT_S16 }, -1, INT_MAX, 1 },
79  {"video_rate", "set videorate", OFFSET(video_rate), AV_OPT_TYPE_VIDEO_RATE, { .str = "25" }, 0, INT_MAX, 1 },
80  {"duration", "set duration", OFFSET(duration), AV_OPT_TYPE_DURATION, { .i64 = 1000 }, 0, INT64_MAX, 1 },
81  {"color", "set color", OFFSET(color), AV_OPT_TYPE_COLOR, { .str = "pink" }, 0, 0, 1 },
82  {"cl", "set channel layout", OFFSET(channel_layout), AV_OPT_TYPE_CHANNEL_LAYOUT, { .i64 = AV_CH_LAYOUT_HEXAGONAL }, 0, INT64_MAX, 1 },
83  {"bin", "set binary value", OFFSET(binary), AV_OPT_TYPE_BINARY, { .str="62696e00" }, 0, 0, 1 },
84  {"bin1", "set binary value", OFFSET(binary1), AV_OPT_TYPE_BINARY, { .str=NULL }, 0, 0, 1 },
85  {"bin2", "set binary value", OFFSET(binary2), AV_OPT_TYPE_BINARY, { .str="" }, 0, 0, 1 },
86  {"num64", "set num 64bit", OFFSET(num64), AV_OPT_TYPE_INT64, { .i64 = 1 }, 0, 100, 1 },
87  {"flt", "set float", OFFSET(flt), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 / 3 }, 0, 100, 1 },
88  {"dbl", "set double", OFFSET(dbl), AV_OPT_TYPE_DOUBLE, { .dbl = 1.0 / 3 }, 0, 100, 1 },
89  {"bool1", "set boolean value", OFFSET(bool1), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, 1 },
90  {"bool2", "set boolean value", OFFSET(bool2), AV_OPT_TYPE_BOOL, { .i64 = 1 }, -1, 1, 1 },
91  {"bool3", "set boolean value", OFFSET(bool3), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, 1 },
92  { NULL },
93 };
94 
95  static const char *test_get_name(void *ctx)
96 {
97  return "test";
98 }
99 
100  static const AVClass test_class = {
101  .class_name = "TestContext",
102  .item_name = test_get_name,
103  .option = test_options,
104 };
105 
106  static void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
107 {
108  vfprintf(stdout, fmt, vl);
109 }
110 
111  int main(void)
112 {
113  int i;
114 
115  av_log_set_level(AV_LOG_DEBUG);
116  av_log_set_callback(log_callback_help);
117 
118  printf("Testing default values\n");
119  {
120  TestContext test_ctx = { 0 };
121  test_ctx.class = &test_class;
122  av_opt_set_defaults(&test_ctx);
123 
124  printf("num=%d\n", test_ctx.num);
125  printf("toggle=%d\n", test_ctx.toggle);
126  printf("string=%s\n", test_ctx.string);
127  printf("escape=%s\n", test_ctx.escape);
128  printf("flags=%d\n", test_ctx.flags);
129  printf("rational=%d/%d\n", test_ctx.rational.num, test_ctx.rational.den);
130  printf("video_rate=%d/%d\n", test_ctx.video_rate.num, test_ctx.video_rate.den);
131  printf("width=%d height=%d\n", test_ctx.w, test_ctx.h);
132  printf("pix_fmt=%s\n", av_get_pix_fmt_name(test_ctx.pix_fmt));
133  printf("sample_fmt=%s\n", av_get_sample_fmt_name(test_ctx.sample_fmt));
134  printf("duration=%"PRId64"\n", test_ctx.duration);
135  printf("color=%d %d %d %d\n", test_ctx.color[0], test_ctx.color[1], test_ctx.color[2], test_ctx.color[3]);
136  printf("channel_layout=%"PRId64"=%"PRId64"\n", test_ctx.channel_layout, (int64_t)AV_CH_LAYOUT_HEXAGONAL);
137  if (test_ctx.binary)
138  printf("binary=%x %x %x %x\n", ((uint8_t*)test_ctx.binary)[0], ((uint8_t*)test_ctx.binary)[1], ((uint8_t*)test_ctx.binary)[2], ((uint8_t*)test_ctx.binary)[3]);
139  printf("binary_size=%d\n", test_ctx.binary_size);
140  printf("num64=%"PRId64"\n", test_ctx.num64);
141  printf("flt=%.6f\n", test_ctx.flt);
142  printf("dbl=%.6f\n", test_ctx.dbl);
143 
144  av_opt_show2(&test_ctx, NULL, -1, 0);
145 
146  av_opt_free(&test_ctx);
147  }
148 
149  printf("\nTesting av_opt_is_set_to_default()\n");
150  {
151  int ret;
152  TestContext test_ctx = { 0 };
153  const AVOption *o = NULL;
154  test_ctx.class = &test_class;
155 
156  av_log_set_level(AV_LOG_QUIET);
157 
158  while (o = av_opt_next(&test_ctx, o)) {
159  ret = av_opt_is_set_to_default_by_name(&test_ctx, o->name, 0);
160  printf("name:%10s default:%d error:%s\n", o->name, !!ret, ret < 0 ? av_err2str(ret) : "");
161  }
162  av_opt_set_defaults(&test_ctx);
163  while (o = av_opt_next(&test_ctx, o)) {
164  ret = av_opt_is_set_to_default_by_name(&test_ctx, o->name, 0);
165  printf("name:%10s default:%d error:%s\n", o->name, !!ret, ret < 0 ? av_err2str(ret) : "");
166  }
167  av_opt_free(&test_ctx);
168  }
169 
170  printf("\nTest av_opt_serialize()\n");
171  {
172  TestContext test_ctx = { 0 };
173  char *buf;
174  test_ctx.class = &test_class;
175 
176  av_log_set_level(AV_LOG_QUIET);
177 
178  av_opt_set_defaults(&test_ctx);
179  if (av_opt_serialize(&test_ctx, 0, 0, &buf, '=', ',') >= 0) {
180  printf("%s\n", buf);
181  av_opt_free(&test_ctx);
182  memset(&test_ctx, 0, sizeof(test_ctx));
183  test_ctx.class = &test_class;
184  av_set_options_string(&test_ctx, buf, "=", ",");
185  av_free(buf);
186  if (av_opt_serialize(&test_ctx, 0, 0, &buf, '=', ',') >= 0) {
187  printf("%s\n", buf);
188  av_free(buf);
189  }
190  }
191  av_opt_free(&test_ctx);
192  }
193 
194  printf("\nTesting av_set_options_string()\n");
195  {
196  TestContext test_ctx = { 0 };
197  static const char * const options[] = {
198  "",
199  ":",
200  "=",
201  "foo=:",
202  ":=foo",
203  "=foo",
204  "foo=",
205  "foo",
206  "foo=val",
207  "foo==val",
208  "toggle=:",
209  "string=:",
210  "toggle=1 : foo",
211  "toggle=100",
212  "toggle==1",
213  "flags=+mu-lame : num=42: toggle=0",
214  "num=42 : string=blahblah",
215  "rational=0 : rational=1/2 : rational=1/-1",
216  "rational=-1/0",
217  "size=1024x768",
218  "size=pal",
219  "size=bogus",
220  "pix_fmt=yuv420p",
221  "pix_fmt=2",
222  "pix_fmt=bogus",
223  "sample_fmt=s16",
224  "sample_fmt=2",
225  "sample_fmt=bogus",
226  "video_rate=pal",
227  "video_rate=25",
228  "video_rate=30000/1001",
229  "video_rate=30/1.001",
230  "video_rate=bogus",
231  "duration=bogus",
232  "duration=123.45",
233  "duration=1\\:23\\:45.67",
234  "color=blue",
235  "color=0x223300",
236  "color=0x42FF07AA",
237  "cl=stereo+downmix",
238  "cl=foo",
239  "bin=boguss",
240  "bin=111",
241  "bin=ffff",
242  "num64=bogus",
243  "num64=44",
244  "num64=44.4",
245  "num64=-1",
246  "num64=101",
247  "flt=bogus",
248  "flt=2",
249  "flt=2.2",
250  "flt=-1",
251  "flt=101",
252  "dbl=bogus",
253  "dbl=2",
254  "dbl=2.2",
255  "dbl=-1",
256  "dbl=101",
257  "bool1=true",
258  "bool2=auto",
259  };
260 
261  test_ctx.class = &test_class;
262  av_opt_set_defaults(&test_ctx);
263 
264  av_log_set_level(AV_LOG_QUIET);
265 
266  for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
267  int silence_log = !strcmp(options[i], "rational=-1/0"); // inf formating differs between platforms
268  av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
269  if (silence_log)
270  av_log_set_callback(NULL);
271  if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
272  printf("Error '%s'\n", options[i]);
273  else
274  printf("OK '%s'\n", options[i]);
275  av_log_set_callback(log_callback_help);
276  }
277  av_opt_free(&test_ctx);
278  }
279 
280  printf("\nTesting av_opt_set_from_string()\n");
281  {
282  TestContext test_ctx = { 0 };
283  static const char * const options[] = {
284  "",
285  "5",
286  "5:hello",
287  "5:hello:size=pal",
288  "5:size=pal:hello",
289  ":",
290  "=",
291  " 5 : hello : size = pal ",
292  "a_very_long_option_name_that_will_need_to_be_ellipsized_around_here=42"
293  };
294  static const char * const shorthand[] = { "num", "string", NULL };
295 
296  test_ctx.class = &test_class;
297  av_opt_set_defaults(&test_ctx);
298 
299  av_log_set_level(AV_LOG_QUIET);
300 
301  for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
302  av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
303  if (av_opt_set_from_string(&test_ctx, options[i], shorthand, "=", ":") < 0)
304  printf("Error '%s'\n", options[i]);
305  else
306  printf("OK '%s'\n", options[i]);
307  }
308  av_opt_free(&test_ctx);
309  }
310 
311  return 0;
312 }
NULL
#define NULL
Definition: coverity.c:32
TestContext::escape
char * escape
Definition: opt.c:54
AV_OPT_TYPE_INT64
Definition: opt.h:224
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
OFFSET
#define OFFSET(x)
Definition: opt.c:60
AVOption
AVOption.
Definition: opt.h:246
fmt
const char * fmt
Definition: avisynth_c.h:769
mem.h
Memory handling functions.
AV_OPT_TYPE_INT
Definition: opt.h:223
av_log_set_level
void av_log_set_level(int level)
Set the log level.
Definition: log.c:385
TestContext::pix_fmt
enum AVPixelFormat pix_fmt
Definition: opt.c:40
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1292
AV_OPT_TYPE_PIXEL_FMT
Definition: opt.h:234
AVRational::num
int num
Numerator.
Definition: rational.h:59
av_set_options_string
int av_set_options_string(void *ctx, const char *opts, const char *key_val_sep, const char *pairs_sep)
Parse the key/value pairs list in opts.
Definition: opt.c:1413
TestContext::toggle
int toggle
Definition: opt.c:34
TestContext::w
int w
Definition: opt.c:39
AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:235
av_opt_serialize
int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer, const char key_val_sep, const char pairs_sep)
Serialize object's options.
Definition: opt.c:1981
av_opt_is_set_to_default_by_name
int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
Check if given option is set to its default value.
Definition: opt.c:1969
AV_OPT_TYPE_FLAGS
Definition: opt.h:222
AV_OPT_TYPE_COLOR
Definition: opt.h:238
AV_LOG_QUIET
#define AV_LOG_QUIET
Print no output.
Definition: log.h:158
av_opt_set_from_string
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1493
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:72
AVOption::name
const char * name
Definition: opt.h:247
AV_OPT_TYPE_CONST
Definition: opt.h:232
uint8_t
uint8_t
Definition: audio_convert.c:194
TestContext::sample_fmt
enum AVSampleFormat sample_fmt
Definition: opt.c:41
opt.h
AVOptions.
TestContext::flags
int flags
Definition: opt.c:36
AV_CH_LAYOUT_HEXAGONAL
#define AV_CH_LAYOUT_HEXAGONAL
Definition: channel_layout.h:101
duration
int64_t duration
Definition: movenc.c:63
AV_OPT_TYPE_STRING
Definition: opt.h:227
flags
static int flags
Definition: log.c:55
TestContext::num64
int64_t num64
Definition: opt.c:51
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_OPT_TYPE_CHANNEL_LAYOUT
Definition: opt.h:239
TestContext::video_rate
AVRational video_rate
Definition: opt.c:38
error.h
error code definitions
TestContext::rational
AVRational rational
Definition: opt.c:37
AV_OPT_TYPE_FLOAT
Definition: opt.h:226
TestContext::color
uint8_t color[4]
Definition: opt.c:43
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
av_opt_next
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
av_get_sample_fmt_name
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:49
log_callback_help
static void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
Definition: opt.c:106
TestContext::binary_size2
int binary_size2
Definition: opt.c:50
channel_layout.h
audio channel layout utility functions
av_log_set_callback
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:400
w
uint8_t w
Definition: llviddspenc.c:38
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_OPT_TYPE_BOOL
Definition: opt.h:240
TestContext::bool3
int bool3
Definition: opt.c:57
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:36
AV_OPT_TYPE_BINARY
offset must point to a pointer immediately followed by an int for the length
Definition: opt.h:229
TestContext::binary2
void * binary2
Definition: opt.c:49
TestContext::flt
float flt
Definition: opt.c:52
TestContext::h
int h
Definition: opt.c:39
AV_OPT_TYPE_DOUBLE
Definition: opt.h:225
test_class
static const AVClass test_class
Definition: opt.c:100
TestContext::bool2
int bool2
Definition: opt.c:56
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
av_opt_show2
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:1280
test_options
static const AVOption test_options[]
Definition: opt.c:66
TestContext::bool1
int bool1
Definition: opt.c:55
TestContext::channel_layout
int64_t channel_layout
Definition: opt.c:44
buf
void * buf
Definition: avisynth_c.h:690
TEST_FLAG_LAME
#define TEST_FLAG_LAME
Definition: opt.c:63
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
TestContext::duration
int64_t duration
Definition: opt.c:42
AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:236
AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:233
TestContext::class
const AVClass * class
Definition: opt.c:32
TEST_FLAG_MU
#define TEST_FLAG_MU
Definition: opt.c:64
level
uint8_t level
Definition: svq3.c:207
AV_OPT_TYPE_SAMPLE_FMT
Definition: opt.h:235
TestContext::string
char * string
Definition: opt.c:35
AV_OPT_TYPE_DURATION
Definition: opt.h:237
test_get_name
static const char * test_get_name(void *ctx)
Definition: opt.c:95
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1545
options
const OptionDef options[]
Definition: ffmpeg_opt.c:3292
main
int main(void)
Definition: opt.c:111
TEST_FLAG_COOL
#define TEST_FLAG_COOL
Definition: opt.c:62
common.h
common internal and external API header
rational.h
Utilties for rational number calculation.
TestContext
Definition: opt.c:31
AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVRational::den
int den
Denominator.
Definition: rational.h:60
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
TestContext::binary_size
int binary_size
Definition: opt.c:46
AV_OPT_TYPE_RATIONAL
Definition: opt.h:228
TestContext::binary
void * binary
Definition: opt.c:45
TestContext::binary_size1
int binary_size1
Definition: opt.c:48
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:2279
TestContext::binary1
void * binary1
Definition: opt.c:47
TestContext::num
int num
Definition: opt.c:33
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
TestContext::dbl
double dbl
Definition: opt.c:53
Generated on Sun May 13 2018 02:04:09 for FFmpeg by   doxygen 1.8.6

AltStyle によって変換されたページ (->オリジナル) /