x264中Parse函数欣赏

最新推荐文章于 2023-09-10 11:37:23 发布
最新推荐文章于 2023-09-10 11:37:23 发布
阅读量8.5k 收藏 6
点赞数 2
分类专栏： S1: C/C++ s6: 视频研究
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stpeace/article/details/8287227
版权

      我们知道，在x264中，x264_param_default函数对一些参数值进行了设定，现在用户如果需要改变这些默认的参数值，就可以通过命令行配置来修改，具体就是传到argv[i]中去.

     下面来看看Parse函数:

    /* Parse command line */
    if( Parse( argc, argv, ¶m, &opt ) < 0 )
        return -1;

 

static int  Parse( int argc, char **argv,
                   x264_param_t *param, cli_opt_t *opt )
{
    char *psz_filename = NULL;
    x264_param_t defaults = *param;
    char *psz;
    int b_avis = 0;
    int b_y4m = 0;
    int b_thread_input = 0;

    memset( opt, 0, sizeof(cli_opt_t) );

    /* Default input file driver */
    p_open_infile = open_file_yuv;
    p_get_frame_total = get_frame_total_yuv;
    p_read_frame = read_frame_yuv;
    p_close_infile = close_file_yuv;

    /* Default output file driver */
    p_open_outfile = open_file_bsf;
    p_set_outfile_param = set_param_bsf;
    p_write_nalu = write_nalu_bsf;
    p_set_eop = set_eop_bsf;
    p_close_outfile = close_file_bsf;

    /* Parse command line options */
    for( ;; )
    {
        int b_error = 0;
        int long_options_index = -1;

#define OPT_FRAMES 256
#define OPT_SEEK 257
#define OPT_QPFILE 258
#define OPT_THREAD_INPUT 259
#define OPT_QUIET 260
#define OPT_PROGRESS 261
#define OPT_VISUALIZE 262
#define OPT_LONGHELP 263

        static struct option long_options[] =
        {
            { "help",    no_argument,       NULL, 'h' },
            { "longhelp",no_argument,       NULL, OPT_LONGHELP },
            { "version", no_argument,       NULL, 'V' },
            { "bitrate", required_argument, NULL, 'B' },
            { "bframes", required_argument, NULL, 'b' },
            { "no-b-adapt", no_argument,    NULL, 0 },
            { "b-bias",  required_argument, NULL, 0 },
            { "b-pyramid", no_argument,     NULL, 0 },
            { "min-keyint",required_argument,NULL,'i' },
            { "keyint",  required_argument, NULL, 'I' },
            { "scenecut",required_argument, NULL, 0 },
            { "nf",      no_argument,       NULL, 0 },
            { "filter",  required_argument, NULL, 'f' },
            { "no-cabac",no_argument,       NULL, 0 },
            { "qp",      required_argument, NULL, 'q' },
            { "qpmin",   required_argument, NULL, 0 },
            { "qpmax",   required_argument, NULL, 0 },
            { "qpstep",  required_argument, NULL, 0 },
            { "crf",     required_argument, NULL, 0 },
            { "ref",     required_argument, NULL, 'r' },
            { "no-asm",  no_argument,       NULL, 0 },
            { "sar",     required_argument, NULL, 0 },
            { "fps",     required_argument, NULL, 0 },
            { "frames",  required_argument, NULL, OPT_FRAMES },
            { "seek",    required_argument, NULL, OPT_SEEK },
            { "output",  required_argument, NULL, 'o' },
            { "analyse", required_argument, NULL, 'A' },
            { "direct",  required_argument, NULL, 0 },
            { "weightb", no_argument,       NULL, 'w' },
            { "me",      required_argument, NULL, 0 },
            { "merange", required_argument, NULL, 0 },
            { "subme",   required_argument, NULL, 'm' },
            { "b-rdo",   no_argument,       NULL, 0 },
            { "mixed-refs", no_argument,    NULL, 0 },
            { "no-chroma-me", no_argument,  NULL, 0 },
            { "bime",    no_argument,       NULL, 0 },
            { "8x8dct",  no_argument,       NULL, '8' },
            { "trellis", required_argument, NULL, 't' },
            { "no-fast-pskip", no_argument, NULL, 0 },
            { "no-dct-decimate", no_argument, NULL, 0 },
            { "level",   required_argument, NULL, 0 },
            { "ratetol", required_argument, NULL, 0 },
            { "vbv-maxrate", required_argument, NULL, 0 },
            { "vbv-bufsize", required_argument, NULL, 0 },
            { "vbv-init", required_argument,NULL,  0 },
            { "ipratio", required_argument, NULL, 0 },
            { "pbratio", required_argument, NULL, 0 },
            { "chroma-qp-offset", required_argument, NULL, 0 },
            { "pass",    required_argument, NULL, 'p' },
            { "stats",   required_argument, NULL, 0 },
            { "rceq",    required_argument, NULL, 0 },
            { "qcomp",   required_argument, NULL, 0 },
            { "qblur",   required_argument, NULL, 0 },
            { "cplxblur",required_argument, NULL, 0 },
            { "zones",   required_argument, NULL, 0 },
            { "qpfile",  required_argument, NULL, OPT_QPFILE },
            { "threads", required_argument, NULL, 0 },
            { "thread-input", no_argument,  NULL, OPT_THREAD_INPUT },
            { "no-psnr", no_argument,       NULL, 0 },
            { "quiet",   no_argument,       NULL, OPT_QUIET },
            { "verbose", no_argument,       NULL, 'v' },
            { "progress",no_argument,       NULL, OPT_PROGRESS },
            { "visualize",no_argument,      NULL, OPT_VISUALIZE },
            { "sps-id",  required_argument, NULL, 0 },
            { "aud",     no_argument,       NULL, 0 },
            { "nr",      required_argument, NULL, 0 },
            { "cqm",     required_argument, NULL, 0 },
            { "cqmfile", required_argument, NULL, 0 },
            { "cqm4",    required_argument, NULL, 0 },
            { "cqm4i",   required_argument, NULL, 0 },
            { "cqm4iy",  required_argument, NULL, 0 },
            { "cqm4ic",  required_argument, NULL, 0 },
            { "cqm4p",   required_argument, NULL, 0 },
            { "cqm4py",  required_argument, NULL, 0 },
            { "cqm4pc",  required_argument, NULL, 0 },
            { "cqm8",    required_argument, NULL, 0 },
            { "cqm8i",   required_argument, NULL, 0 },
            { "cqm8p",   required_argument, NULL, 0 },
            { "overscan", required_argument, NULL, 0 },
            { "videoformat", required_argument, NULL, 0 },
            { "fullrange", required_argument, NULL, 0 },
            { "colorprim", required_argument, NULL, 0 },
            { "transfer", required_argument, NULL, 0 },
            { "colormatrix", required_argument, NULL, 0 },
            { "chromaloc", required_argument, NULL, 0 },
            {0, 0, 0, 0}
        };

        int c = getopt_long( argc, argv, "8A:B:b:f:hI:i:m:o:p:q:r:t:Vvw",
                             long_options, &long_options_index);

        if( c == -1 )
        {
            break;
        }

        switch( c )
        {
            case 'h':
                Help( &defaults, 0 );
                exit(0);
            case OPT_LONGHELP:
                Help( &defaults, 1 );
                exit(0);
            case 'V':
#ifdef X264_POINTVER
                printf( "x264 "X264_POINTVER"\n" );
#else
                printf( "x264 0.%d.X\n", X264_BUILD );
#endif
                exit(0);
            case OPT_FRAMES:
                param->i_frame_total = atoi( optarg );
                break;
            case OPT_SEEK:
                opt->i_seek = atoi( optarg );
                break;
            case 'o':
                if( !strncasecmp(optarg + strlen(optarg) - 4, ".mp4", 4) )
                {
#ifdef MP4_OUTPUT
                    p_open_outfile = open_file_mp4;
                    p_write_nalu = write_nalu_mp4;
                    p_set_outfile_param = set_param_mp4;
                    p_set_eop = set_eop_mp4;
                    p_close_outfile = close_file_mp4;
#else
                    fprintf( stderr, "x264 [error]: not compiled with MP4 output support\n" );
                    return -1;
#endif
                }
                else if( !strncasecmp(optarg + strlen(optarg) - 4, ".mkv", 4) )
                {
                    p_open_outfile = open_file_mkv;
                    p_write_nalu = write_nalu_mkv;
                    p_set_outfile_param = set_param_mkv;
                    p_set_eop = set_eop_mkv;
                    p_close_outfile = close_file_mkv;
                }
                if( !strcmp(optarg, "-") )
                    opt->hout = stdout;
                else if( p_open_outfile( optarg, &opt->hout ) )
                {
                    fprintf( stderr, "x264 [error]: can't open output file `%s'\n", optarg );
                    return -1;
                }
                break;
            case OPT_QPFILE:
                opt->qpfile = fopen( optarg, "r" );
                if( !opt->qpfile )
                {
                    fprintf( stderr, "x264 [error]: can't open `%s'\n", optarg );
                    return -1;
                }
                param->i_scenecut_threshold = -1;
                param->b_bframe_adaptive = 0;
                break;
            case OPT_THREAD_INPUT:
                b_thread_input = 1;
                break;
            case OPT_QUIET:
                param->i_log_level = X264_LOG_NONE;
                param->analyse.b_psnr = 0;
                break;
            case 'v':
                param->i_log_level = X264_LOG_DEBUG;
                break;
            case OPT_PROGRESS:
                opt->b_progress = 1;
                break;
            case OPT_VISUALIZE:
#ifdef VISUALIZE
                param->b_visualize = 1;
                b_exit_on_ctrl_c = 1;
#else
                fprintf( stderr, "x264 [warning]: not compiled with visualization support\n" );
#endif
                break;
            default:
            {
                int i;
                if( long_options_index < 0 )
                {
                    for( i = 0; long_options[i].name; i++ )
                        if( long_options[i].val == c )
                        {
                            long_options_index = i;
                            break;
                        }
                    if( long_options_index < 0 )
                    {
                        /* getopt_long already printed an error message */
                        return -1;
                    }
                }

                b_error |= x264_param_parse( param, long_options[long_options_index].name, optarg ? optarg : "true" );
            }
        }

        if( b_error )
        {
            const char *name = long_options_index > 0 ? long_options[long_options_index].name : argv[optind-2];
            fprintf( stderr, "x264 [error]: invalid argument: %s = %s\n", name, optarg );
            return -1;
        }
    }

    /* Get the file name */
    if( optind > argc - 1 || !opt->hout )
    {
        fprintf( stderr, "x264 [error]: No %s file. Run x264 --help for a list of options.\n",
                 optind > argc - 1 ? "input" : "output" );
        return -1;
    }
    psz_filename = argv[optind++];

    /* check demuxer type */
    psz = psz_filename + strlen(psz_filename) - 1;
    while( psz > psz_filename && *psz != '.' )
        psz--;
    if( !strncasecmp( psz, ".avi", 4 ) || !strncasecmp( psz, ".avs", 4 ) )
        b_avis = 1;
    if( !strncasecmp( psz, ".y4m", 4 ) )
        b_y4m = 1;

    if( !(b_avis || b_y4m) ) // raw yuv
    {
        if( optind > argc - 1 )
        {
            /* try to parse the file name */
            for( psz = psz_filename; *psz; psz++ )
            {
                if( *psz >= '0' && *psz <= '9'
                    && sscanf( psz, "%ux%u", ¶m->i_width, ¶m->i_height ) == 2 )
                {
                    if( param->i_log_level >= X264_LOG_INFO )
                        fprintf( stderr, "x264 [info]: file name gives %dx%d\n", param->i_width, param->i_height );
                    break;
                }
            }
        }
        else
        {
            sscanf( argv[optind++], "%ux%u", ¶m->i_width, ¶m->i_height );
        }
    }
        
    if( !(b_avis || b_y4m) && ( !param->i_width || !param->i_height ) )
    {
        fprintf( stderr, "x264 [error]: Rawyuv input requires a resolution.\n" );
        return -1;
    }

    /* open the input */
    {
        if( b_avis )
        {
#ifdef AVIS_INPUT
            p_open_infile = open_file_avis;
            p_get_frame_total = get_frame_total_avis;
            p_read_frame = read_frame_avis;
            p_close_infile = close_file_avis;
#else
            fprintf( stderr, "x264 [error]: not compiled with AVIS input support\n" );
            return -1;
#endif
        }
        if ( b_y4m )
        {
            p_open_infile = open_file_y4m;
            p_get_frame_total = get_frame_total_y4m;
            p_read_frame = read_frame_y4m;
            p_close_infile = close_file_y4m;
        }

        if( p_open_infile( psz_filename, &opt->hin, param ) )
        {
            fprintf( stderr, "x264 [error]: could not open input file '%s'\n", psz_filename );
            return -1;
        }
    }

#ifdef HAVE_PTHREAD
    if( b_thread_input || param->i_threads > 1 )
    {
        if( open_file_thread( NULL, &opt->hin, param ) )
        {
            fprintf( stderr, "x264 [warning]: threaded input failed\n" );
        }
        else
        {
            p_open_infile = open_file_thread;
            p_get_frame_total = get_frame_total_thread;
            p_read_frame = read_frame_thread;
            p_close_infile = close_file_thread;
        }
    }
#endif

    return 0;
}


       可见， Parse函数实际上实现了来对命令行的解析. 如果要配置出自己想要的参数值，那么，Parse函数是必须搞清楚的.

 

