Como faço para obter uma miniatura de vídeo do YouTube da API do YouTube?
https://stackoverflow.com/questions/2068344
-
20-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Se eu tiver um URL de vídeo no YouTube, existe alguma maneira de usar o PHP e o Curl para obter a miniatura associada da API do YouTube?
Solução
Cada vídeo do YouTube possui quatro imagens geradas. Eles são previsivelmente formatados da seguinte forma:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/0.jpg
https://img.youtube.com/vi/<insert-youtube-video-id-here>/1.jpg
https://img.youtube.com/vi/<insert-youtube-video-id-here>/2.jpg
https://img.youtube.com/vi/<insert-youtube-video-id-here>/3.jpg
O primeiro da lista é uma imagem em tamanho real e outras são imagens de miniatura. A imagem de miniatura padrão (ou seja, uma de 1.jpg, 2.jpg, 3.jpg) é:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/default.jpg
Para a versão de alta qualidade da miniatura, use um URL semelhante a esta:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg
Há também uma versão de qualidade média da miniatura, usando um URL semelhante ao QG:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg
Para a versão de definição padrão da miniatura, use um URL semelhante a este:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/sddefault.jpg
Para a versão máxima de resolução da miniatura, use um URL semelhante a este:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg
Todos os URLs acima também estão disponíveis no HTTP. Além disso, o nome do host um pouco mais curto i3.ytimg.com trabalha no lugar de img.youtube.com no exemplo de URLs acima.
Como alternativa, você pode usar o API de dados do YouTube (V3) Para obter imagens de miniatura.
Outras dicas
Você pode usar API de dados do YouTube Para recuperar miniaturas de vídeo, legenda, descrição, classificação, estatísticas e muito mais. A versão 3 da API requer uma chave*. Obter a chave e criar um Vídeos: Lista solicitar:
https://www.googleapis.com/youtube/v3/videos?key=YOUR_API_KEY&part=snippet&id=VIDEO_ID
Exemplo de código PHP
$data = file_get_contents("https://www.googleapis.com/youtube/v3/videos?key=YOUR_API_KEY&part=snippet&id=T0Jqdjbed40");
$json = json_decode($data);
var_dump($json->items[0]->snippet->thumbnails);
Resultado
object(stdClass)#5 (5) {
["default"]=>
object(stdClass)#6 (3) {
["url"]=>
string(46) "https://i.ytimg.com/vi/T0Jqdjbed40/default.jpg"
["width"]=>
int(120)
["height"]=>
int(90)
}
["medium"]=>
object(stdClass)#7 (3) {
["url"]=>
string(48) "https://i.ytimg.com/vi/T0Jqdjbed40/mqdefault.jpg"
["width"]=>
int(320)
["height"]=>
int(180)
}
["high"]=>
object(stdClass)#8 (3) {
["url"]=>
string(48) "https://i.ytimg.com/vi/T0Jqdjbed40/hqdefault.jpg"
["width"]=>
int(480)
["height"]=>
int(360)
}
["standard"]=>
object(stdClass)#9 (3) {
["url"]=>
string(48) "https://i.ytimg.com/vi/T0Jqdjbed40/sddefault.jpg"
["width"]=>
int(640)
["height"]=>
int(480)
}
["maxres"]=>
object(stdClass)#10 (3) {
["url"]=>
string(52) "https://i.ytimg.com/vi/T0Jqdjbed40/maxresdefault.jpg"
["width"]=>
int(1280)
["height"]=>
int(720)
}
}
* Não apenas que você precise de uma chave, você pode receber informações de cobrança, dependendo do número de solicitações de API que planeja fazer. No entanto, poucos milhões de solicitações por dia são gratuitos.
O que Asaph disse está certo. No entanto, nem todo vídeo do YouTube contém todas as nove miniaturas. Além disso, o tamanho da imagem das miniaturas depende do vídeo (os números abaixo são baseados em um).
Existem sete miniaturas garantidas:
| Thumbnail Name | Size (px) | URL |
|---------------------|-----------|--------------------------------------------------|
| Player Background | 480x360 | https://i1.ytimg.com/vi/<VIDEO ID>/0.jpg |
| Start | 120x90 | https://i1.ytimg.com/vi/<VIDEO ID>/1.jpg |
| Middle | 120x90 | https://i1.ytimg.com/vi/<VIDEO ID>/2.jpg |
| End | 120x90 | https://i1.ytimg.com/vi/<VIDEO ID>/3.jpg |
| High Quality | 480x360 | https://i1.ytimg.com/vi/<VIDEO ID>/hqdefault.jpg |
| Medium Quality | 320x180 | https://i1.ytimg.com/vi/<VIDEO ID>/mqdefault.jpg |
| Normal Quality | 120x90 | https://i1.ytimg.com/vi/<VIDEO ID>/default.jpg |
Além disso, as duas outras miniaturas podem ou não existir. A presença deles provavelmente se baseia se o vídeo é de alta qualidade.
| Thumbnail Name | Size (px) | URL |
|---------------------|-----------|------------------------------------------------------|
| Standard Definition | 640x480 | https://i1.ytimg.com/vi/<VIDEO ID>/sddefault.jpg |
| Maximum Resolution | 1920x1080 | https://i1.ytimg.com/vi/<VIDEO ID>/maxresdefault.jpg |
Você pode encontrar scripts JavaScript e PHP para recuperar miniaturas e outras informações do YouTube em:
- Como obter informações de vídeo do YouTube com PHP
- Recuperar detalhes de vídeo do YouTube usando JavaScript - JSON & API V2
Você também pode usar o Gerador de informações de vídeo do youtube Ferramenta para obter todas as informações sobre um vídeo do YouTube enviando um URL ou ID de vídeo.
Na API V3 do YouTube, também podemos usar esses URLs para obter miniaturas ... elas são classificadas com base em sua qualidade.
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/default.jpg - default
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg - medium
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg - high
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/sddefault.jpg - standard
E para a resolução máxima ..
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg
Uma vantagem desses URLs sobre os URLs na primeira resposta é que esses URLs não são bloqueados pelos firewalls.
Se você deseja a maior imagem do YouTube para um ID de vídeo específico, o URL deve ser algo assim:
http://i3.ytimg.com/vi/SomeVideoIDHere/0.jpg
Usando a API, você pode pegar a imagem de miniatura padrão. Código simples deve ser algo assim:
//Grab the default thumbnail image
$attrs = $media->group->thumbnail[1]->attributes();
$thumbnail = $attrs['url'];
$thumbnail = substr($thumbnail, 0, -5);
$thumb1 = $thumbnail."default.jpg";
// Grab the third thumbnail image
$thumb2 = $thumbnail."2.jpg";
// Grab the fourth thumbnail image.
$thumb3 = $thumbnail."3.jpg";
// Using simple cURL to save it your server.
// You can extend the cURL below if you want it as fancy, just like
// the rest of the folks here.
$ch = curl_init ("$thumb1");
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_BINARYTRANSFER,1);
$rawdata = curl_exec($ch);
curl_close($ch);
// Using fwrite to save the above
$fp = fopen("SomeLocationInReferenceToYourScript/AnyNameYouWant.jpg", 'w');
// Write the file
fwrite($fp, $rawdata);
// And then close it.
fclose($fp);
Se você quiser se livrar das "barras pretas" e fazê -lo como o YouTube, você pode usar:
https://i.ytimg.com/vi_webp/<video id>/mqdefault.webp
E se você não pode usar o .webp Extensão de arquivo Você pode fazer assim:
https://i.ytimg.com/vi/<video id>/mqdefault.jpg
Além disso, se você precisar da versão não escalada, use maxresdefault ao invés de mqdefault.
Nota: não tenho certeza sobre a proporção se você planeja usar maxresdefault.
Eu fiz uma função para buscar apenas imagens existentes do YouTube
function youtube_image($id) {
$resolution = array (
'maxresdefault',
'sddefault',
'mqdefault',
'hqdefault',
'default'
);
for ($x = 0; $x < sizeof($resolution); $x++) {
$url = '//img.youtube.com/vi/' . $id . '/' . $resolution[$x] . '.jpg';
if (get_headers($url)[0] == 'HTTP/1.0 200 OK') {
break;
}
}
return $url;
}
Dentro API de dados do YouTube v3, você pode obter miniaturas de vídeo com o Vídeos-> Lista função. A partir de Snippet.thumbnails. (chave), você pode escolher a miniatura padrão, de média ou alta resolução e obter sua largura, altura e URL.
Você também pode atualizar miniaturas com o Miniaturas-> Conjunto funcionalidade.
Para exemplos, você pode conferir o Amostras de API do YouTube projeto. (PHP.)
Você pode obter o Entrada de vídeo que contém o URL na miniatura do vídeo. Há um código de exemplo no link. Ou, se você deseja analisar XML, há informações aqui. O XML retornou tem um media:thumbnail elemento, que contém o URL da miniatura.
// Get image form video URL
$url = $video['video_url'];
$urls = parse_url($url);
//Expect the URL to be http://youtu.be/abcd, where abcd is the video ID
if ($urls['host'] == 'youtu.be') :
$imgPath = ltrim($urls['path'],'/');
//Expect the URL to be http://www.youtube.com/embed/abcd
elseif (strpos($urls['path'],'embed') == 1) :
$imgPath = end(explode('/',$urls['path']));
//Expect the URL to be abcd only
elseif (strpos($url,'/') === false):
$imgPath = $url;
//Expect the URL to be http://www.youtube.com/watch?v=abcd
else :
parse_str($urls['query']);
$imgPath = $v;
endif;
O YouTube é de propriedade do Google e o Google gosta de ter um número razoável de imagens para diferentes tamanhos de tela, portanto, suas imagens são armazenadas em tamanhos diferentes. Aqui está um exemplo de como será sua miniatura:
Miniatura de baixa qualidade:
http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/sddefault.jpg
Miniatura de qualidade média:
http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/mqdefault.jpg
Miniatura de alta qualidade:
http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/hqdefault.jpg
Miniatura máxima de qualidade:
http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/maxresdefault.jpg
Youtube API Versão 3 em funcionamento em 2 minutos
Se tudo o que você deseja fazer é pesquisar no YouTube e obter propriedades associadas:
Arranje um API público -- Este link dá uma boa direção
Use abaixo a string de consulta. A consulta de pesquisa (indicada por Q =) na string de URL é Stackoverflow por exemplo, propósitos. O YouTube enviará de volta uma resposta JSON, onde você pode analisar a miniatura, snippet, autor, etc.
Usar:
https://www.googleapis.com/youtube/v3/videoCategories?part=snippet,id&maxResults=100®ionCode=us&key=**Your YouTube ID**
Acima está o link. Usando isso, você pode encontrar as características do YouTube dos vídeos. Após encontrar características, você pode obter vídeos da categoria selecionada. Depois então você pode encontrar imagens de vídeo selecionadas usando Resposta de Asaph.
Experimente a abordagem acima e você pode analisar tudo do YouTube API.
Eu usei miniaturas do YouTube dessa maneira:
$url = 'http://img.youtube.com/vi/' . $youtubeId . '/0.jpg';
$img = dirname(__FILE__) . '/youtubeThumbnail_' . $youtubeId . '.jpg';
file_put_contents($img, file_get_contents($url));
Lembre -se de que o YouTube evita incluir imagens diretamente do servidor.
Encontrei esta ferramenta bacana que permite criar a imagem com o botão de reprodução do YouTube colocado sobre a imagem:
- Instalado no servidor para script: https://github.com/halgatewood/youtube-thumbnail-enhancer
Apenas para adicionar/expandir as soluções dadas, acho que é necessário observar que, como eu mesmo tive esse problema, pode -se realmente pegar vários conteúdos de vídeos do YouTube, neste caso, miniaturas, com uma solicitação HTTP:
Usando um cliente REST, neste caso, httpful, você pode fazer algo assim:
<?php
header("Content-type", "application/json");
//download the httpfull.phar file from http://phphttpclient.com
include("httpful.phar");
$youtubeVidIds= array("nL-rk4bgJWU", "__kupr7KQos", "UCSynl4WbLQ", "joPjqEGJGqU", "PBwEBjX3D3Q");
$response = \Httpful\Request::get("https://www.googleapis.com/youtube/v3/videos?key=YourAPIKey4&part=snippet&id=".implode (",",$youtubeVidIds)."")
->send();
print ($response);
?>
Outra boa alternativa seria usar o OFEBBED API que é suportada pelo YouTube.
Você simplesmente adiciona seu URL do YouTube ao URL do OEembed e receberá um JSON, incluindo uma miniatura e o código HTML para incorporação.
Exemplo:
http://www.youtube.com/oembed?format=json&url=http%3A//youtube.com/watch%3Fv%3DDLzxrzFCyOs
Daria a você:
{
thumbnail_url: "https://i.ytimg.com/vi/DLzxrzFCyOs/hqdefault.jpg",
width: 459,
author_name: "AllKindsOfStuff",
version: "1.0",
author_url: "https://www.youtube.com/channel/UCLNd5EtH77IyN1frExzwPRQ",
thumbnail_width: 480,
type: "video",
provider_url: "https://www.youtube.com/",
html: "<iframe width="459" height="344" src="https://www.youtube.com/embed/DLzxrzFCyOs?feature=oembed" frameborder="0" allowfullscreen></iframe>",
title: "Some title bla bla foo bar",
thumbnail_height: 360,
provider_name: "YouTube",
height: 344
}
Leia a documentação para mais em formação.
Uma função simples de PHP que criei para a miniatura do YouTube e os tipos são
- predefinição
- HQDefault
- MQDefault
- sddefault
- Maxresdefault
function get_youtube_thumb($link,$type){
$video_id = explode("?v=", $link);
if (empty($video_id[1])){
$video_id = explode("/v/", $link);
$video_id = explode("&", $video_id[1]);
$video_id = $video_id[0];
}
$thumb_link = "";
if($type == 'default' || $type == 'hqdefault' ||
$type == 'mqdefault' || $type == 'sddefault' ||
$type == 'maxresdefault'){
$thumb_link = 'http://img.youtube.com/vi/'.$video_id.'/'.$type.'.jpg';
}elseif($type == "id"){
$thumb_link = $video_id;
}
return $thumb_link;}
Se você está usando a API pública, a melhor maneira de fazer isso é usar if declarações.
Se o vídeo for público ou não listado, você define a miniatura usando o método URL. Se o vídeo for privado, você usa a API para obter a miniatura.
<?php
if($video_status == 'unlisted'){
$video_thumbnail = 'http://img.youtube.com/vi/'.$video_url.'/mqdefault.jpg';
$video_status = '<i class="fa fa-lock"></i> Unlisted';
}
elseif($video_status == 'public'){
$video_thumbnail = 'http://img.youtube.com/vi/'.$video_url.'/mqdefault.jpg';
$video_status = '<i class="fa fa-eye"></i> Public';
}
elseif($video_status == 'private'){
$video_thumbnail = $playlistItem['snippet']['thumbnails']['maxres']['url'];
$video_status = '<i class="fa fa-lock"></i> Private';
}
API de dados do YouTube
O YouTube nos fornece as quatro imagens geradas para cada vídeo através da API de dados (v3), por exemplo,
Obtendo acesso às imagens via API
- Primeiro obtenha sua chave de API pública em Google API Console.
- Conforme a referência de miniatura do YouTube no Documentação da API, você precisa acessar os recursos no snippet.thumbnails.
De acordo com isso, você precisa expressar seu URL como este -
www.googleapis.com/youtube/v3/videos?part=snippet&id=`yourVideoId`&key=`yourApiKey`
Agora, altere seu ID de vídeo e sua chave da API para o seu respectivo ID de vídeo e chave API e sua resposta será uma saída JSON, fornecendo os quatro links nas miniaturas da variável snippet (se todos estiverem disponíveis).
Você pode obter o ID de vídeo do URL de vídeo do YouTube usando parse_url ,parse_str e depois insira os URLs preditivos para imagens. Obrigado ao YouTube pelos URLs preditivos
$videoUrl = "https://www.youtube.com/watch?v=8zy7wGbQgfw";
parse_str( parse_url( $videoUrl, PHP_URL_QUERY ), $my_array_of_vars );
$ytID = $my_array_of_vars['v']; //gets video ID
print "https://img.youtube.com/vi/<?php print $ytID?>/maxresdefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/mqdefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/hqdefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/sddefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/default.jpg";
Você pode usar esta ferramenta para gerar miniaturas do YouTube
https://tools.tutsplanet.com/index.php/get-youtube-video-thumbnails
Eu acho que eles são muito respostas para a miniatura, mas quero adicionar outros URLs para obter a miniatura do YouTube com muita facilidade. Estou apenas tomando algum texto da resposta de Asaph. Aqui estão alguns URLs para obter miniaturas do YouTube:
https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/default.jpg
Para a versão de alta qualidade da miniatura, use um URL semelhante a esta:
https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg
Há também uma versão de média qualidade da miniatura, usando um URL semelhante à alta qualidade:
https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg
Para a versão de definição padrão da miniatura, use um URL semelhante a este:
https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/sddefault.jpg
Para a versão máxima de resolução da miniatura, use um URL semelhante a este:
https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg
function get_video_thumbnail( $src ) {
$url_pieces = explode('/', $src);
if( $url_pieces[2] == 'dai.ly'){
$id = $url_pieces[3];
$hash = json_decode(file_get_contents('https://api.dailymotion.com/video/'.$id.'?fields=thumbnail_large_url'), TRUE);
$thumbnail = $hash['thumbnail_large_url'];
}else if($url_pieces[2] == 'www.dailymotion.com'){
$id = $url_pieces[4];
$hash = json_decode(file_get_contents('https://api.dailymotion.com/video/'.$id.'?fields=thumbnail_large_url'), TRUE);
$thumbnail = $hash['thumbnail_large_url'];
}else if ( $url_pieces[2] == 'vimeo.com' ) { // If Vimeo
$id = $url_pieces[3];
$hash = unserialize(file_get_contents('http://vimeo.com/api/v2/video/' . $id . '.php'));
$thumbnail = $hash[0]['thumbnail_large'];
} elseif ( $url_pieces[2] == 'youtu.be' ) { // If Youtube
$extract_id = explode('?', $url_pieces[3]);
$id = $extract_id[0];
$thumbnail = 'http://img.youtube.com/vi/' . $id . '/mqdefault.jpg';
}else if ( $url_pieces[2] == 'player.vimeo.com' ) { // If Vimeo
$id = $url_pieces[4];
$hash = unserialize(file_get_contents('http://vimeo.com/api/v2/video/' . $id . '.php'));
$thumbnail = $hash[0]['thumbnail_large'];
} elseif ( $url_pieces[2] == 'www.youtube.com' ) { // If Youtube
$extract_id = explode('=', $url_pieces[3]);
$id = $extract_id[1];
$thumbnail = 'http://img.youtube.com/vi/' . $id . '/mqdefault.jpg';
} else{
$thumbnail = tim_thumb_default_image('video-icon.png', null, 147, 252);
}
return $thumbnail;
}
get_video_thumbnail('https://vimeo.com/154618727');
get_video_thumbnail('https://www.youtube.com/watch?v=SwU0I7_5Cmc');
get_video_thumbnail('https://youtu.be/pbzIfnekjtM');
get_video_thumbnail('http://www.dailymotion.com/video/x5thjyz');
A resposta superior é otimizado para uso manual. O token de ID de vídeo sem separadores permite a seleção com um clique duplo.
Cada vídeo do YouTube possui quatro imagens geradas. Eles são previsivelmente formatados da seguinte forma:
https://img.youtube.com/vi/YOUTUBEVIDEOID/0.jpg
https://img.youtube.com/vi/YOUTUBEVIDEOID/1.jpg
https://img.youtube.com/vi/YOUTUBEVIDEOID/2.jpg
https://img.youtube.com/vi/YOUTUBEVIDEOID/3.jpg
O primeiro da lista é uma imagem em tamanho real e outras são imagens de miniatura. A imagem de miniatura padrão (ou seja, um de 1.jpg, 2.jpg, 3.jpg) é:
https://img.youtube.com/vi/YOUTUBEVIDEOID/default.jpg
Para a versão de alta qualidade da miniatura, use um URL semelhante a esta:
https://img.youtube.com/vi/YOUTUBEVIDEOID/hqdefault.jpg
Há também uma versão de qualidade média da miniatura, usando um URL semelhante ao QG:
https://img.youtube.com/vi/YOUTUBEVIDEOID/mqdefault.jpg
Para a versão de definição padrão da miniatura, use um URL semelhante a este:
https://img.youtube.com/vi/YOUTUBEVIDEOID/sddefault.jpg
Para a versão máxima de resolução da miniatura, use um URL semelhante a este:
https://img.youtube.com/vi/YOUTUBEVIDEOID/maxresdefault.jpg
Todos os URLs acima também estão disponíveis no HTTP. Além disso, o nome do host um pouco mais curto i3.ytimg.com trabalha no lugar de img.youtube.com no exemplo de URLs acima.
Como alternativa, você pode usar o API de dados do YouTube (V3) Para obter imagens de miniatura.
Método 1:
Você pode encontrar todas as informações para um vídeo do YouTube com uma página JSON que até "thumbnail_url",http://www.youtube.com/oembed?format=json&url={Seu URL de vídeo vai aqui}
Como o Código Final de Teste de Look + Php
$data = file_get_contents("https://www.youtube.com/oembed?format=json&url=https://www.youtube.com/watch?v=_7s-6V_0nwA");
$json = json_decode($data);
var_dump($json);
Resultado
object(stdClass)[1]
public 'width' => int 480
public 'version' => string '1.0' (length=3)
public 'thumbnail_width' => int 480
public 'title' => string 'how to reminder in window as display message' (length=44)
public 'provider_url' => string 'https://www.youtube.com/' (length=24)
public 'thumbnail_url' => string 'https://i.ytimg.com/vi/_7s-6V_0nwA/hqdefault.jpg' (length=48)
public 'author_name' => string 'H2 ZONE' (length=7)
public 'type' => string 'video' (length=5)
public 'author_url' => string 'https://www.youtube.com/channel/UC9M35YwDs8_PCWXd3qkiNzg' (length=56)
public 'provider_name' => string 'YouTube' (length=7)
public 'height' => int 270
public 'html' => string '<iframe width="480" height="270" src="https://www.youtube.com/embed/_7s-6V_0nwA?feature=oembed" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>' (length=171)
public 'thumbnail_height' => int 360
Para detalhes, você também pode ver https://www.youtube.com/watch?v=mxde7q59bi8 Tutorial em vídeo 1
Método 2:
Usando o link da imagem do YouTube,https://img.youtube.com/vi/"Insert-youtube-video-id here" /default.jpg
Método 3:
Usando o código -fonte do navegador para obter miniatura usando o link de URL de vídeo -GO para o código -fonte de vídeo e pesquise em Thumbnailurl. Agora você pode usar este URL em seu código -fonte:
{img src="https://img.youtube.com/vi/"insert-youtube-video-id-here"/default.jpg"}
Para detalhes, você também pode ver Como obter uma miniatura de vídeo do YouTube usando o IDouhttps://www.youtube.com/watch?v=9f6e8mem6piTutorial em vídeo 2
Usar img.youtube.com/vi/YouTubeID/ImageFormat.jpg
Aqui, os formatos de imagem são diferentes, como padrão, hqdefault, maxresdefault.
Esta é a minha solução excluída apenas para o lado do cliente.
YouTube.parse('https://www.youtube.com/watch?v=P3DGwyl0mJQ').then(_ => console.log(_))
O código:
import { parseURL, parseQueryString } from './url'
import { getImageSize } from './image'
const PICTURE_SIZE_NAMES = [
// 1280 x 720.
// HD aspect ratio.
'maxresdefault',
// 629 x 472.
// non-HD aspect ratio.
'sddefault',
// For really old videos not having `maxresdefault`/`sddefault`.
'hqdefault'
]
// - Supported YouTube URL formats:
// - http://www.youtube.com/watch?v=My2FRPA3Gf8
// - http://youtu.be/My2FRPA3Gf8
export default
{
parse: async function(url)
{
// Get video ID.
let id
const location = parseURL(url)
if (location.hostname === 'www.youtube.com') {
if (location.search) {
const query = parseQueryString(location.search.slice('/'.length))
id = query.v
}
} else if (location.hostname === 'youtu.be') {
id = location.pathname.slice('/'.length)
}
if (id) {
return {
source: {
provider: 'YouTube',
id
},
picture: await this.getPicture(id)
}
}
},
getPicture: async (id) => {
for (const sizeName of PICTURE_SIZE_NAMES) {
try {
const url = getPictureSizeURL(id, sizeName)
return {
type: 'image/jpeg',
sizes: [{
url,
...(await getImageSize(url))
}]
}
} catch (error) {
console.error(error)
}
}
throw new Error(`No picture found for YouTube video ${id}`)
},
getEmbeddedVideoURL(id, options = {}) {
return `https://www.youtube.com/embed/${id}`
}
}
const getPictureSizeURL = (id, sizeName) => `https://img.youtube.com/vi/${id}/${sizeName}.jpg`
Utilitário image.js:
// Gets image size.
// Returns a `Promise`.
function getImageSize(url)
{
return new Promise((resolve, reject) =>
{
const image = new Image()
image.onload = () => resolve({ width: image.width, height: image.height })
image.onerror = reject
image.src = url
})
}
Utilitário url.js:
// Only on client side.
export function parseURL(url)
{
const link = document.createElement('a')
link.href = url
return link
}
export function parseQueryString(queryString)
{
return queryString.split('&').reduce((query, part) =>
{
const [key, value] = part.split('=')
query[decodeURIComponent(key)] = decodeURIComponent(value)
return query
},
{})
}
Aqui está uma função simples que criei para obter as miniaturas. É fácil de entender e usar.
$ link é o link do YouTube copiado exatamente como está no navegador, por exemplo, https://www.youtube.com/watch?v=bq0mxqxmlsk
function get_youtube_thumb($link){
$new = str_replace('https://www.youtube.com/watch?v=', '', $link);
$thumbnail = 'https://img.youtube.com/vi/' . $new . '/0.jpg';
return $thumbnail;
}
Salve este código no arquivo .php vazio e teste -o.
<img src="<?php echo youtube_img_src('9bZkp7q19f0', 'high');?>" />
<?php
// Get a YOUTUBE video thumb image's source url for IMG tag "src" attribute:
// $ID = YouYube video ID (string)
// $size = string (default, medium, high or standard)
function youtube_img_src ($ID = null, $size = 'default') {
switch ($size) {
case 'medium':
$size = 'mqdefault';
break;
case 'high':
$size = 'hqdefault';
break;
case 'standard':
$size = 'sddefault';
break;
default:
$size = 'default';
break;
}
if ($ID) {
return sprintf('https://img.youtube.com/vi/%s/%s.jpg', $ID, $size);
}
return 'https://img.youtube.com/vi/ERROR/1.jpg';
}
Obrigado.
public const string tubeThumb = "http://i.ytimg.com/vi/[id]/hqdefault.jpg";
vid.Thumbnail = tubeThumb.Replace("[id]", vid.VideoID);
