void MpvHandler::LoadOsdSize() { if(mpv) { mpv_get_property(mpv, "osd-width", MPV_FORMAT_INT64, &osdWidth); mpv_get_property(mpv, "osd-height", MPV_FORMAT_INT64, &osdHeight); } }
void MpvHandler::LoadVideoParams() { 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 MainWindow::handle_mpv_event(mpv_event *event) { switch (event->event_id) { case MPV_EVENT_PROPERTY_CHANGE: { mpv_event_property *prop = (mpv_event_property *)event->data; if (strcmp(prop->name, "time-pos") == 0) { if (prop->format == MPV_FORMAT_DOUBLE) { double time = *(double *)prop->data; std::stringstream ss; ss << "At: " << time; statusBar()->showMessage(QString::fromStdString(ss.str())); } else if (prop->format == MPV_FORMAT_NONE) { // The property is unavailable, which probably means playback // was stopped. statusBar()->showMessage(""); } } break; } case MPV_EVENT_VIDEO_RECONFIG: { // Retrieve the new video size. int64_t w, h; if (mpv_get_property(mpv, "dwidth", MPV_FORMAT_INT64, &w) >= 0 && mpv_get_property(mpv, "dheight", MPV_FORMAT_INT64, &h) >= 0 && w > 0 && h > 0) { // Force Qt to resize the mpv window to video size. You probably // want to do something more sophisticated here, because: // A) it prevents the user from making the window smaller for no // reason (I was unsure how to make Qt do the right thing) // B) the MPV_EVENT_VIDEO_RECONFIG event doesn't necessarily imply // a resize, and you should check yourself if the video // dimensions really changed // mpv itself will scale/letter box the video to the container size // if the video doesn't fit. mpv_container->setMinimumSize(w, h); } break; } case MPV_EVENT_SHUTDOWN: { mpv_terminate_destroy(mpv); mpv = NULL; break; } default: ; // Ignore uninteresting or unknown events. } }
void VideoPlayer::updateTime() { double t; mpv_get_property(mpv, "time-pos", MPV_FORMAT_DOUBLE, &t); TimePosition = t * 1000; Q_EMIT positionChanged(TimePosition); }
void MpvHandler::LoadChapters() { fileInfo.chapters.clear(); mpv_node node; mpv_get_property(mpv, "chapter-list", MPV_FORMAT_NODE, &node); if(node.format == MPV_FORMAT_NODE_ARRAY) { for(int i = 0; i < node.u.list->num; i++) { if(node.u.list->values[i].format == MPV_FORMAT_NODE_MAP) { Mpv::Chapter ch; for(int n = 0; n < node.u.list->values[i].u.list->num; n++) { if(QString(node.u.list->values[i].u.list->keys[n]) == "title") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING) ch.title = node.u.list->values[i].u.list->values[n].u.string; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "time") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_DOUBLE) ch.time = (int)node.u.list->values[i].u.list->values[n].u.double_; } } fileInfo.chapters.push_back(ch); } } } emit chaptersChanged(fileInfo.chapters); }
void MpvHandler::LoadMetadata() { fileInfo.metadata.clear(); mpv_node node; mpv_get_property(mpv, "metadata", MPV_FORMAT_NODE, &node); if(node.format == MPV_FORMAT_NODE_MAP) for(int n = 0; n < node.u.list->num; n++) if(node.u.list->values[n].format == MPV_FORMAT_STRING) fileInfo.metadata[node.u.list->keys[n]] = node.u.list->values[n].u.string; }
void TimeUpdater::run() { double val; int TimePosition; while(true) { usleep(10); mpv_get_property(mpv, "time-pos", MPV_FORMAT_DOUBLE, &val); TimePosition = val * 1000; emit timeChanged(TimePosition); } }
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::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); }
static void mpv_prop_change_handler(GmpvMpvObj *mpv, mpv_event_property* prop) { g_debug("Received mpv property change event for \"%s\"", prop->name); if(g_strcmp0(prop->name, "pause") == 0) { gboolean idle; mpv->state.paused = prop->data?*((int *)prop->data):TRUE; mpv_get_property(mpv->mpv_ctx, "idle", MPV_FORMAT_FLAG, &idle); if(idle && !mpv->state.paused) { gmpv_mpv_obj_load(mpv, NULL, FALSE, TRUE); } } }
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); }
gboolean gmpv_mpv_obj_get_property_flag(GmpvMpvObj *mpv, const gchar *name) { gboolean value = FALSE; gint rc = MPV_ERROR_UNINITIALIZED; if(mpv->mpv_ctx) { rc = mpv_get_property (mpv->mpv_ctx, name, MPV_FORMAT_FLAG, &value); } if(rc < 0) { g_info( "Failed to retrieve property \"%s\" as flag. " "Reason: %s.", name, mpv_error_string(rc) ); } return value; }
gint gmpv_mpv_obj_get_property( GmpvMpvObj *mpv, const gchar *name, mpv_format format, void *data ) { gint rc = MPV_ERROR_UNINITIALIZED; if(mpv->mpv_ctx) { rc = mpv_get_property(mpv->mpv_ctx, name, format, data); } if(rc < 0) { g_info( "Failed to retrieve property \"%s\" " "using mpv format %d. Reason: %s.", name, format, mpv_error_string(rc) ); } return rc; }
gboolean update_seek_bar(gpointer data) { gmpv_handle *ctx = data; gdouble time_pos; gint rc; rc = mpv_get_property( ctx->mpv_ctx, "time-pos", MPV_FORMAT_DOUBLE, &time_pos ); if(rc >= 0) { ControlBox *control_box = CONTROL_BOX(ctx->gui->control_box); gtk_range_set_value ( GTK_RANGE(control_box->seek_bar), time_pos ); } return TRUE; }
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); }
bool KNMusicBackendMpvThread::event(QEvent *event) { //Check out the event type. if(event->type()==QEvent::User) { //Get all the event until there no event. while(m_mpvHandle) { //Get the mpv event. mpv_event *mpvEvent=mpv_wait_event(m_mpvHandle, 0); //Check out the event pointer. if(mpvEvent==nullptr || MPV_EVENT_NONE == mpvEvent->event_id) { //All the event has been processed. break; } //Check out whether there's an error occurs. if(mpvEvent->error < 0) { //!FIXME: Do something here. } switch(mpvEvent->event_id) { case MPV_EVENT_PROPERTY_CHANGE: { //Cast the mpv event data to event property. mpv_event_property *prop=(mpv_event_property *)mpvEvent->data; //Check out the property name. // From bakamplayer: // playback-time does the same thing as time-pos but works for // streaming media if(strcmp(prop->name, "time-pos") == 0) { //Cehck the format. if(MPV_FORMAT_DOUBLE==prop->format) { //Output the playback time. emit positionChanged((qint64)((*(double *)prop->data)*1000.0)-m_startPosition); } } //Mission finished. break; } //This event is totally different, though I don't know why. //BakaMPlayer says it is. case MPV_EVENT_START_FILE: { break; } case MPV_EVENT_FILE_LOADED: { //Pause it right after the file loaded. pause(); //Reset the playing state. m_state=MusicUtil::Stopped; //Emit the state changed signal. emit stateChanged(m_state); //We have to update all the file inforamtion here. //Get the duration of the file. double mediaDuration; //Get the property. mpv_get_property(m_mpvHandle, "length", MPV_FORMAT_DOUBLE, &mediaDuration); //Save the total duration. qint64 propertyDuration=(qint64)(mediaDuration*1000.0); //Check property duration if(propertyDuration>0) { //For valid duration. m_totalDuration=propertyDuration; //Update the end position. checkStartAndEndPosition(); //Emit the loaded signal. emit loadSuccess(); } //Mission complete. break; } case MPV_EVENT_PAUSE: { //We should save the state as pause. //We may never have stop. m_state=MusicUtil::Paused; //Emit the state changed signal. emit stateChanged(m_state); break; } case MPV_EVENT_UNPAUSE: { //We should save the state as playing. m_state=MusicUtil::Playing; //Emit the state changed signal. emit stateChanged(m_state); //Sync the playing volume. setVolume(m_volumeSize); break; } case MPV_EVENT_END_FILE: { //It should be stopped. m_state=MusicUtil::Stopped; //Emit the state changed signal. emit stateChanged(m_state); break; } } } } //For others, do the defualt event. return KNMusicStandardBackendThread::event(event); }
void gmpv_mpv_obj_reset(GmpvMpvObj *mpv) { const gchar *quit_cmd[] = {"quit_watch_later", NULL}; gchar *loop_str; gboolean loop; gint64 playlist_pos; gint playlist_pos_rc; g_assert(mpv->mpv_ctx); loop_str = gmpv_mpv_obj_get_property_string(mpv, "loop"); loop = (g_strcmp0(loop_str, "inf") == 0); mpv_free(loop_str); playlist_pos_rc = mpv_get_property( mpv->mpv_ctx, "playlist-pos", MPV_FORMAT_INT64, &playlist_pos ); /* Reset mpv->mpv_ctx */ mpv->state.ready = FALSE; mpv_check_error(gmpv_mpv_obj_command(mpv, quit_cmd)); gmpv_mpv_obj_quit(mpv); mpv->mpv_ctx = mpv_create(); gmpv_mpv_obj_initialize(mpv); gmpv_mpv_obj_set_event_callback ( mpv, mpv->event_callback, mpv->event_callback_data ); gmpv_mpv_obj_set_opengl_cb_callback ( mpv, mpv->opengl_cb_callback, mpv->opengl_cb_callback_data ); gmpv_mpv_obj_set_property_string(mpv, "loop", loop?"inf":"no"); if(mpv->playlist) { if(mpv->state.loaded) { gint rc; rc = mpv_request_event (mpv->mpv_ctx, MPV_EVENT_FILE_LOADED, 0); mpv_check_error(rc); gmpv_mpv_obj_load(mpv, NULL, FALSE, TRUE); rc = mpv_request_event (mpv->mpv_ctx, MPV_EVENT_FILE_LOADED, 1); mpv_check_error(rc); } if(playlist_pos_rc >= 0 && playlist_pos > 0) { gmpv_mpv_obj_set_property( mpv, "playlist-pos", MPV_FORMAT_INT64, &playlist_pos ); } gmpv_mpv_obj_set_property( mpv, "pause", MPV_FORMAT_FLAG, &mpv->state.paused ); } }
static void mpv_obj_update_playlist(GmpvMpvObj *mpv) { /* The length of "playlist//filename" including null-terminator (19) * plus the number of digits in the maximum value of 64 bit int (19). */ const gsize filename_prop_str_size = 38; GtkListStore *store = gmpv_playlist_get_store(mpv->playlist); gchar *filename_prop_str = g_malloc(filename_prop_str_size); gboolean iter_end = FALSE; GtkTreeIter iter; mpv_node mpv_playlist; gint playlist_count; gint i; mpv_check_error(mpv_get_property( mpv->mpv_ctx, "playlist", MPV_FORMAT_NODE, &mpv_playlist )); playlist_count = mpv_playlist.u.list->num; gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter); for(i = 0; i < playlist_count; i++) { mpv_node_list *prop_list = mpv_playlist.u.list->values[i].u.list; gchar *uri = NULL; gchar *title = NULL; gchar *name = NULL; for(gint j = 0; j < prop_list->num; j++) { const gchar *key = prop_list->keys[j]; const mpv_node value = prop_list->values[j]; if(g_strcmp0(key, "filename") == 0) { g_assert(value.format == MPV_FORMAT_STRING); uri = value.u.string; } else if(g_strcmp0(key, "title") == 0) { g_assert(value.format == MPV_FORMAT_STRING); title = value.u.string; } } name = title?g_strdup(title):get_name_from_path(uri); /* Overwrite current entry if it doesn't match the new value */ if(!iter_end) { gchar *old_name = NULL; gchar *old_uri = NULL; gboolean name_update; gboolean uri_update; gtk_tree_model_get ( GTK_TREE_MODEL(store), &iter, PLAYLIST_NAME_COLUMN, &old_name, PLAYLIST_URI_COLUMN, &old_uri, -1 ); name_update = (g_strcmp0(name, old_name) != 0); uri_update = (g_strcmp0(uri, old_uri) != 0); /* Only set the name if either the title can be * retrieved or the name is unset. This preserves the * correct title if it becomes unavailable later such as * when restarting mpv. */ if(name_update && (!old_name || title || uri_update)) { gtk_list_store_set ( store, &iter, PLAYLIST_NAME_COLUMN, name, -1 ); } if(uri_update) { gtk_list_store_set ( store, &iter, PLAYLIST_URI_COLUMN, uri, -1 ); } iter_end = !gtk_tree_model_iter_next (GTK_TREE_MODEL(store), &iter); g_free(old_name); g_free(old_uri); } /* Append entries to the playlist if there are fewer entries in * the playlist widget than mpv's playlist. */ else { gmpv_playlist_append(mpv->playlist, name, uri); } g_free(name); } /* If there are more entries in the playlist widget than mpv's playlist, * remove the excess entries from the playlist widget. */ if(!iter_end) { while(gtk_list_store_remove(store, &iter)); } g_free(filename_prop_str); mpv_free_node_contents(&mpv_playlist); }
void MpvHandler::LoadTracks() { fileInfo.tracks.clear(); mpv_node node; mpv_get_property(mpv, "track-list", MPV_FORMAT_NODE, &node); if(node.format == MPV_FORMAT_NODE_ARRAY) { for(int i = 0; i < node.u.list->num; i++) { if(node.u.list->values[i].format == MPV_FORMAT_NODE_MAP) { Mpv::Track track; for(int n = 0; n < node.u.list->values[i].u.list->num; n++) { if(QString(node.u.list->values[i].u.list->keys[n]) == "id") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_INT64) track.id = node.u.list->values[i].u.list->values[n].u.int64; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "type") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING) track.type = node.u.list->values[i].u.list->values[n].u.string; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "src-id") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_INT64) track.src_id = node.u.list->values[i].u.list->values[n].u.int64; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "title") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING) track.title = node.u.list->values[i].u.list->values[n].u.string; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "lang") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING) track.lang = node.u.list->values[i].u.list->values[n].u.string; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "albumart") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG) track.albumart = node.u.list->values[i].u.list->values[n].u.flag; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "default") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG) track._default = node.u.list->values[i].u.list->values[n].u.flag; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "external") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_FLAG) track.external = node.u.list->values[i].u.list->values[n].u.flag; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "external-filename") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING) track.external_filename = node.u.list->values[i].u.list->values[n].u.string; } else if(QString(node.u.list->values[i].u.list->keys[n]) == "codec") { if(node.u.list->values[i].u.list->values[n].format == MPV_FORMAT_STRING) track.codec = node.u.list->values[i].u.list->values[n].u.string; } } fileInfo.tracks.push_back(track); } } } emit trackListChanged(fileInfo.tracks); }
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_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); }