STATIC mp_uint_t get_arg_vfpreg(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn) { const char *reg_str = get_arg_str(pn); if (reg_str[0] == 's' && reg_str[1] != '\0') { mp_uint_t regno = 0; for (++reg_str; *reg_str; ++reg_str) { mp_uint_t v = *reg_str; if (!('0' <= v && v <= '9')) { goto malformed; } regno = 10 * regno + v - '0'; } if (regno > 31) { emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects at most r%d", op, 31)); return 0; } else { return regno; } } malformed: emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects an FPU register", op)); return 0; }
static void userspace_message_process(const char *modname, int pass, double clock, int cpu, void *args) { const char * str = get_arg_str(args, "message"); if (pass == 1) init_trace(&trace_g, TG_PROCESS, 0.1, TRACE_SYM_F_STRING, "user event"); if (pass == 2) emit_trace(&trace_g, (union ltt_value)"%s", str); }
STATIC mp_uint_t get_arg_special_reg(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn) { const char *reg_str = get_arg_str(pn); for (mp_uint_t i = 0; i < MP_ARRAY_SIZE(special_reg_name_table); i++) { const special_reg_name_t *r = &special_reg_name_table[i]; if (strcmp(r->name, reg_str) == 0) { return r->reg; } } emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects a special register", op)); return 0; }
STATIC mp_uint_t get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn) { const char *reg_str = get_arg_str(pn); for (mp_uint_t i = 0; i < MP_ARRAY_SIZE(reg_name_table); i++) { const reg_name_t *r = ®_name_table[i]; if (reg_str[0] == r->name[0] && reg_str[1] == r->name[1] && reg_str[2] == r->name[2] && (reg_str[2] == '\0' || reg_str[3] == '\0')) { return r->reg; } } emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects a register", op)); return 0; }
static void ardupilot_end_process(const char *modname, int pass, double clock, int cpu, void *args) { const char *name = get_arg_str(args, "name_field"); struct perf_apm *perf = find_or_add_perf(name); if (pass == 1) { init_trace(&perf->trace, TG_APM, 1 + 0.1 * perf->pos, TRACE_SYM_F_BITS, "%s", name); } if (pass == 2) { emit_trace(&perf->trace, (union ltt_value)LT_IDLE); } }
Convert::Convert (const ::VSMap &in, ::VSMap &out, void *user_data_ptr, ::VSCore &core, const ::VSAPI &vsapi) : vsutl::FilterBase (vsapi, "convert", ::fmParallel, 0) , _clip_src_sptr (vsapi.propGetNode (&in, "clip", 0, 0), vsapi) , _vi_in (*_vsapi.getVideoInfo (_clip_src_sptr.get ())) , _vi_out (_vi_in) , _fmtc (*(vsapi.getPluginById (fmtc_PLUGIN_NAME, &core))) , _step_list () , _col_fam (-1) , _mats (fmtcl::ColorSpaceH265_UNSPECIFIED) , _matd (fmtcl::ColorSpaceH265_UNSPECIFIED) , _cplaces (fmtcl::ChromaPlacement_UNDEF) , _cplaced (fmtcl::ChromaPlacement_UNDEF) , _fulls (ConvStep::Range_UNDEF) , _fulld (ConvStep::Range_UNDEF) , _transs (fmtcl::TransCurve_UNDEF) , _transd (fmtcl::TransCurve_UNDEF) , _gcors (get_arg_flt (in, out, "gcors", 1)) , _gcord (get_arg_flt (in, out, "gcord", 1)) { const ::VSFormat & fmt_src = *(_vi_in.format); retrieve_output_colorspace (in, out, core, fmt_src); const ::VSFormat & fmt_dst = *(_vi_out.format); // Range _fulls = retrieve_range (fmt_src, in, out, "fulls"); _fulld = retrieve_range (fmt_dst, in, out, "fulld"); // Chroma placement const std::string cplace_str = get_arg_str (in, out, "cplace", "mpeg2"); if (vsutl::has_chroma (fmt_src)) { const std::string cplacex_str = get_arg_str (in, out, "cplaces", cplace_str); _cplaces = Resample::conv_str_to_chroma_placement (*this, cplacex_str); } if (vsutl::has_chroma (fmt_dst)) { const std::string cplacex_str = get_arg_str (in, out, "cplaced", cplace_str); _cplaced = Resample::conv_str_to_chroma_placement (*this, cplacex_str); } // Matrix presets std::string mat (get_arg_str (in, out, "mat", "")); std::string mats (( fmt_src.colorFamily == ::cmYUV ) ? mat : ""); std::string matd (( fmt_dst.colorFamily == ::cmYUV || fmt_dst.colorFamily == ::cmGray) ? mat : ""); mats = get_arg_str (in, out, "mats", mats); matd = get_arg_str (in, out, "matd", matd); if (! mats.empty () || ! matd.empty ()) { fstb::conv_to_lower_case (mats); fstb::conv_to_lower_case (matd); Matrix::select_def_mat (mats, fmt_src); Matrix::select_def_mat (matd, fmt_dst); _mats = Matrix::find_cs_from_mat_str (*this, mats, true); _matd = Matrix::find_cs_from_mat_str (*this, matd, true); } // Transfer curve _transs = retrieve_tcurve (fmt_src, in, out, "transs", ""); _transd = retrieve_tcurve (fmt_dst, in, out, "transd", ""); /*** To do ***/ find_conversion_steps (in, out); /*** To do ***/ }
fmtcl::TransCurve Convert::retrieve_tcurve (const ::VSFormat &fmt, const ::VSMap &in, ::VSMap &out, const char arg_0 [], const char def_0 []) { fmtcl::TransCurve tcurve = fmtcl::TransCurve_UNDEF; bool curve_flag = false; std::string curve_str = get_arg_str (in, out, arg_0, def_0, 0, &curve_flag); fstb::conv_to_lower_case (curve_str); if (! curve_flag || curve_str.empty ()) { tcurve = fmtcl::TransCurve_UNDEF; } else if (curve_str == "linear") { tcurve = fmtcl::TransCurve_LINEAR; } else if (curve_str == "srgb" || curve_str == "6196621") { tcurve = fmtcl::TransCurve_SRGB; } else if (curve_str == "709") { tcurve = fmtcl::TransCurve_709; } else if (curve_str == "601" || curve_str == "170") { tcurve = fmtcl::TransCurve_601; } else if (curve_str == "470m") { tcurve = fmtcl::TransCurve_470M; } else if (curve_str == "470bg") { tcurve = fmtcl::TransCurve_470BG; } else if (curve_str == "240") { tcurve = fmtcl::TransCurve_240; } else if (curve_str == "2020") { tcurve = fmtcl::TransCurve_2020_12; } else if (curve_str == "log100") { tcurve = fmtcl::TransCurve_LOG100; } else if (curve_str == "log316") { tcurve = fmtcl::TransCurve_LOG316; } else if (curve_str == "6196624") { tcurve = fmtcl::TransCurve_61966_2_4; } else if (curve_str == "1361") { tcurve = fmtcl::TransCurve_1361; } else if (curve_str == "1886") { tcurve = fmtcl::TransCurve_1886; } else if (curve_str == "1886a") { tcurve = fmtcl::TransCurve_1886A; } else { throw_inval_arg ("unexpected string for the transfer curve."); } return (tcurve); }
void Convert::retrieve_output_colorspace (const ::VSMap &in, ::VSMap &out, ::VSCore &core, const ::VSFormat &fmt_src) { const ::VSFormat * fmt_dst_ptr = &fmt_src; // Full colorspace int csp_dst = get_arg_int (in, out, "csp", ::pfNone); if (csp_dst != ::pfNone) { fmt_dst_ptr = _vsapi.getFormatPreset (csp_dst, &core); if (fmt_dst_ptr == 0) { throw_inval_arg ("unknown output colorspace."); } } int col_fam = fmt_dst_ptr->colorFamily; int spl_type = fmt_dst_ptr->sampleType; int bits = fmt_dst_ptr->bitsPerSample; int ssh = fmt_dst_ptr->subSamplingW; int ssv = fmt_dst_ptr->subSamplingH; // Color family _col_fam = get_arg_int (in, out, "col_fam", col_fam); // Chroma subsampling std::string css (get_arg_str (in, out, "css", "")); if (! css.empty ()) { const int ret_val = vsutl::conv_str_to_chroma_subspl (ssh, ssv, css); if (ret_val != 0) { throw_inval_arg ("unsupported css value."); } } // Destination bit depth and sample type bool bits_def_flag = false; bool flt_def_flag = false; int flt = (spl_type != ::stInteger) ? 1 : 0; bits = get_arg_int (in, out, "bits", bits, 0, &bits_def_flag); flt = get_arg_int (in, out, "flt" , flt, 0, &flt_def_flag ); spl_type = (flt != 0) ? ::stFloat : ::stInteger; if (flt_def_flag && ! bits_def_flag) { if (spl_type == ::stFloat) { bits = 32; } else { if (bits > 16) { throw_inval_arg ( "Cannot deduce the output bitdepth. Please specify it." ); } } } else if (bits_def_flag && ! flt_def_flag) { if (bits >= 32) { spl_type = ::stFloat; } else { spl_type = ::stInteger; } } // Combines the modified parameters and validates the format try { fmt_dst_ptr = register_format ( _col_fam, spl_type, bits, ssh, ssv, core ); } catch (std::exception &) { throw; } catch (...) { fmt_dst_ptr = 0; } if (fmt_dst_ptr == 0) { throw_rt_err ( "couldn\'t get a pixel format identifier for the output clip." ); } _vi_out.format = fmt_dst_ptr; }
Matrix::Matrix (const ::VSMap &in, ::VSMap &out, void * /*user_data_ptr*/, ::VSCore &core, const ::VSAPI &vsapi) : vsutl::FilterBase (vsapi, "matrix", ::fmParallel, 0) , _clip_src_sptr (vsapi.propGetNode (&in, "clip", 0, 0), vsapi) , _vi_in (*_vsapi.getVideoInfo (_clip_src_sptr.get ())) , _vi_out (_vi_in) , _sse_flag (false) , _sse2_flag (false) , _avx_flag (false) , _avx2_flag (false) , _range_set_src_flag (false) , _range_set_dst_flag (false) , _full_range_src_flag (false) , _full_range_dst_flag (false) /*, _mat_main ()*/ , _csp_out (fmtcl::ColorSpaceH265_UNSPECIFIED) , _plane_out (get_arg_int (in, out, "singleout", -1)) , _proc_uptr () { assert (&in != 0); assert (&out != 0); assert (&core != 0); assert (&vsapi != 0); vsutl::CpuOpt cpu_opt (*this, in, out); _sse_flag = cpu_opt.has_sse (); _sse2_flag = cpu_opt.has_sse2 (); _avx_flag = cpu_opt.has_avx (); _avx2_flag = cpu_opt.has_avx2 (); _proc_uptr = std::unique_ptr <fmtcl::MatrixProc> (new fmtcl::MatrixProc ( _sse_flag, _sse2_flag, _avx_flag, _avx2_flag )); // Checks the input clip if (_vi_in.format == 0) { throw_inval_arg ("only constant pixel formats are supported."); } const ::VSFormat & fmt_src = *_vi_in.format; if (fmt_src.subSamplingW != 0 || fmt_src.subSamplingH != 0) { throw_inval_arg ("input must be 4:4:4."); } if (fmt_src.numPlanes != NBR_PLANES) { throw_inval_arg ("greyscale format not supported as input."); } if ( ( fmt_src.sampleType == ::stInteger && ( fmt_src.bitsPerSample < 8 || fmt_src.bitsPerSample > 12) && fmt_src.bitsPerSample != 16) || ( fmt_src.sampleType == ::stFloat && fmt_src.bitsPerSample != 32)) { throw_inval_arg ("pixel bitdepth not supported."); } if (_plane_out >= NBR_PLANES) { throw_inval_arg ( "singleout is a plane index and must be -1 or ranging from 0 to 3." ); } // Destination colorspace bool force_col_fam_flag; const ::VSFormat * fmt_dst_ptr = get_output_colorspace ( in, out, core, fmt_src, _plane_out, force_col_fam_flag ); if ( fmt_dst_ptr->colorFamily != ::cmGray && fmt_dst_ptr->colorFamily != ::cmRGB && fmt_dst_ptr->colorFamily != ::cmYUV && fmt_dst_ptr->colorFamily != ::cmYCoCg) { throw_inval_arg ("unsupported color family for output."); } if ( ( fmt_dst_ptr->sampleType == ::stInteger && ( fmt_dst_ptr->bitsPerSample < 8 || fmt_dst_ptr->bitsPerSample > 12) && fmt_dst_ptr->bitsPerSample != 16) || ( fmt_dst_ptr->sampleType == ::stFloat && fmt_dst_ptr->bitsPerSample != 32)) { throw_inval_arg ("output bitdepth not supported."); } if ( fmt_dst_ptr->sampleType != fmt_src.sampleType || fmt_dst_ptr->bitsPerSample < fmt_src.bitsPerSample || fmt_dst_ptr->subSamplingW != fmt_src.subSamplingW || fmt_dst_ptr->subSamplingH != fmt_src.subSamplingH) { throw_inval_arg ( "specified output colorspace is not compatible with the input." ); } // Preliminary matrix test: deduce the target color family if unspecified if ( ! force_col_fam_flag && fmt_dst_ptr->colorFamily != ::cmGray) { int def_count = 0; def_count += is_arg_defined (in, "mat" ) ? 1 : 0; def_count += is_arg_defined (in, "mats") ? 1 : 0; def_count += is_arg_defined (in, "matd") ? 1 : 0; if (def_count == 1) { std::string tmp_mat (get_arg_str (in, out, "mat", "")); tmp_mat = get_arg_str (in, out, "mats", tmp_mat); tmp_mat = get_arg_str (in, out, "matd", tmp_mat); fmtcl::ColorSpaceH265 tmp_csp = find_cs_from_mat_str (*this, tmp_mat, false); fmt_dst_ptr = find_dst_col_fam (tmp_csp, fmt_dst_ptr, fmt_src, core); } } // Output format is validated. _vi_out.format = fmt_dst_ptr; const ::VSFormat &fmt_dst = *fmt_dst_ptr; const int nbr_expected_coef = NBR_PLANES * (NBR_PLANES + 1); bool mat_init_flag = false; // Matrix presets std::string mat (get_arg_str (in, out, "mat", "")); std::string mats (( fmt_src.colorFamily == ::cmYUV ) ? mat : ""); std::string matd (( fmt_dst.colorFamily == ::cmYUV || fmt_dst.colorFamily == ::cmGray) ? mat : ""); mats = get_arg_str (in, out, "mats", mats); matd = get_arg_str (in, out, "matd", matd); if (! mats.empty () || ! matd.empty ()) { fstb::conv_to_lower_case (mats); fstb::conv_to_lower_case (matd); select_def_mat (mats, fmt_src); select_def_mat (matd, fmt_dst); fmtcl::Mat4 m2s; fmtcl::Mat4 m2d; make_mat_from_str (m2s, mats, true); make_mat_from_str (m2d, matd, false); _csp_out = find_cs_from_mat_str (*this, matd, false); _mat_main = m2d * m2s; mat_init_flag = true; } // Range _full_range_src_flag = (get_arg_int ( in, out, "fulls" , vsutl::is_full_range_default (fmt_src) ? 1 : 0, 0, &_range_set_src_flag ) != 0); _full_range_dst_flag = (get_arg_int ( in, out, "fulld", vsutl::is_full_range_default (fmt_dst) ? 1 : 0, 0, &_range_set_dst_flag ) != 0); // Custom coefficients const int nbr_coef = _vsapi.propNumElements (&in, "coef"); const bool custom_mat_flag = (nbr_coef > 0); if (custom_mat_flag) { if (nbr_coef != nbr_expected_coef) { throw_inval_arg ("coef has a wrong number of elements."); } for (int y = 0; y < NBR_PLANES + 1; ++y) { for (int x = 0; x < NBR_PLANES + 1; ++x) { _mat_main [y] [x] = (x == y) ? 1 : 0; if ( (x < fmt_src.numPlanes || x == NBR_PLANES) && y < fmt_dst.numPlanes) { int err = 0; const int index = y * (fmt_src.numPlanes + 1) + x; const double c = _vsapi.propGetFloat (&in, "coef", index, &err); if (err != 0) { throw_rt_err ("error while reading the matrix coefficients."); } _mat_main [y] [x] = c; } } } mat_init_flag = true; } if (! mat_init_flag) { throw_inval_arg ( "you must specify a matrix preset or a custom coefficient list." ); } prepare_coef (fmt_dst, fmt_src); if (_vsapi.getError (&out) != 0) { throw -1; } }
Transfer::Transfer (const ::VSMap &in, ::VSMap &out, void * /*user_data_ptr*/, ::VSCore &core, const ::VSAPI &vsapi) : vsutl::FilterBase (vsapi, "transfer", ::fmParallel, 0) , _clip_src_sptr (vsapi.propGetNode (&in, "clip", 0, 0), vsapi) , _vi_in (*_vsapi.getVideoInfo (_clip_src_sptr.get ())) , _vi_out (_vi_in) , _sse2_flag (false) , _avx2_flag (false) , _transs (get_arg_str (in, out, "transs", "")) , _transd (get_arg_str (in, out, "transd", "")) , _contrast (get_arg_flt (in, out, "cont", 1)) , _gcor (get_arg_flt (in, out, "gcor", 1)) , _lvl_black (get_arg_flt (in, out, "blacklvl", 0)) , _full_range_src_flag (get_arg_int (in, out, "fulls", 1) != 0) , _full_range_dst_flag (get_arg_int (in, out, "fulld", 1) != 0) , _curve_s (fmtcl::TransCurve_UNDEF) , _curve_d (fmtcl::TransCurve_UNDEF) , _loglut_flag (false) , _plane_processor (vsapi, *this, "transfer", true) , _lut_uptr () { assert (&in != 0); assert (&out != 0); assert (&core != 0); assert (&vsapi != 0); fstb::conv_to_lower_case (_transs); fstb::conv_to_lower_case (_transd); vsutl::CpuOpt cpu_opt (*this, in, out); _sse2_flag = cpu_opt.has_sse2 (); _avx2_flag = cpu_opt.has_avx2 (); // Checks the input clip if (_vi_in.format == 0) { throw_inval_arg ("only constant pixel formats are supported."); } const ::VSFormat & fmt_src = *_vi_in.format; if ( fmt_src.colorFamily != ::cmGray && fmt_src.colorFamily != ::cmRGB) { throw_inval_arg ("unsupported color family."); } if ( ( fmt_src.sampleType == ::stInteger && ( fmt_src.bitsPerSample < 8 || fmt_src.bitsPerSample > 16)) || ( fmt_src.sampleType == ::stFloat && fmt_src.bitsPerSample != 32)) { throw_inval_arg ("pixel bitdepth not supported."); } // Destination colorspace const ::VSFormat& fmt_dst = get_output_colorspace (in, out, core, fmt_src); if ( ( fmt_dst.sampleType == ::stInteger && fmt_dst.bitsPerSample != 16) || ( fmt_dst.sampleType == ::stFloat && fmt_dst.bitsPerSample != 32)) { throw_inval_arg ("output bitdepth not supported."); } // Output format is validated. _vi_out.format = &fmt_dst; init_table (); }