Ottieni miniature img da Vimeo?
https://stackoverflow.com/questions/1361149
-
20-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Voglio ottenere un'immagine in miniatura per i video da Vimeo.
Quando ricevo immagini da Youtube faccio semplicemente così:
http://img.youtube.com/vi/HwP5NG-3e8I/2.jpg
Qualche idea su come fare per Vimeo?
Soluzione
Dal Documenti API Vimeo semplici:
Effettuare una richiesta video
Per ottenere dati su un video specifico, utilizzare il seguente URL:
http://vimeo.com/api/v2/video/video_id.output
video_id L'ID del video per il quale desideri informazioni.
produzione Specificare il tipo di output.Attualmente offriamo formati JSON, PHP e XML.
Quindi ottieni questo URL http://vimeo.com/api/v2/video/6271487.xml
<videos>
<video>
[skipped]
<thumbnail_small>http://ts.vimeo.com.s3.amazonaws.com/235/662/23566238_100.jpg</thumbnail_small>
<thumbnail_medium>http://ts.vimeo.com.s3.amazonaws.com/235/662/23566238_200.jpg</thumbnail_medium>
<thumbnail_large>http://ts.vimeo.com.s3.amazonaws.com/235/662/23566238_640.jpg</thumbnail_large>
[skipped]
</videos>
Analizzalo per ogni video per ottenere la miniatura
Ecco il codice approssimativo in PHP
<?php
$imgid = 6271487;
$hash = unserialize(file_get_contents("http://vimeo.com/api/v2/video/$imgid.php"));
echo $hash[0]['thumbnail_medium'];
Altri suggerimenti
In javascript (utilizza jQuery):
function vimeoLoadingThumb(id){
var url = "http://vimeo.com/api/v2/video/" + id + ".json?callback=showThumb";
var id_img = "#vimeo-" + id;
var script = document.createElement( 'script' );
script.src = url;
$(id_img).before(script);
}
function showThumb(data){
var id_img = "#vimeo-" + data[0].id;
$(id_img).attr('src',data[0].thumbnail_medium);
}
Per visualizzarla:
<img id="vimeo-{{ video.id_video }}" src="" alt="{{ video.title }}" />
<script type="text/javascript">
vimeoLoadingThumb({{ video.id_video }});
</script>
Utilizzando richiesta jQuery jsonp:
<script type="text/javascript">
$.ajax({
type:'GET',
url: 'http://vimeo.com/api/v2/video/' + video_id + '.json',
jsonp: 'callback',
dataType: 'jsonp',
success: function(data){
var thumbnail_src = data[0].thumbnail_large;
$('#thumb_wrapper').append('<img src="' + thumbnail_src + '"/>');
}
});
</script>
<div id="thumb_wrapper"></div>
Si dovrebbe analizzare la risposta API di Vimeo. Non c'è modo ad essa con chiamate URL (come Dailymotion o YouTube).
Ecco la mia soluzione PHP:
/**
* Gets a vimeo thumbnail url
* @param mixed $id A vimeo id (ie. 1185346)
* @return thumbnail's url
*/
function getVimeoThumb($id) {
$data = file_get_contents("http://vimeo.com/api/v2/video/$id.json");
$data = json_decode($data);
return $data[0]->thumbnail_medium;
}
Con Ruby, è possibile effettuare le seguenti operazioni se si dispone, dice:
url = "http://www.vimeo.com/7592893"
vimeo_video_id = url.scan(/vimeo.com\/(\d+)\/?/).flatten.to_s # extract the video id
vimeo_video_json_url = "http://vimeo.com/api/v2/video/%s.json" % vimeo_video_id # API call
# Parse the JSON and extract the thumbnail_large url
thumbnail_image_location = JSON.parse(open(vimeo_video_json_url).read).first['thumbnail_large'] rescue nil
Ecco un esempio di come fare la stessa cosa in ASP.NET utilizzando C #. Sentitevi liberi di usare un'immagine diversa errore di cattura :)
public string GetVimeoPreviewImage(string vimeoURL)
{
try
{
string vimeoUrl = System.Web.HttpContext.Current.Server.HtmlEncode(vimeoURL);
int pos = vimeoUrl.LastIndexOf(".com");
string videoID = vimeoUrl.Substring(pos + 4, 8);
XmlDocument doc = new XmlDocument();
doc.Load("http://vimeo.com/api/v2/video/" + videoID + ".xml");
XmlElement root = doc.DocumentElement;
string vimeoThumb = root.FirstChild.SelectSingleNode("thumbnail_medium").ChildNodes[0].Value;
string imageURL = vimeoThumb;
return imageURL;
}
catch
{
//cat with cheese on it's face fail
return "http://bestofepicfail.com/wp-content/uploads/2008/08/cheese_fail.jpg";
}
}
NOTA: La tua richiesta API dovrebbe come questo, quando richiesto: http://vimeo.com /api/v2/video/32660708.xml
Il modo più semplice JavaScript che ho trovato per ottenere la miniatura, senza cercare l'ID del Video sta usando:
//Get the video thumbnail via Ajax
$.ajax({
type:'GET',
url: 'https://vimeo.com/api/oembed.json?url=' + encodeURIComponent(url),
dataType: 'json',
success: function(data) {
console.log(data.thumbnail_url);
}
});
Nota: Se qualcuno ha bisogno di ottenere il video delle miniature relative al video id che può sostituire il $id con l'ID del Video e ottenere un XML con i dettagli del video:
http://vimeo.com/api/v2/video/$id.xml
Esempio:
http://vimeo.com/api/v2/video/198340486.xml
Se si desidera utilizzare miniature attraverso js puri / jquery senza api, è possibile utilizzare questo strumento per catturare un fotogramma del video e voilà! Inserire il pollice URL nel quale mai fonte gradite.
Ecco una penna codice:
<img src="https://i.vimeocdn.com/video/531141496_640.jpg"` alt="" />
Ecco il sito per ottenere miniature:
utilizzando l'URL Vimeo ( https://player.vimeo.com/video/30572181 ), ecco il mio esempio
<!DOCTYPE html>
<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="utf-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<script src="http://code.jquery.com/jquery-latest.min.js" type="text/javascript"></script>
<title>Vimeo</title>
</head>
<body>
<div>
<img src="" id="thumbImg">
</div>
<script>
$(document).ready(function () {
var vimeoVideoUrl = 'https://player.vimeo.com/video/30572181';
var match = /vimeo.*\/(\d+)/i.exec(vimeoVideoUrl);
if (match) {
var vimeoVideoID = match[1];
$.getJSON('http://www.vimeo.com/api/v2/video/' + vimeoVideoID + '.json?callback=?', { format: "json" }, function (data) {
featuredImg = data[0].thumbnail_large;
$('#thumbImg').attr("src", featuredImg);
});
}
});
</script>
</body>
</html>
Sembra api / v2 è morto.
Per poter utilizzare la nuova API, devi registrare l'applicazione , e base64 codifica il client_id e client_secret come un'intestazione di autorizzazione.
$.ajax({
type:'GET',
url: 'https://api.vimeo.com/videos/' + video_id,
dataType: 'json',
headers: {
'Authorization': 'Basic ' + window.btoa(client_id + ":" + client_secret);
},
success: function(data) {
var thumbnail_src = data.pictures.sizes[2].link;
$('#thumbImg').attr('src', thumbnail_src);
}
});
Per motivi di sicurezza, è possibile restituire il client_id e client_secret già codificato dal server.
function parseVideo(url) {
// - Supported YouTube URL formats:
// - http://www.youtube.com/watch?v=My2FRPA3Gf8
// - http://youtu.be/My2FRPA3Gf8
// - https://youtube.googleapis.com/v/My2FRPA3Gf8
// - Supported Vimeo URL formats:
// - http://vimeo.com/25451551
// - http://player.vimeo.com/video/25451551
// - Also supports relative URLs:
// - //player.vimeo.com/video/25451551
url.match(/(http:|https:|)\/\/(player.|www.)?(vimeo\.com|youtu(be\.com|\.be|be\.googleapis\.com))\/(video\/|embed\/|watch\?v=|v\/)?([A-Za-z0-9._%-]*)(\&\S+)?/);
if (RegExp.$3.indexOf('youtu') > -1) {
var type = 'youtube';
} else if (RegExp.$3.indexOf('vimeo') > -1) {
var type = 'vimeo';
}
return {
type: type,
id: RegExp.$6
};
}
function getVideoThumbnail(url, cb) {
var videoObj = parseVideo(url);
if (videoObj.type == 'youtube') {
cb('//img.youtube.com/vi/' + videoObj.id + '/maxresdefault.jpg');
} else if (videoObj.type == 'vimeo') {
$.get('http://vimeo.com/api/v2/video/' + videoObj.id + '.json', function(data) {
cb(data[0].thumbnail_large);
});
}
}
In realtà il ragazzo che ha chiesto questa domanda ha postato la sua risposta.
"Vimeo sembrano voler me di fare una richiesta HTTP, ed estrarre l'URL miniatura dalla XML ritornano ..."
La documentazione API Vimeo sono qui: http://vimeo.com/api/docs/ semplice-api
In breve, la vostra applicazione ha bisogno di fare una richiesta GET a un URL simile al seguente:
http://vimeo.com/api/v2/video/video_id.output
e analizzare i dati restituiti per ottenere l'URL delle miniature che si richiede, quindi scaricare il file in quel URL.
ho scritto una funzione in PHP per me lasciare a questo, spero proprio utile a qualcuno. Il percorso per la miniatura è contenuto all'interno di un tag link sulla pagina del video. Questo sembra fare il trucco per me.
$video_url = "http://vimeo.com/7811853"
$file = fopen($video_url, "r");
$filedata = stream_get_contents($file);
$html_content = strpos($filedata,"<link rel=\"videothumbnail");
$link_string = substr($filedata, $html_content, 128);
$video_id_array = explode("\"", $link_string);
$thumbnail_url = $video_id_array[3];
echo $thumbnail_url;
Speranza che aiuta nessuno.
Foggson
function getVimeoInfo($link)
{
if (preg_match('~^http://(?:www\.)?vimeo\.com/(?:clip:)?(\d+)~', $link, $match))
{
$id = $match[1];
}
else
{
$id = substr($link,10,strlen($link));
}
if (!function_exists('curl_init')) die('CURL is not installed!');
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "http://vimeo.com/api/v2/video/$id.php");
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 10);
$output = unserialize(curl_exec($ch));
$output = $output[0];
curl_close($ch);
return $output;
}`
// al di sotto funzione passare l'URL delle miniature.
function save_image_local($thumbnail_url)
{
//for save image at local server
$filename = time().'_hbk.jpg';
$fullpath = '../../app/webroot/img/videos/image/'.$filename;
file_put_contents ($fullpath,file_get_contents($thumbnail_url));
return $filename;
}
Scomporre la risposta di Karthikeyan P in modo che possa essere utilizzata in una gamma più ampia di scenari:
// Requires jQuery
function parseVimeoIdFromUrl(vimeoUrl) {
var match = /vimeo.*\/(\d+)/i.exec(vimeoUrl);
if (match)
return match[1];
return null;
};
function getVimeoThumbUrl(vimeoId) {
var deferred = $.Deferred();
$.ajax(
'//www.vimeo.com/api/v2/video/' + vimeoId + '.json',
{
dataType: 'jsonp',
cache: true
}
)
.done(function (data) {
// .thumbnail_small 100x75
// .thumbnail_medium 200x150
// 640 wide
var img = data[0].thumbnail_large;
deferred.resolve(img);
})
.fail(function(a, b, c) {
deferred.reject(a, b, c);
});
return deferred;
};
Utilizzo
Ottieni un ID Vimeo dall'URL di un video Vimeo:
var vimeoId = parseVimeoIdFromUrl(vimeoUrl);
Ottieni un URL di miniatura Vimeo da un ID Vimeo:
getVimeoThumbUrl(vimeoIds[0])
.done(function(img) {
$('div').append('<img src="' + img + '"/>');
});
Questo è un modo rapido furbo di farlo, e anche un modo per scegliere un formato personalizzato.
Vado qui:
http://vimeo.com/api/v2/video/[VIDEO ID].php
Scarica il file, aprirlo, e trovare i 640 pixel di larghezza delle miniature, avrà un formato in questo modo:
https://i.vimeocdn.com/video/[LONG NUMBER HERE]_640.jpg
Si prende il collegamento, modificare il 640 per - ad esempio - 1400, e si finisce con qualcosa di simile:
https://i.vimeocdn.com/video/[LONG NUMBER HERE]_1400.jpg
Incolla sulla vostra barra di ricerca del browser e godere.
Saluti,
Se non avete bisogno di una soluzione automatizzata, è possibile trovare l'URL delle miniature inserendo l'ID vimeo qui: http: //video.depone.eu/
UPDATE: Questa soluzione ha smesso di funzionare a partire dal dicembre 2018
.che stavo cercando la stessa cosa e sembra che la maggior parte delle risposte qui sono obsoleti a causa di Vimeo API v2 essere sconsigliato.
il mio php 2 ¢:
$vidID = 12345 // Vimeo Video ID
$tnLink = json_decode(file_get_contents('https://vimeo.com/api/oembed.json?url=https%3A//vimeo.com/' . $vidID))->thumbnail_url;
con quanto sopra si otterrà il link immagine predefinita delle miniature Vimeo a.
Se si desidera utilizzare immagini diverse dimensioni, è possibile aggiungere qualcosa come:
$tnLink = substr($tnLink, strrpos($tnLink, '/') + 1);
$tnLink = substr($tnLink, 0, strrpos($tnLink, '_')); // You now have the thumbnail ID, which is different from Video ID
// And you can use it with link to one of the sizes of crunched by Vimeo thumbnail image, for example:
$tnLink = 'https://i.vimeocdn.com/filter/overlay?src0=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F' . $tnLink . '_1280x720.jpg&src1=https%3A%2F%2Ff.vimeocdn.com%2Fimages_v6%2Fshare%2Fplay_icon_overlay.png';
Se siete alla ricerca di una soluzione alternativa e possibile gestire l'account vimeo c'è un altro modo, è sufficiente aggiungere tutti i video che si desidera visualizzare in un album e quindi utilizzare l'API per richiedere i dettagli dell'album - è mostra allora tutta la miniature e collegamenti. Non è l'ideale, ma potrebbe aiutare.
Si potrebbe voler dare un'occhiata al gioiello di Matt Hooks. https://github.com/matthooks/vimeo
Si prevede un semplice involucro Vimeo per l'API.
Tutto quello che serve è quello di memorizzare il video_id (e il fornitore se si sta anche facendo altri siti di video)
È possibile estrarre il video Vimeo id in questo modo
def
get_vimeo_video_id (link)
vimeo_video_id = nil
vimeo_regex = /http:\/\/(www\.)?vimeo.com\/(\d+)($|\/)/
vimeo_match = vimeo_regex.match(link)
if vimeo_match.nil?
vimeo_regex = /http:\/\/player.vimeo.com\/video\/([a-z0-9-]+)/
vimeo_match = vimeo_regex.match(link)
end
vimeo_video_id = vimeo_match[2] unless vimeo_match.nil?
return vimeo_video_id
end
e se avete bisogno di tubo si potrebbe trovare questo utile
def
get_youtube_video_id (link)
youtube_video_id = nil
youtube_regex = /^(https?:\/\/)?(www\.)?youtu.be\/([A-Za-z0-9._%-]*)(\&\S+)?/
youtube_match = youtube_regex.match(link)
if youtube_match.nil?
youtubecom_regex = /^(https?:\/\/)?(www\.)?youtube.com\/watch\?v=([A-Za-z0-9._%-]*)(\&\S+)?/
youtube_match = youtubecom_regex.match(link)
end
youtube_video_id = youtube_match[3] unless youtube_match.nil?
return youtube_video_id
end
Per uno come me che sta cercando di capire questo fuori di recente,
https://i.vimeocdn.com/video/[video_id]_[dimension].webp funziona per me.
(dove dimension = 200x150 | 640)
