static void uninit(struct vo *vo)
{
struct vo_priv *p = vo->priv;
pthread_mutex_lock(&p->ctx->lock);
mp_image_unrefp(&p->ctx->next_frame);
mp_image_unrefp(&p->ctx->waiting_frame);
p->ctx->img_params = (struct mp_image_params){0};
p->ctx->reconfigured = true;
p->ctx->active = NULL;
pthread_mutex_unlock(&p->ctx->lock);
}
static int preinit(struct vo *vo)
{
struct vo_priv *p = vo->priv;
p->vo = vo;
p->ctx = vo->extra.opengl_cb_context;
if (!p->ctx) {
MP_FATAL(vo, "No context set.\n");
return -1;
}
pthread_mutex_lock(&p->ctx->lock);
if (!p->ctx->initialized) {
MP_FATAL(vo, "OpenGL context not initialized.\n");
pthread_mutex_unlock(&p->ctx->lock);
return -1;
}
p->ctx->active = vo;
p->ctx->reconfigured = true;
assert(vo->osd == p->ctx->osd);
copy_vo_opts(vo);
pthread_mutex_unlock(&p->ctx->lock);
return 0;
}
#define OPT_BASE_STRUCT struct vo_priv
static const struct m_option options[] = {
OPT_FLAG("debug", use_gl_debug, 0),
OPT_SUBSTRUCT("", renderer_opts, gl_video_conf, 0),
{0},
};
const struct vo_driver video_out_opengl_cb = {
.description = "OpenGL Callbacks for libmpv",
.name = "opengl-cb",
.caps = VO_CAP_ROTATE90,
.preinit = preinit,
.query_format = query_format,
.reconfig = reconfig,
.control = control,
.draw_image = draw_image,
.flip_page = flip_page,
.uninit = uninit,
.priv_size = sizeof(struct vo_priv),
.options = options,
};
int
sshauthopt_deserialise(struct sshbuf *m, struct sshauthopt **optsp)
{
struct sshauthopt *opts = NULL;
int r = SSH_ERR_INTERNAL_ERROR;
u_char f;
u_int tmp;
if ((opts = calloc(1, sizeof(*opts))) == NULL)
return SSH_ERR_ALLOC_FAIL;
#define OPT_FLAG(x) \
do { \
if ((r = sshbuf_get_u8(m, &f)) != 0) \
goto out; \
opts->x = f; \
} while (0)
OPT_FLAG(permit_port_forwarding_flag);
OPT_FLAG(permit_agent_forwarding_flag);
OPT_FLAG(permit_x11_forwarding_flag);
OPT_FLAG(permit_pty_flag);
OPT_FLAG(permit_user_rc);
OPT_FLAG(restricted);
OPT_FLAG(cert_authority);
#undef OPT_FLAG
if ((r = sshbuf_get_u64(m, &opts->valid_before)) != 0)
goto out;
/* tunnel number can be negative to indicate "unset" */
if ((r = sshbuf_get_u8(m, &f)) != 0 ||
(r = sshbuf_get_u32(m, &tmp)) != 0)
goto out;
opts->force_tun_device = f ? -1 : (int)tmp;
/* String options may be NULL */
if ((r = deserialise_nullable_string(m, &opts->cert_principals)) != 0 ||
(r = deserialise_nullable_string(m, &opts->force_command)) != 0 ||
(r = deserialise_nullable_string(m,
&opts->required_from_host_cert)) != 0 ||
(r = deserialise_nullable_string(m,
&opts->required_from_host_keys)) != 0)
goto out;
/* Array options */
if ((r = deserialise_array(m, &opts->env, &opts->nenv)) != 0 ||
(r = deserialise_array(m,
&opts->permitopen, &opts->npermitopen)) != 0)
goto out;
/* success */
r = 0;
*optsp = opts;
opts = NULL;
out:
sshauthopt_free(opts);
return r;
}
static void uninit(struct vo *vo)
{
struct vo_priv *p = vo->priv;
pthread_mutex_lock(&p->ctx->lock);
forget_frames(p->ctx, true);
p->ctx->img_params = (struct mp_image_params){0};
p->ctx->reconfigured = true;
p->ctx->active = NULL;
update(p);
pthread_mutex_unlock(&p->ctx->lock);
}
static int preinit(struct vo *vo)
{
struct vo_priv *p = vo->priv;
p->vo = vo;
p->ctx = vo->extra.opengl_cb_context;
if (!p->ctx) {
MP_FATAL(vo, "No context set.\n");
return -1;
}
pthread_mutex_lock(&p->ctx->lock);
if (!p->ctx->initialized) {
MP_FATAL(vo, "OpenGL context not initialized.\n");
pthread_mutex_unlock(&p->ctx->lock);
return -1;
}
p->ctx->active = vo;
p->ctx->reconfigured = true;
p->ctx->update_new_opts = true;
copy_vo_opts(vo);
pthread_mutex_unlock(&p->ctx->lock);
return 0;
}
#define OPT_BASE_STRUCT struct vo_priv
static const struct m_option options[] = {
OPT_FLAG("debug", use_gl_debug, 0),
OPT_INTRANGE("frame-queue-size", frame_queue_size, 0, 1, 100, OPTDEF_INT(2)),
OPT_CHOICE("frame-drop-mode", frame_drop_mode, 0,
({"pop", FRAME_DROP_POP},
{"clear", FRAME_DROP_CLEAR},
static int recreate_video_proc(struct vf_instance *vf)
{
struct vf_priv_s *p = vf->priv;
HRESULT hr;
destroy_video_proc(vf);
D3D11_VIDEO_PROCESSOR_CONTENT_DESC vpdesc = {
.InputFrameFormat = p->d3d_frame_format,
.InputWidth = p->c_w,
.InputHeight = p->c_h,
.OutputWidth = p->params.w,
.OutputHeight = p->params.h,
};
hr = ID3D11VideoDevice_CreateVideoProcessorEnumerator(p->video_dev, &vpdesc,
&p->vp_enum);
if (FAILED(hr))
goto fail;
D3D11_VIDEO_PROCESSOR_CAPS caps;
hr = ID3D11VideoProcessorEnumerator_GetVideoProcessorCaps(p->vp_enum, &caps);
if (FAILED(hr))
goto fail;
MP_VERBOSE(vf, "Found %d rate conversion caps. Looking for caps=0x%x.\n",
(int)caps.RateConversionCapsCount, p->mode);
int rindex = -1;
for (int n = 0; n < caps.RateConversionCapsCount; n++) {
D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS rcaps;
hr = ID3D11VideoProcessorEnumerator_GetVideoProcessorRateConversionCaps
(p->vp_enum, n, &rcaps);
if (FAILED(hr))
goto fail;
MP_VERBOSE(vf, " - %d: 0x%08x\n", n, (unsigned)rcaps.ProcessorCaps);
if (rcaps.ProcessorCaps & p->mode) {
MP_VERBOSE(vf, " (matching)\n");
if (rindex < 0)
rindex = n;
}
}
if (rindex < 0) {
MP_WARN(vf, "No fitting video processor found, picking #0.\n");
rindex = 0;
}
// TOOD: so, how do we select which rate conversion mode the processor uses?
hr = ID3D11VideoDevice_CreateVideoProcessor(p->video_dev, p->vp_enum, rindex,
&p->video_proc);
if (FAILED(hr)) {
MP_ERR(vf, "Failed to create D3D11 video processor.\n");
goto fail;
}
// Note: libavcodec does not support cropping left/top with hwaccel.
RECT src_rc = {
.right = p->params.w,
.bottom = p->params.h,
};
ID3D11VideoContext_VideoProcessorSetStreamSourceRect(p->video_ctx,
p->video_proc,
0, TRUE, &src_rc);
// This is supposed to stop drivers from f*****g up the video quality.
ID3D11VideoContext_VideoProcessorSetStreamAutoProcessingMode(p->video_ctx,
p->video_proc,
0, FALSE);
ID3D11VideoContext_VideoProcessorSetStreamOutputRate(p->video_ctx,
p->video_proc,
0,
D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_NORMAL,
FALSE, 0);
D3D11_VIDEO_PROCESSOR_COLOR_SPACE csp = {
.YCbCr_Matrix = p->params.color.space != MP_CSP_BT_601,
.Nominal_Range = p->params.color.levels == MP_CSP_LEVELS_TV ? 1 : 2,
};
ID3D11VideoContext_VideoProcessorSetStreamColorSpace(p->video_ctx,
p->video_proc,
0, &csp);
if (p->out_rgb) {
if (p->params.color.space != MP_CSP_BT_601 &&
p->params.color.space != MP_CSP_BT_709)
{
MP_WARN(vf, "Unsupported video colorspace (%s/%s). Consider "
"disabling hardware decoding, or using "
"--hwdec=d3d11va-copy to get correct output.\n",
m_opt_choice_str(mp_csp_names, p->params.color.space),
m_opt_choice_str(mp_csp_levels_names, p->params.color.levels));
}
} else {
ID3D11VideoContext_VideoProcessorSetOutputColorSpace(p->video_ctx,
p->video_proc,
&csp);
}
return 0;
fail:
destroy_video_proc(vf);
return -1;
}
static int render(struct vf_instance *vf)
{
struct vf_priv_s *p = vf->priv;
int res = -1;
HRESULT hr;
ID3D11VideoProcessorInputView *in_view = NULL;
ID3D11VideoProcessorOutputView *out_view = NULL;
struct mp_image *in = NULL, *out = NULL;
out = mp_image_pool_get(p->pool, p->out_params.imgfmt, p->params.w, p->params.h);
if (!out)
goto cleanup;
ID3D11Texture2D *d3d_out_tex = (void *)out->planes[1];
in = mp_refqueue_get(p->queue, 0);
if (!in)
goto cleanup;
ID3D11Texture2D *d3d_tex = (void *)in->planes[1];
int d3d_subindex = (intptr_t)in->planes[2];
mp_image_copy_attributes(out, in);
D3D11_VIDEO_FRAME_FORMAT d3d_frame_format;
if (!mp_refqueue_should_deint(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
} else if (mp_refqueue_top_field_first(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST;
} else {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST;
}
D3D11_TEXTURE2D_DESC texdesc;
ID3D11Texture2D_GetDesc(d3d_tex, &texdesc);
if (!p->video_proc || p->c_w != texdesc.Width || p->c_h != texdesc.Height ||
p->d3d_frame_format != d3d_frame_format)
{
p->c_w = texdesc.Width;
p->c_h = texdesc.Height;
p->d3d_frame_format = d3d_frame_format;
if (recreate_video_proc(vf) < 0)
goto cleanup;
}
if (!mp_refqueue_should_deint(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
} else if (mp_refqueue_is_top_field(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST;
} else {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST;
}
ID3D11VideoContext_VideoProcessorSetStreamFrameFormat(p->video_ctx,
p->video_proc,
0, d3d_frame_format);
D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC indesc = {
.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D,
.Texture2D = {
.ArraySlice = d3d_subindex,
},
};
hr = ID3D11VideoDevice_CreateVideoProcessorInputView(p->video_dev,
(ID3D11Resource *)d3d_tex,
p->vp_enum, &indesc,
&in_view);
if (FAILED(hr)) {
MP_ERR(vf, "Could not create ID3D11VideoProcessorInputView\n");
goto cleanup;
}
D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC outdesc = {
.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D,
};
hr = ID3D11VideoDevice_CreateVideoProcessorOutputView(p->video_dev,
(ID3D11Resource *)d3d_out_tex,
p->vp_enum, &outdesc,
&out_view);
if (FAILED(hr))
goto cleanup;
D3D11_VIDEO_PROCESSOR_STREAM stream = {
.Enable = TRUE,
.pInputSurface = in_view,
};
int frame = mp_refqueue_is_second_field(p->queue);
hr = ID3D11VideoContext_VideoProcessorBlt(p->video_ctx, p->video_proc,
out_view, frame, 1, &stream);
if (FAILED(hr)) {
MP_ERR(vf, "VideoProcessorBlt failed.\n");
goto cleanup;
}
res = 0;
cleanup:
if (in_view)
ID3D11VideoProcessorInputView_Release(in_view);
if (out_view)
ID3D11VideoProcessorOutputView_Release(out_view);
if (res >= 0) {
vf_add_output_frame(vf, out);
} else {
talloc_free(out);
}
mp_refqueue_next_field(p->queue);
return res;
}
static int filter_out(struct vf_instance *vf)
{
struct vf_priv_s *p = vf->priv;
if (!mp_refqueue_has_output(p->queue))
return 0;
// no filtering
if (!mp_refqueue_should_deint(p->queue) && !p->require_filtering) {
struct mp_image *in = mp_image_new_ref(mp_refqueue_get(p->queue, 0));
if (!in)
return -1;
mp_image_set_params(in, &p->out_params);
vf_add_output_frame(vf, in);
mp_refqueue_next(p->queue);
return 0;
}
return render(vf);
}
static int reconfig(struct vf_instance *vf, struct mp_image_params *in,
struct mp_image_params *out)
{
struct vf_priv_s *p = vf->priv;
flush_frames(vf);
talloc_free(p->pool);
p->pool = NULL;
destroy_video_proc(vf);
*out = *in;
if (vf_next_query_format(vf, IMGFMT_D3D11VA) ||
vf_next_query_format(vf, IMGFMT_D3D11NV12))
{
out->imgfmt = vf_next_query_format(vf, IMGFMT_D3D11VA)
? IMGFMT_D3D11VA : IMGFMT_D3D11NV12;
out->hw_subfmt = IMGFMT_NV12;
p->out_format = DXGI_FORMAT_NV12;
p->out_shared = false;
p->out_rgb = false;
} else {
out->imgfmt = IMGFMT_D3D11RGB;
out->hw_subfmt = IMGFMT_RGB0;
p->out_format = DXGI_FORMAT_B8G8R8A8_UNORM;
p->out_shared = true;
p->out_rgb = true;
}
p->require_filtering = in->hw_subfmt != out->hw_subfmt;
p->params = *in;
p->out_params = *out;
p->pool = mp_image_pool_new(20);
mp_image_pool_set_allocator(p->pool, alloc_pool, vf);
mp_image_pool_set_lru(p->pool);
return 0;
}
static void uninit(struct vf_instance *vf)
{
struct vf_priv_s *p = vf->priv;
destroy_video_proc(vf);
flush_frames(vf);
mp_refqueue_free(p->queue);
talloc_free(p->pool);
if (p->video_ctx)
ID3D11VideoContext_Release(p->video_ctx);
if (p->video_dev)
ID3D11VideoDevice_Release(p->video_dev);
if (p->device_ctx)
ID3D11DeviceContext_Release(p->device_ctx);
if (p->vo_dev)
ID3D11Device_Release(p->vo_dev);
}
static int query_format(struct vf_instance *vf, unsigned int imgfmt)
{
if (imgfmt == IMGFMT_D3D11VA ||
imgfmt == IMGFMT_D3D11NV12 ||
imgfmt == IMGFMT_D3D11RGB)
{
return vf_next_query_format(vf, IMGFMT_D3D11VA) ||
vf_next_query_format(vf, IMGFMT_D3D11NV12) ||
vf_next_query_format(vf, IMGFMT_D3D11RGB);
}
return 0;
}
static bool test_conversion(int in, int out)
{
return (in == IMGFMT_D3D11VA ||
in == IMGFMT_D3D11NV12 ||
in == IMGFMT_D3D11RGB) &&
(out == IMGFMT_D3D11VA ||
out == IMGFMT_D3D11NV12 ||
out == IMGFMT_D3D11RGB);
}
static int control(struct vf_instance *vf, int request, void* data)
{
struct vf_priv_s *p = vf->priv;
switch (request){
case VFCTRL_GET_DEINTERLACE:
*(int*)data = !!p->deint_enabled;
return true;
case VFCTRL_SET_DEINTERLACE:
p->deint_enabled = !!*(int*)data;
return true;
case VFCTRL_SEEK_RESET:
flush_frames(vf);
return true;
default:
return CONTROL_UNKNOWN;
}
}
static int vf_open(vf_instance_t *vf)
{
struct vf_priv_s *p = vf->priv;
vf->reconfig = reconfig;
vf->filter_ext = filter_ext;
vf->filter_out = filter_out;
vf->query_format = query_format;
vf->uninit = uninit;
vf->control = control;
p->queue = mp_refqueue_alloc();
p->vo_dev = hwdec_devices_load(vf->hwdec_devs, HWDEC_D3D11VA);
if (!p->vo_dev)
return 0;
ID3D11Device_AddRef(p->vo_dev);
HRESULT hr;
hr = ID3D11Device_QueryInterface(p->vo_dev, &IID_ID3D11VideoDevice,
(void **)&p->video_dev);
if (FAILED(hr))
goto fail;
ID3D11Device_GetImmediateContext(p->vo_dev, &p->device_ctx);
if (!p->device_ctx)
goto fail;
hr = ID3D11DeviceContext_QueryInterface(p->device_ctx, &IID_ID3D11VideoContext,
(void **)&p->video_ctx);
if (FAILED(hr))
goto fail;
return 1;
fail:
uninit(vf);
return 0;
}
#define OPT_BASE_STRUCT struct vf_priv_s
static const m_option_t vf_opts_fields[] = {
OPT_FLAG("deint", deint_enabled, 0),
OPT_FLAG("interlaced-only", interlaced_only, 0),
OPT_CHOICE("mode", mode, 0,
({"blend", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BLEND},
{"bob", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BOB},
{"adaptive", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_ADAPTIVE},
{"mocomp", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_MOTION_COMPENSATION},
#define INITIAL_PROBE_SIZE STREAM_BUFFER_SIZE
#define PROBE_BUF_SIZE FFMIN(STREAM_MAX_BUFFER_SIZE, 2 * 1024 * 1024)
#define OPT_BASE_STRUCT struct MPOpts
// Should correspond to IO_BUFFER_SIZE in libavformat/aviobuf.c (not public)
// libavformat (almost) always reads data in blocks of this size.
#define BIO_BUFFER_SIZE 32768
const m_option_t lavfdopts_conf[] = {
OPT_INTRANGE("probesize", lavfdopts.probesize, 0, 32, INT_MAX),
OPT_STRING("format", lavfdopts.format, 0),
OPT_FLOATRANGE("analyzeduration", lavfdopts.analyzeduration, 0, 0, 3600),
OPT_INTRANGE("buffersize", lavfdopts.buffersize, 0, 1, 10 * 1024 * 1024,
OPTDEF_INT(BIO_BUFFER_SIZE)),
OPT_FLAG("allow-mimetype", lavfdopts.allow_mimetype, 0),
OPT_INTRANGE("probescore", lavfdopts.probescore, 0, 0, 100),
OPT_STRING("cryptokey", lavfdopts.cryptokey, 0),
OPT_CHOICE("genpts-mode", lavfdopts.genptsmode, 0,
({"lavf", 1}, {"no", 0})),
OPT_STRING("o", lavfdopts.avopt, 0),
{NULL, NULL, 0, 0, 0, 0, NULL}
};
#define MAX_PKT_QUEUE 50
typedef struct lavf_priv {
char *filename;
const struct format_hack *format_hack;
AVInputFormat *avif;
AVFormatContext *avfc;
err_out:
uninit(vo);
return -1;
}
static int validate_backend_opt(const m_option_t *opt, struct bstr name,
struct bstr param)
{
char s[20];
snprintf(s, sizeof(s), "%.*s", BSTR_P(param));
return mpgl_find_backend(s) >= -1 ? 1 : M_OPT_INVALID;
}
#define OPT_BASE_STRUCT struct gl_priv
const struct m_option options[] = {
OPT_FLAG("glfinish", use_glFinish, 0),
OPT_INT("swapinterval", swap_interval, 0, OPTDEF_INT(1)),
OPT_FLAG("debug", use_gl_debug, 0),
OPT_STRING_VALIDATE("backend", backend, 0, validate_backend_opt),
OPT_FLAG("sw", allow_sw, 0),
OPT_SUBSTRUCT("", renderer_opts, gl_video_conf, 0),
OPT_SUBSTRUCT("", icc_opts, mp_icc_conf, 0),
{0},
};
static const char help_text[];
const struct vo_driver video_out_opengl = {
.info = &(const vo_info_t) {
"Extended OpenGL Renderer",
/* dir/public. */
int flagsubonly = -1; /* =1 subscribers only for get/index/thread */
unsigned long copylines = 0; /* Number of lines from the message to copy */
const char *digsz =
"from\\to\\subject\\reply-to\\date\\message-id\\cc\\"
"mime-version\\content-type\\content-transfer-encoding";
int flagarchived; /* if list is archived */
int flagindexed; /* if list is indexed */
const char *flagformat = 0;
const char FATAL[] = "ezmlm-get: fatal: ";
const char USAGE[] =
"ezmlm-get: usage: ezmlm-get [-bBcClLpPsSvV] [-f fmt] [digestcode]";
static struct option options[] = {
OPT_FLAG(flagbottom,'b',1,0), /* add text/bottom (default) */
OPT_FLAG(flagbottom,'B',0,0), /* suppress text/bottom */
OPT_FLAG(flagdo,'c',1,0), /* do commands */
OPT_FLAG(flagdo,'C',0,0), /* ignore commands X dig */
OPT_CSTR(flagformat,'f',"digformat"),
OPT_FLAG(flagpublic,'p',1,0), /* always public */
OPT_FLAG(flagpublic,'P',0,0), /* never public = only mods do cmd */
OPT_FLAG(flagsubonly,'s',1,"subgetonly"), /* only subs have archive access */
OPT_FLAG(flagsubonly,'S',0,0), /* everyone has archive access */
OPT_FLAG(flagindexed,0,1,"indexed"),
OPT_FLAG(flagarchived,0,1,"archived"),
OPT_ULONG(copylines,0,"copylines"),
OPT_END
};
stralloc listname = {0};
};
const struct m_opt_choice_alternatives mp_image_writer_formats[] = {
{"jpg", AV_CODEC_ID_MJPEG},
{"jpeg", AV_CODEC_ID_MJPEG},
{"png", AV_CODEC_ID_PNG},
{0}
};
#define OPT_BASE_STRUCT struct image_writer_opts
const struct m_option image_writer_opts[] = {
OPT_CHOICE_C("format", format, 0, mp_image_writer_formats),
OPT_INTRANGE("jpeg-quality", jpeg_quality, 0, 0, 100),
OPT_INTRANGE("jpeg-smooth", jpeg_smooth, 0, 0, 100),
OPT_FLAG("jpeg-source-chroma", jpeg_source_chroma, 0),
OPT_INTRANGE("png-compression", png_compression, 0, 0, 9),
OPT_INTRANGE("png-filter", png_filter, 0, 0, 5),
OPT_FLAG("high-bit-depth", high_bit_depth, 0),
OPT_FLAG("tag-colorspace", tag_csp, 0),
{0},
};
struct image_writer_ctx {
struct mp_log *log;
const struct image_writer_opts *opts;
struct mp_imgfmt_desc original_format;
};
static enum AVPixelFormat replace_j_format(enum AVPixelFormat fmt)
{
vo->hwdec_devs, hwdec);
gl_video_set_hwdec(p->renderer, p->hwdec);
}
p->original_opts = m_sub_options_copy(p, &opengl_conf, p);
return 0;
err_out:
uninit(vo);
return -1;
}
#define OPT_BASE_STRUCT struct gl_priv
static const struct m_option options[] = {
OPT_FLAG("glfinish", use_glFinish, 0),
OPT_FLAG("waitvsync", waitvsync, 0),
OPT_INT("swapinterval", swap_interval, 0, OPTDEF_INT(1)),
OPT_CHOICE("dwmflush", dwm_flush, 0,
({"no", -1}, {"auto", 0}, {"windowed", 1}, {"yes", 2})),
OPT_FLAG("debug", use_gl_debug, 0),
OPT_STRING_VALIDATE("backend", backend, 0, mpgl_validate_backend_opt),
OPT_FLAG("sw", allow_sw, 0),
OPT_CHOICE("es", es, 0, ({"no", -1}, {"auto", 0}, {"yes", 1})),
OPT_INTPAIR("check-pattern", opt_pattern, 0),
OPT_INTRANGE("vsync-fences", opt_vsync_fences, 0, 0, NUM_VSYNC_FENCES),
OPT_SUBSTRUCT("", renderer_opts, gl_video_conf, 0),
{0},
};
{"playlist", NULL, CONF_TYPE_STRING, CONF_NOCFG | M_OPT_MIN, 1, 0, NULL},
{"shuffle", NULL, CONF_TYPE_FLAG, CONF_NOCFG, 0, 0, NULL},
{"{", NULL, CONF_TYPE_STORE, CONF_NOCFG, 0, 0, NULL},
{"}", NULL, CONF_TYPE_STORE, CONF_NOCFG, 0, 0, NULL},
// handled in m_config.c
{ "include", NULL, CONF_TYPE_STRING },
{ "profile", NULL, CONF_TYPE_STRING_LIST },
{ "show-profile", NULL, CONF_TYPE_STRING, CONF_NOCFG },
{ "list-options", NULL, CONF_TYPE_STORE, CONF_NOCFG },
// handled in mplayer.c (looks at the raw argv[])
{"leak-report", "", CONF_TYPE_STORE, CONF_GLOBAL | CONF_NOCFG },
// ------------------------- common options --------------------
OPT_FLAG("quiet", quiet, CONF_GLOBAL),
{"really-quiet", &verbose, CONF_TYPE_STORE, CONF_GLOBAL|CONF_PRE_PARSE, 0, -10, NULL},
{"msglevel", (void *) msgl_config, CONF_TYPE_SUBCONFIG, CONF_GLOBAL, 0, 0, NULL},
{"msgcolor", &mp_msg_color, CONF_TYPE_FLAG, CONF_GLOBAL | CONF_PRE_PARSE, 0, 1, NULL},
{"msgmodule", &mp_msg_module, CONF_TYPE_FLAG, CONF_GLOBAL, 0, 1, NULL},
#ifdef CONFIG_PRIORITY
{"priority", &proc_priority, CONF_TYPE_STRING, 0, 0, 0, NULL},
#endif
OPT_FLAG("config", load_config, CONF_GLOBAL | CONF_NOCFG | CONF_PRE_PARSE),
OPT_STRINGLIST("reset-on-next-file", reset_options, CONF_GLOBAL),
// ------------------------- stream options --------------------
#ifdef CONFIG_STREAM_CACHE
OPT_CHOICE_OR_INT("cache", stream_cache_size, 0, 32, 0x7fffffff,
({"no", 0},
.jpeg_optimize = 100,
.jpeg_smooth = 0,
.jpeg_dpi = 72,
.jpeg_progressive = 0,
.jpeg_baseline = 1,
};
#define OPT_BASE_STRUCT struct image_writer_opts
const struct m_sub_options image_writer_conf = {
.opts = (m_option_t[]) {
OPT_INTRANGE("jpeg-quality", jpeg_quality, 0, 0, 100),
OPT_INTRANGE("jpeg-optimize", jpeg_optimize, 0, 0, 100),
OPT_INTRANGE("jpeg-smooth", jpeg_smooth, 0, 0, 100),
OPT_INTRANGE("jpeg-dpi", jpeg_dpi, M_OPT_MIN, 1, 99999),
OPT_FLAG("jpeg-progressive", jpeg_progressive, 0),
OPT_FLAG("jpeg-baseline", jpeg_baseline, 0),
OPT_INTRANGE("png-compression", png_compression, 0, 0, 9),
OPT_INTRANGE("png-filter", png_filter, 0, 0, 5),
OPT_STRING("format", format, 0),
{0},
},
.size = sizeof(struct image_writer_opts),
.defaults = &image_writer_opts_defaults,
};
struct image_writer_ctx {
struct mp_log *log;
const struct image_writer_opts *opts;
const struct img_writer *writer;
};
{
struct vo_priv *p = vo->priv;
pthread_mutex_lock(&p->ctx->lock);
forget_frames(p->ctx);
p->ctx->img_params = *params;
p->ctx->reconfigured = true;
pthread_mutex_unlock(&p->ctx->lock);
return 0;
}
// list of options which can be changed at runtime
#define OPT_BASE_STRUCT struct vo_priv
static const struct m_option change_opts[] = {
OPT_FLAG("debug", use_gl_debug, 0),
OPT_INTRANGE("frame-queue-size", frame_queue_size, 0, 1, 100, OPTDEF_INT(2)),
OPT_CHOICE("frame-drop-mode", frame_drop_mode, 0,
({"pop", FRAME_DROP_POP},
{"clear", FRAME_DROP_CLEAR})),
OPT_SUBSTRUCT("", renderer_opts, gl_video_conf, 0),
{0}
};
#undef OPT_BASE_STRUCT
static bool reparse_cmdline(struct vo_priv *p, char *args)
{
struct m_config *cfg = NULL;
struct vo_priv *opts = NULL;
int r = 0;
const char FATAL[] = "ezmlm-moderate: fatal: ";
const char INFO[] = "ezmlm-moderate: info: ";
const char USAGE[] =
"ezmlm-moderate: usage: ezmlm-moderate [-cCmMrRvV] [-t replyto] dir [/path/ezmlm-send]";
static const char *replyto = (char *) 0;
static int flagmime = MOD_MIME; /* default is message as attachment */
static stralloc sendopt = {0};
static struct option options[] = {
OPT_COPY_FLAG(sendopt,'c'),
OPT_COPY_FLAG(sendopt,'C'),
OPT_COPY_FLAG(sendopt,'r'),
OPT_COPY_FLAG(sendopt,'R'),
OPT_FLAG(flagmime,'m',1,0),
OPT_FLAG(flagmime,'M',0,0),
OPT_CSTR(replyto,'t',0),
OPT_CSTR(replyto,'T',0),
OPT_END
};
stralloc mydtline = {0};
stralloc accept = {0};
stralloc reject = {0};
stralloc to = {0};
stralloc send = {0};
stralloc comment = {0};
datetime_sec when;
char strnum[FMT_ULONG];
/* Timeouts in h for messages. If modtime has a number, it is made to be*/
/* in the range DELAY_MIN..DELAY_MAX. If the number is 0 or there is no */
/* number, DELAY_DEFAULT is used. Messages that are read-only are */
/* ignored. Messages in 'pending' that have the execute bit set result */
/* in an informative reply to the poster. Any defects in the message */
/* format, inability to open the file, etc, result in a maillog entry */
/* whereafter the message is erased. */
/* The defines are in "idx.h" */
const char FATAL[] = "ezmlm-clean: fatal: ";
const char USAGE[] =
"ezmlm-clean: usage: ezmlm-clean [-mMrRvV] dir";
static struct option options[] = {
OPT_FLAG(flagmime,'m',1,0),
OPT_FLAG(flagmime,'M',0,0),
OPT_FLAG(flagreturn,'r',1,0),
OPT_FLAG(flagreturn,'R',0,"noreturnposts"),
OPT_END
};
void die_read(void)
{
strerr_die2x(111,FATAL,MSG1(ERR_READ,fnmsg.s));
}
datetime_sec when;
unsigned int older;
char textbuf[1024];
int exitquiet = 100; /* reject with error (100) rather than exit */
/* quietly (99) if listaddress missing */
int flagheaderreject = 1; /* reject messages with headers listed in */
/* DIR/headerreject. */
int flagbody = 0; /* =1 => reject if subject or body starts with*/
/* "subscribe" or "unsubscribe" */
int flagforward = 0; /* =1 => forward commands to list-request */
int flagparsemime = 0;
int flaghavesubject = 0;
int flaghavecommand = 0;
int flagcheck = 0; /* set after boundary is found in body, */
/* until blank line */
unsigned long copylines = 0; /* Number of lines from the message to copy */
static struct option options[] = {
OPT_FLAG(flagbody,'b',1,0),
OPT_FLAG(flagbody,'B',0,0),
OPT_FLAG(flagrejectcommands,'c',1,0),
OPT_FLAG(flagrejectcommands,'C',0,0),
OPT_FLAG(flagforward,'f',1,0),
OPT_FLAG(flagforward,'F',0,0),
OPT_FLAG(flagheaderreject,'h',1,0),
OPT_FLAG(flagheaderreject,'H',0,0),
OPT_FLAG(exitquiet,'q',99,0),
OPT_FLAG(exitquiet,'Q',100,0),
OPT_FLAG(flagneedsubject,'s',1,0),
OPT_FLAG(flagneedsubject,'S',0,0),
OPT_FLAG(flagtook,'t',0,0),
OPT_FLAG(flagtook,'T',1,0),
OPT_END
};
#include "fmt.h"
#include "messages.h"
#include "die.h"
#include "config.h"
#include "idx.h"
#include "auto_version.h"
const char FATAL[] = "ezmlm-split: fatal: ";
const char INFO[] = "ezmlm-split: info: ";
const char USAGE[] =
"ezmlm-split: usage: ezmlm-split [-dD] dir [splitfile]";
static int flagdo = 1; /* default is manager function */
static struct option options[] = {
OPT_FLAG(flagdo,'d',1,0),
OPT_FLAG(flagdo,'D',0,0),
OPT_END
};
static const char *sender;
static const char *split;
static stralloc target = {0};
static stralloc lctarget = {0};
static stralloc line = {0};
static stralloc domain = {0};
static stralloc name = {0};
static stralloc from = {0};
static stralloc to = {0};
static unsigned long lineno;
static int flagfound;
#include "idx.h"
#include "wrap.h"
const char FATAL[] = "ezmlm-cron: fatal: ";
const char USAGE[] =
"ezmlm-cron: usage: ezmlm-cron [-cCdDlLvV] [-w dow] [-t hh:mm] [-i hrs] listadr code";
static const char *flagt = 0;
static const char *flagw = 0;
static unsigned long deltah = 24L; /* default interval 24h */
static int flagconfig = 0;
static int flagdelete = 0;
static int flaglist = 0;
static struct option options[] = {
OPT_FLAG(flagconfig,'c',1,0),
OPT_FLAG(flagconfig,'C',0,0),
OPT_FLAG(flagdelete,'d',1,0),
OPT_FLAG(flagdelete,'D',0,0),
OPT_ULONG(deltah,'i',0),
OPT_FLAG(flaglist,'l',1,0),
OPT_FLAG(flaglist,'L',0,0),
OPT_CSTR(flagt,'t',0),
OPT_CSTR(flagw,'w',0),
OPT_END
};
static void die_syntax(stralloc *line)
{
if (!stralloc_0(line)) die_nomem();
strerr_die4x(100,FATAL,MSG1(ERR_SYNTAX,TXT_EZCRONRC),": ",line->s);
#include "subdb.h"
#include "getconfopt.h"
#include "messages.h"
#include "die.h"
#include "idx.h"
#include "config.h"
#include "auto_version.h"
const char FATAL[] = "ezmlm-issubn: fatal: ";
const char USAGE[] =
"ezmlm-issubn: usage: ezmlm-issubn [-nN] dir [subdir ...]";
static int flagsub = 0;
static struct option options[] = {
OPT_FLAG(flagsub,'n',99,0),
OPT_FLAG(flagsub,'N',0,0),
OPT_END
};
void main(int argc,char **argv)
{
const char *subdir;
const char *addr;
int opt;
int senderissub;
int i;
addr = get_sender();
if (!addr) die_sender(); /* REQUIRE sender */
static int flagunsubismod = 0; /* default: do not require moderator approval to */
/* unsubscribe from moderated list */
static int flagedit = -1; /* default: text file edit not allowed */
static int flagstorefrom = 1; /* default: store from: line for subscribes */
static int flagshowact = 0; /* default: do not show the action taken */
static char encin = '\0'; /* encoding of incoming message */
static int flagdig = 0; /* request is not for digest list */
static unsigned long copylines = 0; /* Number of lines from the message to copy */
static int flagpublic = 0;
static stralloc modsub = {0};
static stralloc remote = {0};
static int ismod;
static stralloc mod = {0};
static struct option options[] = {
OPT_FLAG(flagshowact,'a',1,0),
OPT_FLAG(flagshowact,'A',0,0),
OPT_FLAG(omitbottom,'b',0,0),
OPT_FLAG(omitbottom,'B',1,"omitbottom"),
OPT_FLAG(flagget,'c',1,0),
OPT_FLAG(flagget,'C',0,0),
OPT_FLAG(flagedit,'d',1,0),
OPT_FLAG(flagedit,'D',0,0),
OPT_FLAG(flagedit,'e',1,"modcanedit"),
OPT_FLAG(flagedit,'E',0,0),
OPT_FLAG(flagstorefrom,'f',1,0),
OPT_FLAG(flagstorefrom,'F',0,0),
OPT_FLAG(flaglist,'l',1,"modcanlist"),
OPT_FLAG(flaglist,'L',0,0),
OPT_FLAG(flagunsubismod,'m',1,0),
OPT_FLAG(flagunsubismod,'M',0,0),
// handled in command line parser (parser-mpcmd.c)
{"playlist", NULL, CONF_TYPE_STRING, CONF_NOCFG | M_OPT_MIN, 1, 0, NULL},
{"{", NULL, CONF_TYPE_STORE, CONF_NOCFG, 0, 0, NULL},
{"}", NULL, CONF_TYPE_STORE, CONF_NOCFG, 0, 0, NULL},
// handled in m_config.c
{ "include", NULL, CONF_TYPE_STRING },
{ "profile", NULL, CONF_TYPE_STRING_LIST },
{ "show-profile", NULL, CONF_TYPE_STRING, CONF_NOCFG },
{ "list-options", NULL, CONF_TYPE_STORE, CONF_NOCFG },
// handled in mplayer.c (looks at the raw argv[])
{"leak-report", NULL, CONF_TYPE_STORE, CONF_GLOBAL | CONF_NOCFG },
OPT_FLAG("shuffle", shuffle, CONF_GLOBAL | CONF_NOCFG),
// ------------------------- common options --------------------
OPT_FLAG("quiet", quiet, CONF_GLOBAL),
{"really-quiet", &verbose, CONF_TYPE_STORE, CONF_GLOBAL|CONF_PRE_PARSE, 0, -10, NULL},
{"msglevel", (void *) msgl_config, CONF_TYPE_SUBCONFIG, CONF_GLOBAL, 0, 0, NULL},
{"msgcolor", &mp_msg_color, CONF_TYPE_FLAG, CONF_GLOBAL | CONF_PRE_PARSE, 0, 1, NULL},
{"msgmodule", &mp_msg_module, CONF_TYPE_FLAG, CONF_GLOBAL, 0, 1, NULL},
#if HAVE_PRIORITY
{"priority", &proc_priority, CONF_TYPE_STRING, 0, 0, 0, NULL},
#endif
OPT_FLAG("config", load_config, CONF_GLOBAL | CONF_NOCFG | CONF_PRE_PARSE),
OPT_STRINGLIST("reset-on-next-file", reset_options, CONF_GLOBAL),
#if HAVE_LUA
OPT_STRINGLIST("lua", lua_files, CONF_GLOBAL),
// handled in command line pre-parser (parse_commandline.c)
{"v", NULL, CONF_TYPE_STORE, CONF_GLOBAL | CONF_NOCFG, 0, 0, NULL},
{"playlist", NULL, CONF_TYPE_STRING, CONF_NOCFG | M_OPT_MIN, 1, 0, NULL},
{"{", NULL, CONF_TYPE_STORE, CONF_NOCFG, 0, 0, NULL},
{"}", NULL, CONF_TYPE_STORE, CONF_NOCFG, 0, 0, NULL},
// handled in m_config.c
{ "include", NULL, CONF_TYPE_STRING },
{ "profile", NULL, CONF_TYPE_STRING_LIST },
{ "show-profile", NULL, CONF_TYPE_STRING, CONF_NOCFG },
{ "list-options", NULL, CONF_TYPE_STORE, CONF_NOCFG },
// handled in main.c (looks at the raw argv[])
{"leak-report", NULL, CONF_TYPE_STORE, CONF_GLOBAL | CONF_NOCFG },
OPT_FLAG("shuffle", shuffle, CONF_GLOBAL | CONF_NOCFG),
// ------------------------- common options --------------------
OPT_FLAG("quiet", quiet, CONF_GLOBAL),
OPT_FLAG_STORE("really-quiet", verbose, CONF_GLOBAL | CONF_PRE_PARSE, -10),
OPT_GENERAL(char*, "msglevel", msglevels, CONF_GLOBAL|CONF_PRE_PARSE,
.type = &m_option_type_msglevels),
OPT_FLAG("msgcolor", msg_color, CONF_GLOBAL | CONF_PRE_PARSE),
OPT_FLAG("msgmodule", msg_module, CONF_GLOBAL),
OPT_FLAG("identify", msg_identify, CONF_GLOBAL),
#if HAVE_PRIORITY
{"priority", &proc_priority, CONF_TYPE_STRING, 0, 0, 0, NULL},
#endif
OPT_FLAG("config", load_config, CONF_GLOBAL | CONF_NOCFG | CONF_PRE_PARSE),
OPT_STRINGLIST("reset-on-next-file", reset_options, CONF_GLOBAL),
#include "messages.h"
#include "config.h"
#include "auto_version.h"
const char FATAL[] = "ezmlm-archive: fatal: ";
const char USAGE[] =
"ezmlm-archive: usage: ezmlm-archive [-cCFsSTvV] [-f min_msg] [-t max_msg] dir";
const char WARNING[] = "ezmlm-archive: warning: inconsistent index: ";
static int flagcreate = 0;
static unsigned long archnum = 0L;
static int flagsyncall = 0;
static unsigned long optto = 0L;
static struct option options[] = {
OPT_FLAG(flagcreate,'c',1,0),
OPT_FLAG(flagcreate,'C',0,0),
OPT_ULONG(archnum,'f',0),
OPT_ULONG_FLAG(archnum,'F',0,0),
OPT_FLAG(flagsyncall,'s',1,0),
OPT_FLAG(flagsyncall,'S',0,0),
OPT_ULONG(optto,'t',0),
OPT_ULONG_FLAG(optto,'T',0,0),
OPT_END
};
substdio ssin;
char inbuf[1024];
substdio ssout;
char outbuf[1024];
substdio ssnum;
static struct option options[] = {
OPT_COPY_FLAG(sendopt,'c'),
OPT_COPY_FLAG(sendopt,'C'),
OPT_COPY_FLAG(sendopt,'r'),
OPT_COPY_FLAG(sendopt,'R'),
OPT_COPY_FLAG(sendopt,'Q'),
OPT_COPY_FLAG(storeopt,'m'),
OPT_COPY_FLAG(storeopt,'M'),
OPT_COPY_FLAG(storeopt,'p'),
OPT_COPY_FLAG(storeopt,'P'),
OPT_COPY_FLAG(storeopt,'s'),
OPT_COPY_FLAG(storeopt,'S'),
OPT_COPY_FLAG(storeopt,'y'),
OPT_COPY_FLAG(storeopt,'Y'),
OPT_CSTR(queryext,'q',0),
OPT_FLAG(dontact,'0',1,0),
OPT_END
};
static int mailprog(const char *s)
{
int r;
int child;
if ((child = wrap_fork()) == 0)
wrap_execsh(s);
/* parent */
switch((r = wrap_waitpid(child))) {
/* 100 perm error, 111 temp, 99 dom ok */
/* 0 rec ok, others bounce */
case 0: case 99: case 100: break;
static int recreate_video_proc(struct mp_filter *vf)
{
struct priv *p = vf->priv;
HRESULT hr;
destroy_video_proc(vf);
D3D11_VIDEO_PROCESSOR_CONTENT_DESC vpdesc = {
.InputFrameFormat = p->d3d_frame_format,
.InputWidth = p->c_w,
.InputHeight = p->c_h,
.OutputWidth = p->params.w,
.OutputHeight = p->params.h,
};
hr = ID3D11VideoDevice_CreateVideoProcessorEnumerator(p->video_dev, &vpdesc,
&p->vp_enum);
if (FAILED(hr))
goto fail;
D3D11_VIDEO_PROCESSOR_CAPS caps;
hr = ID3D11VideoProcessorEnumerator_GetVideoProcessorCaps(p->vp_enum, &caps);
if (FAILED(hr))
goto fail;
MP_VERBOSE(vf, "Found %d rate conversion caps. Looking for caps=0x%x.\n",
(int)caps.RateConversionCapsCount, p->opts->mode);
int rindex = -1;
for (int n = 0; n < caps.RateConversionCapsCount; n++) {
D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS rcaps;
hr = ID3D11VideoProcessorEnumerator_GetVideoProcessorRateConversionCaps
(p->vp_enum, n, &rcaps);
if (FAILED(hr))
goto fail;
MP_VERBOSE(vf, " - %d: 0x%08x\n", n, (unsigned)rcaps.ProcessorCaps);
if (rcaps.ProcessorCaps & p->opts->mode) {
MP_VERBOSE(vf, " (matching)\n");
if (rindex < 0)
rindex = n;
}
}
if (rindex < 0) {
MP_WARN(vf, "No fitting video processor found, picking #0.\n");
rindex = 0;
}
// TOOD: so, how do we select which rate conversion mode the processor uses?
hr = ID3D11VideoDevice_CreateVideoProcessor(p->video_dev, p->vp_enum, rindex,
&p->video_proc);
if (FAILED(hr)) {
MP_ERR(vf, "Failed to create D3D11 video processor.\n");
goto fail;
}
// Note: libavcodec does not support cropping left/top with hwaccel.
RECT src_rc = {
.right = p->params.w,
.bottom = p->params.h,
};
ID3D11VideoContext_VideoProcessorSetStreamSourceRect(p->video_ctx,
p->video_proc,
0, TRUE, &src_rc);
// This is supposed to stop drivers from f*****g up the video quality.
ID3D11VideoContext_VideoProcessorSetStreamAutoProcessingMode(p->video_ctx,
p->video_proc,
0, FALSE);
ID3D11VideoContext_VideoProcessorSetStreamOutputRate(p->video_ctx,
p->video_proc,
0,
D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_NORMAL,
FALSE, 0);
D3D11_VIDEO_PROCESSOR_COLOR_SPACE csp = {
.YCbCr_Matrix = p->params.color.space != MP_CSP_BT_601,
.Nominal_Range = p->params.color.levels == MP_CSP_LEVELS_TV ? 1 : 2,
};
ID3D11VideoContext_VideoProcessorSetStreamColorSpace(p->video_ctx,
p->video_proc,
0, &csp);
if (p->out_rgb) {
if (p->params.color.space != MP_CSP_BT_601 &&
p->params.color.space != MP_CSP_BT_709)
{
MP_WARN(vf, "Unsupported video colorspace (%s/%s). Consider "
"disabling hardware decoding, or using "
"--hwdec=d3d11va-copy to get correct output.\n",
m_opt_choice_str(mp_csp_names, p->params.color.space),
m_opt_choice_str(mp_csp_levels_names, p->params.color.levels));
}
} else {
ID3D11VideoContext_VideoProcessorSetOutputColorSpace(p->video_ctx,
p->video_proc,
&csp);
}
return 0;
fail:
destroy_video_proc(vf);
return -1;
}
static struct mp_image *render(struct mp_filter *vf)
{
struct priv *p = vf->priv;
int res = -1;
HRESULT hr;
ID3D11VideoProcessorInputView *in_view = NULL;
ID3D11VideoProcessorOutputView *out_view = NULL;
struct mp_image *in = NULL, *out = NULL;
out = mp_image_pool_get(p->pool, IMGFMT_D3D11, p->params.w, p->params.h);
if (!out) {
MP_WARN(vf, "failed to allocate frame\n");
goto cleanup;
}
ID3D11Texture2D *d3d_out_tex = (void *)out->planes[0];
in = mp_refqueue_get(p->queue, 0);
if (!in)
goto cleanup;
ID3D11Texture2D *d3d_tex = (void *)in->planes[0];
int d3d_subindex = (intptr_t)in->planes[1];
mp_image_copy_attributes(out, in);
D3D11_VIDEO_FRAME_FORMAT d3d_frame_format;
if (!mp_refqueue_should_deint(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
} else if (mp_refqueue_top_field_first(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST;
} else {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST;
}
D3D11_TEXTURE2D_DESC texdesc;
ID3D11Texture2D_GetDesc(d3d_tex, &texdesc);
if (!p->video_proc || p->c_w != texdesc.Width || p->c_h != texdesc.Height ||
p->d3d_frame_format != d3d_frame_format)
{
p->c_w = texdesc.Width;
p->c_h = texdesc.Height;
p->d3d_frame_format = d3d_frame_format;
if (recreate_video_proc(vf) < 0)
goto cleanup;
}
if (!mp_refqueue_should_deint(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
} else if (mp_refqueue_is_top_field(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST;
} else {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST;
}
ID3D11VideoContext_VideoProcessorSetStreamFrameFormat(p->video_ctx,
p->video_proc,
0, d3d_frame_format);
D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC indesc = {
.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D,
.Texture2D = {
.ArraySlice = d3d_subindex,
},
};
hr = ID3D11VideoDevice_CreateVideoProcessorInputView(p->video_dev,
(ID3D11Resource *)d3d_tex,
p->vp_enum, &indesc,
&in_view);
if (FAILED(hr)) {
MP_ERR(vf, "Could not create ID3D11VideoProcessorInputView\n");
goto cleanup;
}
D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC outdesc = {
.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D,
};
hr = ID3D11VideoDevice_CreateVideoProcessorOutputView(p->video_dev,
(ID3D11Resource *)d3d_out_tex,
p->vp_enum, &outdesc,
&out_view);
if (FAILED(hr)) {
MP_ERR(vf, "Could not create ID3D11VideoProcessorOutputView\n");
goto cleanup;
}
D3D11_VIDEO_PROCESSOR_STREAM stream = {
.Enable = TRUE,
.pInputSurface = in_view,
};
int frame = mp_refqueue_is_second_field(p->queue);
hr = ID3D11VideoContext_VideoProcessorBlt(p->video_ctx, p->video_proc,
out_view, frame, 1, &stream);
if (FAILED(hr)) {
MP_ERR(vf, "VideoProcessorBlt failed.\n");
goto cleanup;
}
res = 0;
cleanup:
if (in_view)
ID3D11VideoProcessorInputView_Release(in_view);
if (out_view)
ID3D11VideoProcessorOutputView_Release(out_view);
if (res < 0)
TA_FREEP(&out);
return out;
}
static bool vo_supports(struct priv *p, int subfmt)
{
for (int n = 0; p->vo_formats && p->vo_formats[n]; n++) {
if (p->vo_formats[n] == subfmt)
return true;
}
return false;
}
static void vf_d3d11vpp_process(struct mp_filter *vf)
{
struct priv *p = vf->priv;
struct mp_image *in_fmt = mp_refqueue_execute_reinit(p->queue);
if (in_fmt) {
mp_image_pool_clear(p->pool);
destroy_video_proc(vf);
p->params = in_fmt->params;
p->out_params = p->params;
if (vo_supports(p, IMGFMT_NV12)) {
p->out_params.hw_subfmt = IMGFMT_NV12;
p->out_format = DXGI_FORMAT_NV12;
p->out_shared = false;
p->out_rgb = false;
} else {
p->out_params.hw_subfmt = IMGFMT_RGB0;
p->out_format = DXGI_FORMAT_B8G8R8A8_UNORM;
p->out_shared = true;
p->out_rgb = true;
}
p->out_params.hw_flags = 0;
p->require_filtering = p->params.hw_subfmt != p->out_params.hw_subfmt;
}
if (!mp_refqueue_can_output(p->queue))
return;
if (!mp_refqueue_should_deint(p->queue) && !p->require_filtering) {
// no filtering
struct mp_image *in = mp_image_new_ref(mp_refqueue_get(p->queue, 0));
if (!in) {
mp_filter_internal_mark_failed(vf);
return;
}
mp_refqueue_write_out_pin(p->queue, in);
} else {
mp_refqueue_write_out_pin(p->queue, render(vf));
}
}
static void uninit(struct mp_filter *vf)
{
struct priv *p = vf->priv;
destroy_video_proc(vf);
flush_frames(vf);
talloc_free(p->queue);
talloc_free(p->pool);
if (p->video_ctx)
ID3D11VideoContext_Release(p->video_ctx);
if (p->video_dev)
ID3D11VideoDevice_Release(p->video_dev);
if (p->device_ctx)
ID3D11DeviceContext_Release(p->device_ctx);
if (p->vo_dev)
ID3D11Device_Release(p->vo_dev);
}
static const struct mp_filter_info vf_d3d11vpp_filter = {
.name = "d3d11vpp",
.process = vf_d3d11vpp_process,
.reset = flush_frames,
.destroy = uninit,
.priv_size = sizeof(struct priv),
};
static struct mp_filter *vf_d3d11vpp_create(struct mp_filter *parent,
void *options)
{
struct mp_filter *f = mp_filter_create(parent, &vf_d3d11vpp_filter);
if (!f) {
talloc_free(options);
return NULL;
}
mp_filter_add_pin(f, MP_PIN_IN, "in");
mp_filter_add_pin(f, MP_PIN_OUT, "out");
struct priv *p = f->priv;
p->opts = talloc_steal(p, options);
// Special path for vf_d3d11_create_outconv(): disable all processing except
// possibly surface format conversions.
if (!p->opts) {
static const struct opts opts = {0};
p->opts = (struct opts *)&opts;
}
p->queue = mp_refqueue_alloc(f);
struct mp_stream_info *info = mp_filter_find_stream_info(f);
if (!info || !info->hwdec_devs)
goto fail;
hwdec_devices_request_all(info->hwdec_devs);
struct mp_hwdec_ctx *hwctx =
hwdec_devices_get_by_lavc(info->hwdec_devs, AV_HWDEVICE_TYPE_D3D11VA);
if (!hwctx || !hwctx->av_device_ref)
goto fail;
AVHWDeviceContext *avhwctx = (void *)hwctx->av_device_ref->data;
AVD3D11VADeviceContext *d3dctx = avhwctx->hwctx;
p->vo_dev = d3dctx->device;
ID3D11Device_AddRef(p->vo_dev);
p->vo_formats = hwctx->supported_formats;
HRESULT hr;
hr = ID3D11Device_QueryInterface(p->vo_dev, &IID_ID3D11VideoDevice,
(void **)&p->video_dev);
if (FAILED(hr))
goto fail;
ID3D11Device_GetImmediateContext(p->vo_dev, &p->device_ctx);
if (!p->device_ctx)
goto fail;
hr = ID3D11DeviceContext_QueryInterface(p->device_ctx, &IID_ID3D11VideoContext,
(void **)&p->video_ctx);
if (FAILED(hr))
goto fail;
p->pool = mp_image_pool_new(f);
mp_image_pool_set_allocator(p->pool, alloc_pool, f);
mp_image_pool_set_lru(p->pool);
mp_refqueue_add_in_format(p->queue, IMGFMT_D3D11, 0);
mp_refqueue_set_refs(p->queue, 0, 0);
mp_refqueue_set_mode(p->queue,
(p->opts->deint_enabled ? MP_MODE_DEINT : 0) |
MP_MODE_OUTPUT_FIELDS |
(p->opts->interlaced_only ? MP_MODE_INTERLACED_ONLY : 0));
return f;
fail:
talloc_free(f);
return NULL;
}
#define OPT_BASE_STRUCT struct opts
static const m_option_t vf_opts_fields[] = {
OPT_FLAG("deint", deint_enabled, 0),
OPT_FLAG("interlaced-only", interlaced_only, 0),
OPT_CHOICE("mode", mode, 0,
({"blend", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BLEND},
{"bob", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BOB},
{"adaptive", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_ADAPTIVE},
{"mocomp", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_MOTION_COMPENSATION},
{"ivctc", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_INVERSE_TELECINE},
{"v", NULL, CONF_TYPE_STORE, CONF_GLOBAL | CONF_NOCFG, 0, 0, NULL},
{"playlist", NULL, CONF_TYPE_STRING, CONF_NOCFG | M_OPT_MIN | M_OPT_FIXED,
1, 0, NULL},
{"{", NULL, CONF_TYPE_STORE, CONF_NOCFG | M_OPT_FIXED, 0, 0, NULL},
{"}", NULL, CONF_TYPE_STORE, CONF_NOCFG | M_OPT_FIXED, 0, 0, NULL},
// handled in m_config.c
{ "include", NULL, CONF_TYPE_STRING, M_OPT_FIXED },
{ "profile", NULL, CONF_TYPE_STRING_LIST, M_OPT_FIXED },
{ "show-profile", NULL, CONF_TYPE_STRING, CONF_NOCFG | M_OPT_FIXED },
{ "list-options", NULL, CONF_TYPE_STORE, CONF_NOCFG | M_OPT_FIXED },
// handled in main.c (looks at the raw argv[])
{"leak-report", NULL, CONF_TYPE_STORE, CONF_GLOBAL | CONF_NOCFG | M_OPT_FIXED },
OPT_FLAG("shuffle", shuffle, CONF_GLOBAL | CONF_NOCFG),
// ------------------------- common options --------------------
OPT_FLAG("quiet", quiet, CONF_GLOBAL),
OPT_FLAG_STORE("really-quiet", verbose, CONF_GLOBAL | CONF_PRE_PARSE, -10),
OPT_FLAG("terminal", use_terminal, CONF_GLOBAL | CONF_PRE_PARSE),
OPT_GENERAL(char*, "msglevel", msglevels, CONF_GLOBAL|CONF_PRE_PARSE,
.type = &m_option_type_msglevels),
OPT_STRING("dump-stats", dump_stats, CONF_GLOBAL | CONF_PRE_PARSE),
OPT_FLAG("msgcolor", msg_color, CONF_GLOBAL | CONF_PRE_PARSE),
OPT_FLAG("msgmodule", msg_module, CONF_GLOBAL),
OPT_FLAG("msgtime", msg_time, CONF_GLOBAL),
OPT_FLAG("identify", msg_identify, CONF_GLOBAL),
#if HAVE_PRIORITY
{"priority", &proc_priority, CONF_TYPE_STRING, 0, 0, 0, NULL},
#endif
#include "idx.h"
#include "config.h"
#include "auto_version.h"
const char FATAL[] = "ezmlm-list: fatal: ";
const char USAGE[] =
"ezmlm-list: usage: ezmlm-list [-mMnNvV] dir [subdir]";
static int flagnumber = 0; /* default list subscribers, not number of */
static const char *flagsubdb = 0;
static struct option options[] = {
OPT_CSTR_FLAG(flagsubdb,'m',0,0),
OPT_CSTR_FLAG(flagsubdb,'M',"std",0),
OPT_CSTR(flagsubdb,'S',0),
OPT_FLAG(flagnumber,'n',1,0),
OPT_FLAG(flagnumber,'N',0,0),
OPT_END
};
static void die_write(void)
{
strerr_die2sys(111,FATAL,MSG(ERR_WRITE_STDOUT));
}
static int subwrite(const char *s,unsigned int l)
{
return substdio_put(subfdout,s,l) | substdio_put(subfdout,"\n",1);
}
static int dummywrite(const char *s,unsigned int l)
