Obter miniaturas img do Vimeo?
https://stackoverflow.com/questions/1361149
-
20-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu quero obter uma imagem de miniatura para vídeos do Vimeo.
Ao obter imagens do YouTube, eu apenas faço assim:
http://img.youtube.com/vi/HwP5NG-3e8I/2.jpg
Alguma ideia de como fazer para o Vimeo?
Solução
De Vimeo simples documentos de API:
Fazendo um pedido de vídeo
Para obter dados sobre um vídeo específico, use o seguinte URL:
http://vimeo.com/api/v2/video/video_id.output
video_id O ID do vídeo para o qual deseja informações.
resultado Especifique o tipo de saída. Atualmente, oferecemos formatos JSON, PHP e XML.
Então, obtendo este 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>
Analise isso para cada vídeo para obter a miniatura
Aqui está o código aproximado no PHP
<?php
$imgid = 6271487;
$hash = unserialize(file_get_contents("http://vimeo.com/api/v2/video/$imgid.php"));
echo $hash[0]['thumbnail_medium'];
Outras dicas
Em JavaScript (usa 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);
}
Para exibi -lo:
<img id="vimeo-{{ video.id_video }}" src="" alt="{{ video.title }}" />
<script type="text/javascript">
vimeoLoadingThumb({{ video.id_video }});
</script>
Usando a solicitação 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>
Você deve analisar a resposta da API do Vimeo. Não há como as chamadas de URL (como Dailymotion ou YouTube).
Aqui está minha solução 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;
}
Com Ruby, você pode fazer o seguinte, se tiver, digamos:
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
Aqui está um exemplo de como fazer a mesma coisa no ASP.NET usando C#. Sinta -se à vontade para usar uma imagem de captura de erro diferente :)
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: Sua solicitação de API deve assim quando solicitada: http://vimeo.com/api/v2/video/32660708.xml
A maneira mais fácil de JavaScript que eu achei para obter a miniatura, sem procurar o ID de vídeo está 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 alguém precisar obter a miniatura em vídeo relacionada ao ID de vídeo, ele pode substituir o $id Com o ID de vídeo e obtenha um XML com os detalhes do vídeo:
http://vimeo.com/api/v2/video/$id.xml
Exemplo:
http://vimeo.com/api/v2/video/198340486.xml
Se você deseja usar a miniatura através da API Pure JS/JQuery no, pode usar esta ferramenta para capturar um quadro do vídeo e do pronto -socorro! Insira o polegar de URL em qualquer fonte que você quiser.
Aqui está uma caneta de código:
<img src="https://i.vimeocdn.com/video/531141496_640.jpg"` alt="" />
Aqui está o site para obter miniatura:
Usando o URL do Vimeo (https://player.vimeo.com/video/30572181), aqui está o meu exemplo
<!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>Parece que a API/V2 está morta.
Para usar a nova API, você precisa registre seu aplicativo, e base64 codificam o client_id e client_secret como cabeçalho de autorização.
$.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);
}
});
Para segurança, você pode devolver o client_id e client_secret já codificado no servidor.
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);
});
}
}
Na verdade, o cara que fez essa pergunta postou sua própria resposta.
"O Vimeo parece querer que eu faça uma solicitação HTTP e extraia o URL da miniatura do XML que eles retornam ..."
Os documentos da API do Vimeo estão aqui: http://vimeo.com/api/docs/simple-api
Em suma, seu aplicativo precisa fazer uma solicitação de obter para um URL como o seguinte:
http://vimeo.com/api/v2/video/video_id.output
e analise os dados retornados para obter o URL de miniatura necessário e faça o download do arquivo nesse URL.
Escrevi uma função no PHP para me deixar, espero que seja útil para alguém. O caminho para a miniatura está contido em uma tag de link na página de vídeo. Isso parece fazer o truque para mim.
$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;
Espero que ajude alguém.
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;
}`
// Na função abaixo, passe o URL da miniatura.
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;
}
A resposta de Karthikeyan P em decomposição para que possa ser usada em uma variedade mais ampla de cenários:
// 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;
};
Uso
Obtenha um ID do Vimeo de um URL de vídeo do Vimeo:
var vimeoId = parseVimeoIdFromUrl(vimeoUrl);
Obtenha um URL de miniatura do Vimeo de um ID do Vimeo:
getVimeoThumbUrl(vimeoIds[0])
.done(function(img) {
$('div').append('<img src="' + img + '"/>');
});
Esta é uma maneira rápida de fazê -lo e também uma maneira de escolher um tamanho personalizado.
Eu vou aqui:
http://vimeo.com/api/v2/video/[VIDEO ID].php
Faça o download do arquivo, abra -o e encontre a miniatura de 640 pixels de largura, ele terá um formato assim:
https://i.vimeocdn.com/video/[LONG NUMBER HERE]_640.jpg
Você pega o link, muda o 640 para - por exemplo - 1400 e acaba com algo assim:
https://i.vimeocdn.com/video/[LONG NUMBER HERE]_1400.jpg
Cole -o na barra de pesquisa do navegador e aproveite.
Saúde,
Se você não precisar de uma solução automatizada, pode encontrar o URL da miniatura inserindo o ID do Vimeo aqui: http://video.depone.eu/
ATUALIZAR: Esta solução parou de funcionar a partir de dezembro de 2018.
Eu estava procurando a mesma coisa e parece que a maioria das respostas aqui está desatualizada devido ao fato de o Vimeo API V2 ser descontinuado.
meu 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;
Com o exposto, você receberá o link para a imagem de miniatura padrão do Vimeo.
Se você quiser usar uma imagem de tamanho diferente, pode adicionar algo como:
$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 você está procurando uma solução alternativa e pode gerenciar a conta do Vimeo, há outra maneira, basta adicionar todos os vídeos que deseja mostrar em um álbum e depois usar a API para solicitar os detalhes do álbum - ele mostra todas as miniaturas e links . Não é o ideal, mas pode ajudar.
Ponto final da API (playground)
Twitter Convo com @vimeoapi
Você pode querer dar uma olhada na jóia de Matt Hooks. https://github.com/matthooks/vimeo
Ele fornece um invólucro simples do Vimeo para a API.
Tudo o que você precisa é armazenar o vídeo_id (e o provedor se você também estiver fazendo outros sites de vídeo)
Você pode extrair o ID de vídeo do Vimeo como So
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 você precisar do seu tubo, você pode achar isso útil
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
Para alguém como eu, que está tentando descobrir isso recentemente,
https://i.vimeocdn.com/video/[video_id]_[dimension].webp funciona para mim.
(Onde dimension = 200x150 | 640)