涛歌依旧
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
爬虫(2)urllib和parse库的介绍和常用函数介绍和使用
小白的程序猿
04-11 867
urllib库含有的网络请求的使用,以及怎么爬取网站上的图片到本地,对url地址的拆分这里也有,总之内容多多.....
python命令行解析之parse_known_args(）函数和parse_args()
热门推荐
mameng1的博客
01-13 3万+
在python中，命令行解析的很好用， 首先导入命令行解析模块 import argparse import sys 然后创建对象 parse=argparse.ArgumentParser() 然后增加命令行 parse.add_argument("--learning_rate",type=float,default=0.01,help="initial learining ra
x264代码剖析（三）：主函数main()、解析函数parse()与编码函数encode()
weixin_33913332的博客
03-07 159
x264代码剖析（三）：主函数main()、解析函数parse()与编码函数encode() x264的入口函数为main()。main()函数首先调用parse()解析输入的参数，然后调用encode()编码YUV数据。parse()首先调用x264_param_default()为保存参数的x264_param_t...
h264_parse.7z
05-28
描述中的"**h264_parse**"可能是一个解析H264码流的代码库，它可以帮助我们理解如何逐个处理这些NAL单元。解析过程中，我们首先要识别NAL单元，然后根据NAL单元类型解析其包含的信息。NAL单元类型有多种，如IDR帧...
浅谈JSON中stringify 函数、toJosn函数和parse函数
10-24
主要介绍了浅谈JSON中stringify 函数、toJosn函数和parse函数,需要的朋友可以参考下
x264学习笔记
08-19
x264提供了丰富的API供开发者使用，以下是一些常用的API函数： - **x264_param_default()**：设置参数集的默认值。 - **x264_picture_alloc() 和 x264_picture_clean()**：分别为图像结构体分配和释放内存。 - **x...
JavaScript 中 JSON.parse 函数 和 JSON.stringify 函数
10-17
主要介绍了JavaScript -- JSON.parse 函数 和 JSON.stringify 函数,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
PHP中可以自动分割查询字符的Parse_str函数使用示例
10-25
主要介绍了PHP中可以自动分割查询字符的Parse_str函数使用示例,小编也没见过的一个函数,这下分割URL中的查询字符串就方便了,需要的朋友可以参考下
x264中的 x264_param_default函数欣赏
认知 行动 坚持
12-12 9419
先看一个简单的程序： #include using namespace std; void set(int *p) { *p = 0; } int main() { int variable; set(&variable); cout << variable << endl; return 0; } 下面来看看x264中x26
parse函数（vue源码分析4）
weixin_39818813的博客
07-05 1067
parse函数（vue源码分析4） theme: juejin highlight: arduino-light 以下代码和分析过程需要结合vue.js源码查看，通过打断点逐一比对。 1. 执行流程 我们先梳理下执行流程： // 执行1 (末尾的mount) Vue.prototype.$mount = function ( el, hydrating ) { var ref = compileToFunctions( /
c# Parse()方法
qq_43511299的博客
09-26 1万+
Parse()方法用于将任意字符串转换成任意类型 要求等式左右两边的类型要匹配 例一： 将字符串类型转换为布尔类型 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Diagnostics; namespace ConsoleApp4 { class Program {
c语言中的parse函数,C语言解释器Parser剖析器——笔记与心得
weixin_36468140的博客
05-20 2953
THE LITTLE C INTERPRETER表达式剖析器(THE EXPRESSION PARSER)读取和分析表达式的这部分代码叫做表达式剖析器。毫无疑问，表达式剖析器是C解释器中单一的最重要的部分。因为C语言定义表达式的方式比其他语言更加粗鄙，所以用大量的代码组成的C源文件来实现表达式剖析器。有几种不同的方式来设计C的表达式剖析器。许多商业的编译器用一种由parser-generator创...
parse()用法
songyh19的博客
11-03 2万+
1.parse()是SimpleDateFomat里面的方法 parseInt()或parsefloat()顾名思义 比如说parseInt()就是把String类型转化为int类型。 如 String a= “123”; int b = Integer.parseInt(a); 这样b就等于123了。 string 强转date类型 //获取当前系统时间 SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat(“YYYY-MM-dd HH:mm:
C#程序设计--Parse函数的用法
weixin_41883890的博客
05-19 9151
本文讲解C#程序设计中Parse函数的用法。 操作流程 1.1. Parse函数介绍 C# Parse 方法用于将字符串类型转换成任意类型，具体的语法形式如下。 数据类型 变量 = 数据类型.Parse(字符串类型的值); 这里要求等号左、右两边的数据类型兼容。 int num1 = int.Parse(Console.ReadLine()); int num2 = int.Parse(Console.ReadLine()); int num3 = int.Parse(Console.ReadLin
R：parse函数和eval函数解析字符串为命令并运行
志浩同学的博客
07-04 4295
文章目录例子1例子2例子3：回归函数lm中例子4：绘图函数ggplot中 parse函数解析字符串为表达式；eval函数执行表达式输出结果；parse函数和eval函数在自定义函数中常常非常有用 library(ggplot2) rm(list = ls()) 例子1 b为字符换：“character” b <- " for (i in 1:5) { print(i) } " class(b) # [1] "character" parse函数将b转化为表达式：“expression” par
Parse 简介
coderock
01-22 1万+
导言 提到Rebol语言的优秀特性那就不得不说它的解析引擎，简称Parse。这项来自Carl Sassenrath的伟大设计，在过去的15年里，使得Rebol用户免受正则表达式（以不可维护著称）的折磨。现如今，Parse的增强版本在Red语言中重装上阵。 简而言之，Parse是一个使用语法规则来解析输入序列的内部DSL（在Rebol生态圈称为“方言”）。Parse方言是TDPL家族的突出一员。
parse学习+函数传值+实例
最新发布
QiFeng360的博客
09-10 164
【代码】parse学习。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值