LCOV - code coverage report
Current view: top level - src/libavutil/tests - opt.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 87 89 97.8 %
Date: 2017-01-22 02:20:28 Functions: 2 3 66.7 %

          Line data    Source code
       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           0 : static const char *test_get_name(void *ctx)
      96             : {
      97           0 :     return "test";
      98             : }
      99             : 
     100             : static const AVClass test_class = {
     101             :     "TestContext",
     102             :     test_get_name,
     103             :     test_options
     104             : };
     105             : 
     106         595 : static void log_callback_help(void *ptr, int level, const char *fmt, va_list vl)
     107             : {
     108         595 :     vfprintf(stdout, fmt, vl);
     109         595 : }
     110             : 
     111           1 : int main(void)
     112             : {
     113             :     int i;
     114             : 
     115           1 :     av_log_set_level(AV_LOG_DEBUG);
     116           1 :     av_log_set_callback(log_callback_help);
     117             : 
     118           1 :     printf("Testing default values\n");
     119             :     {
     120           1 :         TestContext test_ctx = { 0 };
     121           1 :         test_ctx.class = &test_class;
     122           1 :         av_opt_set_defaults(&test_ctx);
     123             : 
     124           1 :         printf("num=%d\n", test_ctx.num);
     125           1 :         printf("toggle=%d\n", test_ctx.toggle);
     126           1 :         printf("string=%s\n", test_ctx.string);
     127           1 :         printf("escape=%s\n", test_ctx.escape);
     128           1 :         printf("flags=%d\n", test_ctx.flags);
     129           1 :         printf("rational=%d/%d\n", test_ctx.rational.num, test_ctx.rational.den);
     130           1 :         printf("video_rate=%d/%d\n", test_ctx.video_rate.num, test_ctx.video_rate.den);
     131           1 :         printf("width=%d height=%d\n", test_ctx.w, test_ctx.h);
     132           1 :         printf("pix_fmt=%s\n", av_get_pix_fmt_name(test_ctx.pix_fmt));
     133           1 :         printf("sample_fmt=%s\n", av_get_sample_fmt_name(test_ctx.sample_fmt));
     134           1 :         printf("duration=%"PRId64"\n", test_ctx.duration);
     135           1 :         printf("color=%d %d %d %d\n", test_ctx.color[0], test_ctx.color[1], test_ctx.color[2], test_ctx.color[3]);
     136           1 :         printf("channel_layout=%"PRId64"=%"PRId64"\n", test_ctx.channel_layout, (int64_t)AV_CH_LAYOUT_HEXAGONAL);
     137           1 :         if (test_ctx.binary)
     138           1 :             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           1 :         printf("binary_size=%d\n", test_ctx.binary_size);
     140           1 :         printf("num64=%"PRId64"\n", test_ctx.num64);
     141           1 :         printf("flt=%.6f\n", test_ctx.flt);
     142           1 :         printf("dbl=%.6f\n", test_ctx.dbl);
     143             : 
     144           1 :         av_opt_show2(&test_ctx, NULL, -1, 0);
     145             : 
     146           1 :         av_opt_free(&test_ctx);
     147             :     }
     148             : 
     149           1 :     printf("\nTesting av_opt_is_set_to_default()\n");
     150             :     {
     151             :         int ret;
     152           1 :         TestContext test_ctx = { 0 };
     153           1 :         const AVOption *o = NULL;
     154           1 :         test_ctx.class = &test_class;
     155             : 
     156           1 :         av_log_set_level(AV_LOG_QUIET);
     157             : 
     158          27 :         while (o = av_opt_next(&test_ctx, o)) {
     159          25 :             ret = av_opt_is_set_to_default_by_name(&test_ctx, o->name, 0);
     160          25 :             printf("name:%10s default:%d error:%s\n", o->name, !!ret, ret < 0 ? av_err2str(ret) : "");
     161             :         }
     162           1 :         av_opt_set_defaults(&test_ctx);
     163          27 :         while (o = av_opt_next(&test_ctx, o)) {
     164          25 :             ret = av_opt_is_set_to_default_by_name(&test_ctx, o->name, 0);
     165          25 :             printf("name:%10s default:%d error:%s\n", o->name, !!ret, ret < 0 ? av_err2str(ret) : "");
     166             :         }
     167           1 :         av_opt_free(&test_ctx);
     168             :     }
     169             : 
     170           1 :     printf("\nTest av_opt_serialize()\n");
     171             :     {
     172           1 :         TestContext test_ctx = { 0 };
     173             :         char *buf;
     174           1 :         test_ctx.class = &test_class;
     175             : 
     176           1 :         av_log_set_level(AV_LOG_QUIET);
     177             : 
     178           1 :         av_opt_set_defaults(&test_ctx);
     179           1 :         if (av_opt_serialize(&test_ctx, 0, 0, &buf, '=', ',') >= 0) {
     180           1 :             printf("%s\n", buf);
     181           1 :             av_opt_free(&test_ctx);
     182           1 :             memset(&test_ctx, 0, sizeof(test_ctx));
     183           1 :             test_ctx.class = &test_class;
     184           1 :             av_set_options_string(&test_ctx, buf, "=", ",");
     185           1 :             av_free(buf);
     186           1 :             if (av_opt_serialize(&test_ctx, 0, 0, &buf, '=', ',') >= 0) {
     187           1 :                 printf("%s\n", buf);
     188           1 :                 av_free(buf);
     189             :             }
     190             :         }
     191           1 :         av_opt_free(&test_ctx);
     192             :     }
     193             : 
     194           1 :     printf("\nTesting av_set_options_string()\n");
     195             :     {
     196           1 :         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           1 :         test_ctx.class = &test_class;
     262           1 :         av_opt_set_defaults(&test_ctx);
     263             : 
     264           1 :         av_log_set_level(AV_LOG_QUIET);
     265             : 
     266          62 :         for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
     267          61 :             int silence_log = !strcmp(options[i], "rational=-1/0"); // inf formating differs between platforms
     268          61 :             av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
     269          61 :             if (silence_log)
     270           1 :                 av_log_set_callback(NULL);
     271          61 :             if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
     272          32 :                 printf("Error '%s'\n", options[i]);
     273             :             else
     274          29 :                 printf("OK    '%s'\n", options[i]);
     275          61 :             av_log_set_callback(log_callback_help);
     276             :         }
     277           1 :         av_opt_free(&test_ctx);
     278             :     }
     279             : 
     280           1 :     printf("\nTesting av_opt_set_from_string()\n");
     281             :     {
     282           1 :         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           1 :         test_ctx.class = &test_class;
     297           1 :         av_opt_set_defaults(&test_ctx);
     298             : 
     299           1 :         av_log_set_level(AV_LOG_QUIET);
     300             : 
     301          10 :         for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
     302           9 :             av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
     303           9 :             if (av_opt_set_from_string(&test_ctx, options[i], shorthand, "=", ":") < 0)
     304           4 :                 printf("Error '%s'\n", options[i]);
     305             :             else
     306           5 :                 printf("OK    '%s'\n", options[i]);
     307             :         }
     308           1 :         av_opt_free(&test_ctx);
     309             :     }
     310             : 
     311           1 :     return 0;
     312             : }

Generated by: LCOV version 1.12