void MpvHandler::LoadVideoParams()
{
fileInfo.video_params.codec = mpv_get_property_string(mpv, "video-codec");
mpv_get_property(mpv, "width", MPV_FORMAT_INT64, &fileInfo.video_params.width);
mpv_get_property(mpv, "height", MPV_FORMAT_INT64, &fileInfo.video_params.height);
mpv_get_property(mpv, "dwidth", MPV_FORMAT_INT64, &fileInfo.video_params.dwidth);
mpv_get_property(mpv, "dheight", MPV_FORMAT_INT64, &fileInfo.video_params.dheight);
// though this has become useless, removing it causes a segfault--no clue:
mpv_get_property(mpv, "video-aspect", MPV_FORMAT_INT64, &fileInfo.video_params.aspect);
emit videoParamsChanged(fileInfo.video_params);
}
void MpvHandler::LoadFileInfo()
{
// get media-title
fileInfo.media_title = mpv_get_property_string(mpv, "media-title");
// get length
double len;
mpv_get_property(mpv, "length", MPV_FORMAT_DOUBLE, &len);
fileInfo.length = (int)len;
fileInfo.video_params.codec = mpv_get_property_string(mpv, "video-codec");
fileInfo.audio_params.codec = mpv_get_property_string(mpv, "audio-codec");
fileInfo.audio_params.samplerate = mpv_get_property_string(mpv, "audio-samplerate");
fileInfo.audio_params.channels = mpv_get_property_string(mpv, "audio-channels");
LoadTracks();
LoadChapters();
LoadVideoParams();
LoadMetadata();
emit fileInfoChanged(fileInfo);
}
void gmpv_mpv_opt_handle_geometry(GmpvMpv *mpv)
{
gchar *opt_buf;
opt_buf = mpv_get_property_string
(mpv->mpv_ctx, "options/geometry");
if(opt_buf)
{
parse_geom_string(mpv, opt_buf, &mpv->geometry);
mpv_free(opt_buf);
}
}
gchar *gmpv_mpv_obj_get_property_string(GmpvMpvObj *mpv, const gchar *name)
{
gchar *value = NULL;
if(mpv->mpv_ctx)
{
value = mpv_get_property_string(mpv->mpv_ctx, name);
}
if(!value)
{
g_info("Failed to retrieve property \"%s\" as string.", name);
}
return value;
}
void MpvHandler::LoadFileInfo()
{
// get media-title
fileInfo.media_title = mpv_get_property_string(mpv, "media-title");
// get length
double len;
mpv_get_property(mpv, "length", MPV_FORMAT_DOUBLE, &len);
fileInfo.length = (int)len;
LoadTracks();
LoadChapters();
LoadVideoParams();
LoadAudioParams();
LoadMetadata();
emit fileInfoChanged(fileInfo);
}
void MpvHandler::Interpolate(bool interpolate)
{
if(vo == QString())
vo = mpv_get_property_string(mpv, "current-vo");
QStringList vos = vo.split(',');
for(auto &o : vos)
{
int i = o.indexOf(":interpolation");
if(interpolate && i == -1)
o.append(":interpolation");
else if(i != -1)
o.remove(i, QString(":interpolation").length());
}
setVo(vos.join(','));
SetOption("vo", vo);
ShowText(tr("Motion Interpolation: %0").arg(interpolate ? tr("enabled") : tr("disabled")));
}
void resize_window_to_fit(gmpv_handle *ctx, gdouble multiplier)
{
gchar *video = mpv_get_property_string(ctx->mpv_ctx, "video");
gint64 width;
gint64 height;
gint mpv_width_rc;
gint mpv_height_rc;
mpv_width_rc = mpv_get_property( ctx->mpv_ctx,
"dwidth",
MPV_FORMAT_INT64,
&width );
mpv_height_rc = mpv_get_property( ctx->mpv_ctx,
"dheight",
MPV_FORMAT_INT64,
&height );
if(video
&& strncmp(video, "no", 3) != 0
&& mpv_width_rc >= 0
&& mpv_height_rc >= 0)
{
gint width_margin;
gint height_margin;
gint new_width;
gint new_height;
width_margin = main_window_get_width_margin(ctx->gui);
height_margin = main_window_get_height_margin(ctx->gui);
new_width = (gint)(multiplier*(gdouble)width)+width_margin;
new_height = (gint)(multiplier*(gdouble)height)+height_margin;
gtk_window_resize( GTK_WINDOW(ctx->gui),
new_width,
new_height );
}
mpv_free(video);
}
void MpvHandler::LoadAudioParams()
{
fileInfo.audio_params.codec = mpv_get_property_string(mpv, "audio-codec");
mpv_node node;
mpv_get_property(mpv, "audio-params", MPV_FORMAT_NODE, &node);
if(node.format == MPV_FORMAT_NODE_MAP)
{
for(int i = 0; i < node.u.list->num; i++)
{
if(QString(node.u.list->keys[i]) == "samplerate")
{
if(node.u.list->values[i].format == MPV_FORMAT_INT64)
fileInfo.audio_params.samplerate = node.u.list->values[i].u.int64;
}
else if(QString(node.u.list->keys[i]) == "channel-count")
{
if(node.u.list->values[i].format == MPV_FORMAT_INT64)
fileInfo.audio_params.channels = node.u.list->values[i].u.int64;
}
}
}
emit audioParamsChanged(fileInfo.audio_params);
}
QString MpvHandler::getMediaInfo()
{
QFileInfo fi(path+file);
double avsync, fps, vbitrate, abitrate;
mpv_get_property(mpv, "avsync", MPV_FORMAT_DOUBLE, &avsync);
mpv_get_property(mpv, "estimated-vf-fps", MPV_FORMAT_DOUBLE, &fps);
mpv_get_property(mpv, "video-bitrate", MPV_FORMAT_DOUBLE, &vbitrate);
mpv_get_property(mpv, "audio-bitrate", MPV_FORMAT_DOUBLE, &abitrate);
QString current_vo = mpv_get_property_string(mpv, "current-vo"),
current_ao = mpv_get_property_string(mpv, "current-ao"),
hwdec_active = mpv_get_property_string(mpv, "hwdec-active");
int vtracks = 0,
atracks = 0;
for(auto &track : fileInfo.tracks)
{
if(track.type == "video")
++vtracks;
else if(track.type == "audio")
++atracks;
}
const QString outer = "%0: %1\n", inner = " %0: %1\n";
QString out = outer.arg(tr("File"), fi.fileName()) +
inner.arg(tr("Title"), fileInfo.media_title) +
inner.arg(tr("File size"), Util::HumanSize(fi.size())) +
inner.arg(tr("Date created"), fi.created().toString()) +
inner.arg(tr("Media length"), Util::FormatTime(fileInfo.length, fileInfo.length)) + '\n';
if(fileInfo.video_params.codec != QString())
out += outer.arg(tr("Video (x%0)").arg(QString::number(vtracks)), fileInfo.video_params.codec) +
inner.arg(tr("Video Output"), QString("%0 (hwdec %1)").arg(current_vo, hwdec_active)) +
inner.arg(tr("Resolution"), QString("%0 x %1 (%2)").arg(QString::number(fileInfo.video_params.width),
QString::number(fileInfo.video_params.height),
Util::Ratio(fileInfo.video_params.width, fileInfo.video_params.height))) +
inner.arg(tr("FPS"), QString::number(fps)) +
inner.arg(tr("A/V Sync"), QString::number(avsync)) +
inner.arg(tr("Bitrate"), tr("%0 kbps").arg(vbitrate)) + '\n';
if(fileInfo.audio_params.codec != QString())
out += outer.arg(tr("Audio (x%0)").arg(QString::number(atracks)), fileInfo.audio_params.codec) +
inner.arg(tr("Audio Output"), current_ao) +
inner.arg(tr("Sample Rate"), QString::number(fileInfo.audio_params.samplerate)) +
inner.arg(tr("Channels"), QString::number(fileInfo.audio_params.channels)) +
inner.arg(tr("Bitrate"), tr("%0 kbps").arg(abitrate)) + '\n';
if(fileInfo.chapters.length() > 0)
{
out += outer.arg(tr("Chapters"), QString());
int n = 1;
for(auto &chapter : fileInfo.chapters)
out += inner.arg(QString::number(n++), chapter.title);
out += '\n';
}
if(fileInfo.metadata.size() > 0)
{
out += outer.arg(tr("Metadata"), QString());
for(auto data = fileInfo.metadata.begin(); data != fileInfo.metadata.end(); ++data)
out += inner.arg(data.key(), *data);
out += '\n';
}
return out;
}
void gmpv_mpv_opt_handle_msg_level(GmpvMpv *mpv)
{
const struct
{
gchar *name;
mpv_log_level level;
}
level_map[] = { {"no", MPV_LOG_LEVEL_NONE},
{"fatal", MPV_LOG_LEVEL_FATAL},
{"error", MPV_LOG_LEVEL_ERROR},
{"warn", MPV_LOG_LEVEL_WARN},
{"info", MPV_LOG_LEVEL_INFO},
{"v", MPV_LOG_LEVEL_V},
{"debug", MPV_LOG_LEVEL_DEBUG},
{"trace", MPV_LOG_LEVEL_TRACE},
{NULL, MPV_LOG_LEVEL_NONE} };
gchar *optbuf = NULL;
gchar **tokens = NULL;
mpv_log_level min_level = DEFAULT_LOG_LEVEL;
gint i;
optbuf = mpv_get_property_string(mpv->mpv_ctx, "options/msg-level");
if(optbuf)
{
tokens = g_strsplit(optbuf, ",", 0);
}
if(mpv->log_level_list)
{
g_slist_free_full(mpv->log_level_list, g_free);
mpv->log_level_list = NULL;
}
for(i = 0; tokens && tokens[i]; i++)
{
gchar **pair = g_strsplit(tokens[i], "=", 2);
module_log_level *level = g_malloc(sizeof(module_log_level));
gboolean found = FALSE;
gint j;
level->prefix = g_strdup(pair[0]);
for(j = 0; level_map[j].name && !found; j++)
{
if(g_strcmp0(pair[1], level_map[j].name) == 0)
{
level->level = level_map[j].level;
found = TRUE;
}
}
/* Ignore if the given level is invalid */
if(found)
{
/* Lower log levels have higher values */
if(level->level > min_level)
{
min_level = level->level;
}
if(g_strcmp0(level->prefix, "all") != 0)
{
mpv->log_level_list
= g_slist_append
(mpv->log_level_list, level);
}
}
g_strfreev(pair);
}
for(i = 0; level_map[i].level != min_level; i++);
mpv_check_error
(mpv_request_log_messages(mpv->mpv_ctx, level_map[i].name));
mpv_free(optbuf);
g_strfreev(tokens);
}
void gmpv_mpv_opt_handle_autofit(GmpvMpv *mpv)
{
gchar *scale_str = NULL;
gchar *autofit_str = NULL;
gchar *larger_str = NULL;
gchar *smaller_str = NULL;
gboolean scale_set = FALSE;
gboolean autofit_set = FALSE;
gboolean larger_set = FALSE;
gboolean smaller_set = FALSE;
scale_str = mpv_get_property_string
(mpv->mpv_ctx, "options/window-scale");
autofit_str = mpv_get_property_string
(mpv->mpv_ctx, "options/autofit");
larger_str = mpv_get_property_string
(mpv->mpv_ctx, "options/autofit-larger");
smaller_str = mpv_get_property_string
(mpv->mpv_ctx, "options/autofit-smaller");
scale_set = scale_str && scale_str[0] != '\0';
autofit_set = autofit_str && autofit_str[0] != '\0';
larger_set = larger_str && larger_str[0] != '\0';
smaller_set = smaller_str && smaller_str[0] != '\0';
if(scale_set || autofit_set || larger_set || smaller_set)
{
gint64 larger_dim[2] = {G_MAXINT, G_MAXINT};
gint64 smaller_dim[2] = {0, 0};
gint64 autofit_dim[2] = {0, 0};
gint64 vid_dim[2];
gdouble ratio[2];
gdouble scale = 1;
gint rc = 0;
rc |= mpv_get_property( mpv->mpv_ctx,
"dwidth",
MPV_FORMAT_INT64,
&vid_dim[0] );
rc |= mpv_get_property( mpv->mpv_ctx,
"dheight",
MPV_FORMAT_INT64,
&vid_dim[1] );
if(rc >= 0)
{
g_debug( "Retrieved video size: "
"%" G_GINT64_FORMAT "x"
"%" G_GINT64_FORMAT,
vid_dim[0], vid_dim[1] );
}
if(rc >= 0 && scale_set)
{
g_debug( "Retrieved option --window-scale=%s",
scale_str);
/* This should never fail since mpv_set_option() will
* refuse to set invalid values.
*/
scale = g_ascii_strtod(scale_str, NULL);
}
if(rc >= 0 && larger_set)
{
g_debug( "Retrieved option --autofit-larger=%s",
larger_str);
parse_dim_string(larger_str, larger_dim);
}
if(rc >= 0 && smaller_set)
{
g_debug( "Retrieved option --autofit-smaller=%s",
smaller_str);
parse_dim_string(smaller_str, smaller_dim);
}
if(rc >= 0)
{
if(autofit_set)
{
g_debug( "Retrieved option --autofit=%s",
autofit_str );
parse_dim_string(autofit_str, autofit_dim);
}
else
{
autofit_dim[0] = vid_dim[0];
autofit_dim[1] = vid_dim[1];
}
if(scale_set)
{
autofit_dim[0]
= (gint64)(scale*(gdouble)autofit_dim[0]);
autofit_dim[1]
= (gint64)(scale*(gdouble)autofit_dim[1]);
}
}
if(rc >= 0)
{
autofit_dim[0] = MIN(autofit_dim[0], larger_dim[0]);
autofit_dim[1] = MIN(autofit_dim[1], larger_dim[1]);
autofit_dim[0] = MAX(autofit_dim[0], smaller_dim[0]);
autofit_dim[1] = MAX(autofit_dim[1], smaller_dim[1]);
if(!autofit_set
&& autofit_dim[0] == vid_dim[0]
&& autofit_dim[1] == vid_dim[1])
{
/* Do not resize if --autofit is not set and the
* video size does not exceed the limits imposed
* by --autofit-larger and --autofit-smaller.
*/
ratio[0] = scale_set?scale:0;
ratio[1] = scale_set?scale:0;
}
else
{
g_debug( "Target video area size: "
"%" G_GINT64_FORMAT
"x%" G_GINT64_FORMAT,
autofit_dim[0], autofit_dim[1] );
ratio[0] = (gdouble)autofit_dim[0]/
(gdouble)vid_dim[0];
ratio[1] = (gdouble)autofit_dim[1]/
(gdouble)vid_dim[1];
}
}
if(rc >= 0 && ratio[0] > 0 && ratio[1] > 0)
{
/* Resize the window so that it is as big as possible
* while preseving the aspect ratio.
*/
mpv->autofit_ratio = MIN(ratio[0], ratio[1]);
g_debug( "Set video size multiplier to %f",
mpv->autofit_ratio );
}
else
{
mpv->autofit_ratio = -1;
}
}
mpv_free(scale_str);
mpv_free(autofit_str);
mpv_free(larger_str);
mpv_free(smaller_str);
}
