vimeo_upload(), sube vídeos a vimeo desde tu servidor con PHP

upload_vimeoSi como a mi os gusta mas vimeo que youtube ya sea por su diseño, facilidad de uso o mayores capacidades de personalización (como la capacidad de descargar los vídeos directamente, personalización de thumbnails…) estáis de enhorabuena..

El siguiente código es capaz de subir vídeos directamente desde nuestro servidor a vimeo agregando titulo, descripción, tags y permisos de acceso. Para hacer esto y cumpliendo una pasada promesa, utilizaremos source_extract() así que es necesario que esta función también esté en el mismo archivo.

[PHP]
function vimeo_upload(
$file,
$mail,
$pass,
$title=”,
$descripcion=”,
$tags=”,
$permisos=false,
$api_key=’e1dfce4136d69d7f99d2a4d00c4a0d71′,
$api_secret=’e9ff591b0′
){

@set_time_limit(0);
$title = htmlentities($title, ENT_NOQUOTES, ‘UTF-8’);
$descripcion = htmlentities($descripcion, ENT_NOQUOTES, ‘UTF-8’);
$cookie = tempnam (“/tmp”, “VIMEO”);
$api_login_url = “http://www.vimeo.com/log_in”;
$api_rest_url = “http://www.vimeo.com/api/rest/”;
$api_auth_url = “http://www.vimeo.com/services/auth/”;
$api_upload_url = “http://www.vimeo.com/services/upload/”;

if($file){
#login
$args = array(
‘sign_in[email]’ => $mail,
‘sign_in[password]’ => $pass
);
$login = source_extract($api_login_url, $args, ”, ”, true, $cookie);

#frob
$args = $_args = array(
‘api_key’ => $api_key,
‘perms’ => ‘write’,
‘format’ => ‘php’
);

$s=$api_secret; foreach($args as $k=>$v){ $s .= $k.$v; } $args[‘api_sig’] = md5($s);
$frob = source_extract($api_auth_url, ”, $args, ”, true, $cookie);
if(!$frob[‘header’][‘Location’]){ //si aun no fue aceptada la autorizacion
$frob = source_extract($api_auth_url, $_args, ”, ”, true, $cookie); #lo autorizamos por POST
$frob = source_extract($api_auth_url, ”, $args, ”, true, $cookie); #y pedimos el frob de nuevo
}
$frob = substr($frob[‘header’][‘Location’], strpos($frob[‘header’][‘Location’], ‘frob=’)+strlen(‘frob=’) );

#token
$args = array(
‘api_key’ => $api_key,
‘format’ => ‘php’,
‘frob’ => $frob,
‘method’ => ‘vimeo.auth.getToken’
);
$s=$api_secret; foreach($args as $k=>$v){ $s .= $k.$v; } $args[‘api_sig’] = md5($s);
$token = source_extract($api_rest_url, ”, $args, ”, true, $cookie);
$token = unserialize($token[‘content’]);
$token = $token->auth->token;

#tiket
$args = array(
‘api_key’ => $api_key,
‘format’ => ‘php’,
‘frob’ => $frob,
‘method’ => ‘vimeo.videos.getUploadTicket’
);

$s=$api_secret; foreach($args as $k=>$v){ $s .= $k.$v; } $args[‘api_sig’] = md5($s);
$tiket = source_extract($api_rest_url, ”, $args, ”, true, $cookie);
$tiket = unserialize($tiket[‘content’]);
$tiket = $tiket->ticket->id;

#upload video
$file = array(‘video’=>$file);
$args = array(
‘api_key’ => $api_key,
‘format’ => ‘php’,
‘auth_token’ => $token,
‘ticket_id’ => $tiket
);

$s=$api_secret; foreach($args as $k=>$v){ $s .= $k.$v; } $args[‘api_sig’] = md5($s);
$upload = source_extract($api_upload_url, $args, ”, $file, true, $cookie);

#check
$args = array(
‘api_key’ => $api_key,
‘format’ => ‘php’,
‘frob’ => $frob,
‘method’ => ‘vimeo.videos.checkUploadStatus’,
‘ticket_id’ => $tiket
);

$s=$api_secret; foreach($args as $k=>$v){ $s .= $k.$v; } $args[‘api_sig’] = md5($s);
$check = source_extract($api_rest_url, ”, $args, ”, true, $cookie);
$check = unserialize($check[‘content’]);

#title
$args = array(
‘api_key’ => $api_key,
‘format’ => ‘php’,
‘method’ => ‘vimeo.videos.setTitle’,
‘title’ => $title,
‘video_id’ => $check->ticket->video_id,
);

$s=$api_secret; foreach($args as $k=>$v){ $s .= $k.$v; } $args[‘api_sig’] = md5($s);
$title = source_extract($api_rest_url, ”, $args, ”, true, $cookie);
$title = unserialize($title[‘content’]);

#caption
$args = array(
‘api_key’ => $api_key,
‘caption’ => $descripcion,
‘format’ => ‘php’,
‘method’ => ‘vimeo.videos.setCaption’,
‘video_id’ => $check->ticket->video_id,
);

$s=$api_secret; foreach($args as $k=>$v){ $s .= $k.$v; } $args[‘api_sig’] = md5($s);
$caption = source_extract($api_rest_url, ”, $args, ”, true, $cookie);
$caption = unserialize($caption[‘content’]);

#tags
$args = array(
‘api_key’ => $api_key,
‘format’ => ‘php’,
‘method’ => ‘vimeo.videos.addTags’,
‘tags’ => $tags,
‘video_id’ => $check->ticket->video_id,
);

$s=$api_secret; foreach($args as $k=>$v){ $s .= $k.$v; } $args[‘api_sig’] = md5($s);
$tags = source_extract($api_rest_url, ”, $args, ”, true, $cookie);
$tags = unserialize($tags[‘content’]);

#privacidad
if($permisos){
$permisos = strtolower($permisos);
if( $permisos!=’anybody’ && $permisos!=’nobody’ && $permisos!=’contacts’ && !strpos($permisos, ‘,’)){
return ‘ERROR: Los permisos permitidos son “nobody” para que sea privado, “anybody”,’.
‘ para que sea publico, “contacts” para que solo lo puedan ver los contactos del’.
‘ usuario registrado o una lista de usuarios separada por comas para que solo esos’.
‘ usuarios puedan ver el video. (la funcion requiere que si se usa esta ultima’.
‘ opción se ponga al menos una coma final.’;
}

if(strpos($permisos, ‘,’)) {
$args = array(
‘api_key’ => $api_key,
‘format’ => ‘php’,
‘method’ => ‘vimeo.videos.setPrivacy’,
‘privacy’ => ‘users’,
‘users’ => (substr($permisos, -1)==’,’) ? substr($permisos, 0, -1) : $permisos,
‘video_id’ => $check->ticket->video_id,
);
} else {
$args = array(
‘api_key’ => $api_key,
‘format’ => ‘php’,
‘method’ => ‘vimeo.videos.setPrivacy’,
‘privacy’ => $permisos,
‘video_id’ => $check->ticket->video_id,
);
}

$s=$api_secret; foreach($args as $k=>$v){ $s .= $k.$v; } $args[‘api_sig’] = md5($s);
$permisos = source_extract($api_rest_url, ”, $args, ”, true, $cookie);
$permisos = unserialize($permisos[‘content’]);
}

return array(
‘login’ => $login,
‘frob’ => $frob,
‘token’ => $token,
‘tiket’ => $tiket,
‘upload’ => $upload,
‘check’ => $check,
‘title’ => $title,
‘caption’ => $caption,
‘tags’ => $tags,
‘privacity’ => $permisos,
);
}
}
[/PHP]

Como resultado la función da un conjunto ordenado en array de las respuestas ofrecidas en cada consulta a la API de vimeo para que podamos extraer o interpretar los datos que queramos.

Para que funcione correctamente tenemos que poner las siguientes variables (en orden):

  • Dirección del archivo a subir. La dirección tiene que estar en el servidor. No se permite indicar otras paginas web por motivos de seguridad en cURL.
  • Email de la cuenta de usuario a la que se quiere subir el archivo.
  • Contraseña de la cuenta de vimeo a la que se va a subir el archivo
  • Titulo del video a subir (opcional)
  • Descripción del video (opcional)
  • Etiquetas del video, IMPORTANTE: separadas por comas (opcional)
  • Permiso de acceso al video. Los vídeos se suben como predeterminado con el permiso en nobody, lo que quiere decir que solo los puede ver el usuario que los ha subido. Los permisos que se pueden poner aquí son nobody para que sea un video privado, anybody para que sea público, contacts para que lo puedan ver solo los contactos agregados a la cuenta de vimeo en la que se sube el video o los nombres de los usuarios a los que se desea dar permiso para que puedan ver el video. Si solo se desea dar permiso a un usuario es obligatorio escribir una coma al final. (opcional)
  • Key del programa. Vimeo identifica las firmas de cada aplicación a partir de las key, así que si quieres usar esta función sin modificar esto no hay problema. La función viene ya con una key pero si quieres modificar la que tiene predeterminada para firmar tu propio programa solo tienes que ponerla aquí. (opcional)
  • Key secreta. Es el complemento a la key anterior para firmar las peticiones. si cambias el parámetro anterior es obligatorio que cambies este también por los datos de la nueva key. (opcional)

Y ahora un ejemplo simple:
Este ejemplo sube un video en mp4 llamado “gato_saltando.mp4″ situado en la misma carpeta donde se ejecute al función.
[PHP]

$video_datos = vimeo_upload(‘gato_saltando.mp4’, ‘cuenta_de_usu@rio.com’, ‘SeCrEt0’, ‘Gato saltando!!’, ‘Texto que explica lo que se ve en el video. En este caso supongo que seria un gato saltando un rato….’, ‘gato, saltando, cat, jumping’, ‘anybody’);

if(strpos($video_datos[‘upload’][‘content’],’stat=”ok”‘)) {
echo ‘El video se ha subido con &eacite;xito’;
} else {
echo ‘No se pudo subir el video: ‘.”\n”;
print_r($video_datos);
}

[/PHP]

Recordad que siempre los archivos a enviar tiene que estar previamente dentro del servidor web.
Para subir los vídeos a vuestro servidor web hay muchísimos script que podéis usar.

Si alguien quiere hacer algo parecido o modificar esta función se puede sentir libre de hacerlo, y si lo deja por aquí mejor que mejor..! Solo comentar que si queréis seguir usando otras propiedades de la API de vimeo tened en cuenta que aun no se por que pero en mi experiencia el “orden” de lo introducido en la consulta es vital para evitar que aparezcan los errores Invalid “111 Signature” sin razón aparente.
Para cualquier cosa comentario.. y como mención especial no puedo dejar de agradecer al señor @edeleon la rápida y acertada respuesta en mis dudas, Gracias.
Gracias de nuevo al Sr. @edeleon he encontrado un bug que afecta a la primera vez que se intenta subir un video a una cuenta nueva… el sistema intentaba asociar la API-KEY a la cuenta y al no conseguirlo, no podia subir el video correctamente. Por esto se le ha añadido una comprobación en el apartado #frob.

Función de extracción de datos Youtube() en PHP version3

Youtube()A estas alturas supongo que los que lean este blog seguramente sepan que hace esta función. Es una función que a partir de una ID de youtube extrae el resto de datos del mismo video…
El motivo de esta actualización es el aviso de @pablo que me indicaba que en la versión 1 se la función si que se obtener el usuario que ha subido el video, asi que esa ha sido la primera corrección.
Revisando el código a demás me di cuenta que la fecha también fallaba, así como el debug de fecha, y como guinda.. mucha gente esta usando la direccion de youtube completa para obtener el ID y para los usuarios menos expertos es un coñazo el extraerlo.. así que he incorporado el metodo que el genio Alex Barros diseño en Boozox y uno de sus lectores @Javier compartieron para que ahora podamos ver los vídeos no solo con la ID si no que también con la URL.

[PHP]
function youtube($id, $debug = false) {
$_id = parse_url($id);
parse_str($_id[‘query’]);
unset($_id);
$id = empty($v) ? $id : $v;

$url = ‘http://es.youtube.com/watch?v=’.$id;
$query = @file_get_contents($url);

$exp_info = ‘!&t=(.+)&!U’;
preg_match_all($exp_info,$query,$t);

$exp_info = “!!U”;
preg_match_all($exp_info,$query,$titulo);

$exp_info = “!!U”;
preg_match_all($exp_info,$query,$descripcion);

$exp_info = “!(.+) de (.+) de (.+)!U”;
preg_match_all($exp_info,$query,$fecha);

$exp_info = ““;
preg_match_all($exp_info,$query,$tags);

$exp_info = “!href=\”/user/(.+)\”!U”;
preg_match_all($exp_info,$query,$user);

$t = $t[1][0];
$titulo = $titulo[1][0];
$descripcion = $descripcion[1][0];
$fecha = ($fecha[1][0]&&$fecha[2][0]&&$fecha[3][0]) ? $fecha[1][0].’ de ‘.$fecha[2][0].’ de ‘.$fecha[3][0] : ”;
$tags = $tags[1][0];
$user = $user[1][0];

$salida[“id”] = $id;
$salida[“t”] = $t;
$salida[“url”] = $url;
$salida[“iurl”] = “http://img.youtube.com/vi/”.$id.”/2.jpg”;
$salida[“reproductor”] = “http://www.youtube.com/p.swf?video_id=”.$id.”&iurl=http://img.youtube.com/vi/”.$id.”/2.jpg&t=”.$t;
$salida[“video”] = “http://youtube.com/get_video.php?video_id=”.$id.”&t=”.$t;
$salida[“html”] = ““;
$salida[“title”] = $titulo;
$salida[“descripcion”] = $descripcion;
$salida[“fecha”] = $fecha;
$salida[“tags”] = $tags;
$salida[“usuario”] = $user;

if($debug){
//sistema de diagnostico
$salida[‘debug’] = $query;
$s[‘la url de lectura es’] = $url;
$s[‘lectura de video’] = ($query ) ? ‘si’ : ‘no’ ;
$s[‘t encontrado’] = ($t ) ? ‘si’ : ‘no’ ;
$s[‘titulo encontrado’] = ($titulo ) ? ‘si’ : ‘no’ ;
$s[‘descripcion encontrada’] = ($descripcion ) ? ‘si’ : ‘no’ ;
$s[‘fecha encontrada’] = ($fecha ) ? ‘si’ : ‘no’ ;
$s[‘tags encontrados’] = ($tags ) ? ‘si’ : ‘no’ ;
$s[‘usuario encontrado’] = ($user ) ? ‘si’ : ‘no’ ;
$s[‘contenido para debug’] = $salida;
return $s;
}
if($t == “”){ //Error de conexion
return false;
} else { // todo OK
return $salida;
}
}
[/PHP]

Un ejemplo con ID:
[PHP]
$datos = youtube(‘aWCD69urAqQ’);
print_r($datos);
[/PHP]

El mismo ejemplo de antes pero esta vez con la URL completa:
[PHP]
$datos = youtube(‘http://es.youtube.com/watch?v=aWCD69urAqQ&fmt=18’);
print_r($datos);
[/PHP]
He sacado una nueva version que corrige errores de peticion y caracteres. la podeis encontrar en Función de extracción de datos Youtube() en PHP version4

Save mobuzz (UNICA SEMANA!)


Mobuzz tv, el primer VidePodcast de nuevas tecnologías que encontré y que desde entonces me informa todas las mañanas de lo que hay en la red ha caído en las garras de la crisis, por esto necesita cumplir un imposible y de paso dar la razón sobre la opción de trabajo que muchos hemos decidido adoptar.
Necesita financiación para poder continuar con su emisión y de paso demostrar a todos que es posible que los telespectadores hagan algo mas que ser receptores pasivos de información y pasen a involucrarse no solo en la colaboración de un programa si no a demás en su financiación.

Lo que están pidiendo es un donativo que, si no se llega al lo que necesitan devolverán.
Puedes colaborar como te sea mas cómodo, via Paypal, por Transeferencia Bancaria, Enviarnos un cheque por correo o directamente puedes ir a sus oficinas, y charlar con ellos .

Entro todos podemos hacer que gente como esta, que dona su trabajo, tiempo y esfuerzo para hacer una apuesta de futuro siga aportándonos un servicios como este, de información de calidad, publica y consensuada por todos.

Por mi parte ya he roto la hucha de tierra0.com y aportado mi granito de arena… ahora te toca a ti…

linksHTML(), encuentra los archivos que contiene una pagina HTML o CSS

LinksHTMLDespués de un pequeño periodo en el que estoy bastante saturado de proyectos y en el que no he podido publicar a penas 3 lineas, os traigo una función de las que no tiene un uso concreto pero si una utilidad.
La función linksHTML() busca los archivos y direcciones que se contienen en un archivo html o css, realizando un array multidimensional a partir de sus extensiones.
El único parámetro que se necesita introducir para que funcione es una URL, (la URL del archivo a leer, la cual puede ser local o externa, pero siempre tiene que ser completa). Si la URL no tiene HTTP:// delante, no pasa nada, automaticamente la funcion lo detecta y lo pone.
Si se produce un error y el archivo no se encuentra o no se puede leer el resultado de la funcion no será el array con los archivos si no un array con un solo valor error que indicará La URL ######### no fue encontrada.

A continuación un ejemplo simple que muestra los archivos con sus respectivas extensiones en forma de arrya discriminando si la web existe o no:
[PHP]
\n”;
print_r($enlaces);
} else { //si hay errores
echo $enlaces[‘error’];
}
?>
[/PHP]

y aquí el código de la función.
[PHP]
function linksHTML($url){
//deteccion de http
$url = substr($url, 0, 7) == ‘http://’ ? $url : ‘http://’.$url;
if(!$query = @file_get_contents($url)){
return array(‘error’ => ‘La URL \”.$url.’\’ no fue encontrada.’);
}

//buscador de enlaces
preg_match_all( “!href=\”(.+)\”!U”, $query, $enlaces[‘href’] );
preg_match_all( “!src=\”(.+)\”!U”, $query, $enlaces[‘src’] );
preg_match_all( “!url\((.+)\)!U”, $query, $enlaces[‘URL-CSS’] );

$enlaces = array_unique(array_merge($enlaces[‘src’][1], $enlaces[‘href’][1], $enlaces[‘URL-CSS’][1]));

//reconstructor de enlaces
$url_base = parse_url($url); $url_base = ‘http://’.$url_base[‘host’];
$url_absolute = pathinfo($url); $url_absolute = $url_absolute[‘dirname’];

foreach($enlaces as $k => $enlace){
switch(substr($enlace, 0, 1)) {
case ‘h’: if(substr($enlace, 0, 7) == ‘http://’) break;
case ‘/’: $enlaces[$k] = $url_base .’/’. $enlace;
case ‘.’:
case ‘#’:
case ‘.’:
case ‘?’:
default: $enlaces[$k] = $url_absolute .’/’. $enlace;
}
$info = pathinfo($enlaces[$k]);
$info[‘extension’] = $info[‘extension’] == ” ? ‘html’ : $info[‘extension’];
$info[‘extension’] = strpos($enlaces[$k], ‘?’) ? ‘?’ : $info[‘extension’];
$ilegal_chars = array(‘\”, ‘%’, ‘”‘);
$s[str_replace($ilegal_chars, ”, $info[‘extension’])][] = str_replace($ilegal_chars, ”, $enlaces[$k]);
}
return $s;
}
[/PHP]
Espero comentarios de para que aplicaríais esto 😉 por mi parte prometo hacer una función/aplicación de esto pronto!

Revision del proyecto Proyector Laser de video

proyector laser RGBHace ya mas de año y pico que publique la idea de realizar una pantalla de alta definición casera a partir del movimiento de 3 punteros láser y después de tantos comentarios y visitas al tema creo que ha llegado la hora de aclararnos un poco sobre que se pretende conseguir y cuales son los pasos para conseguirlo.

La idea principal era realizar una pantalla OpenHardware, que cualquiera pudiera mejorar mientras decidan compartir esas mejoras con los demás. De esta manera todos tendremos pantallas de bajo coste y podremos hacer llegar la información a mas lugares. Por esto una de las principales cosas que buscaba era que fuera de montaje sencillo y asequible, para que no fuera muy costoso para cualquiera poder experimentar.

Por todo esto y para empezar unificando pense en utiizar como referencia los conectores que mas se utilizan desde que puse el articulo hasta la actualizad, los conectores VGA. Estos permiten utilizar salidas independientes para cada color (Rojo, Verde y Azul) y a demas tomar una señal cuadrada que indica cuando cambia de linea o de punto (sincronismo vertical u horizontal). Pero de todas formas para realizar esta idea hace falta superar algunos retos electrónicos y opticos:

Como ya se comento en el anterior articulo, el ingenio funcionaria a partir de unas piezas espejadas móviles que orientaran los haces de luz a cada punto de la pantalla. Esto se conseguiría utilizando un primer sistema que moviera el haz de derecha a izquierda creando lineas de puntos, y un segundo que moviera cada linea un punto mas abajo creando los cuadros de imagen. La utilización de esta tecnología hace que el tamaño y resolución de la pantalla pueda ser cambiado digitalmente sin utilizar piezas adicionales (llegando hasta unos limites claro).

El primer reto a superar para conseguirlo seria realizar un sistema espejado que pueda moverse al menos a 50Hz. En un primer momento para mejorar el montaje se opto por utilizar motores de CD o DVD viejos para conseguir la velocidad necesaria utilizando un engranaje dentado para hacer reflejar los haces de luz, pero pronto comunicaron que esto era igual de facil de montar como de que las lineas se vieran borrosas por la sujeción de los elementos. Por lo tanto creo que volvemos a la opción inicial.
Podríamos utilizar un altavoz, como sistema móvil, espejeando su membrana a partir de un spray cromado o utilizando algún recubrimiento de este tipo y acoplarle un circuito de transistor que utilice las señales de salida de sincronismo del conector VGA (pines13-5 y 15-10) para, directamente sin mas controladores se produzca la vibración. Lo que no se, es si tendríamos que utilizar algún elemento mas entre medias para conectarlo y poder por lo tanto hacer que la potencia en el altavoz sea suficiente.

esquema de Pines VGAEl segundo reto seria crear un circuito electrónico que permita, a partir de la potencia de cada color poder pasar la potencia proporcional al láser. Esto seria muy parecido al anterior… con un circuito de transistor que permita variar a partir de 2 potenciómetros la tensión máxima y mínima de entrada al láser nos iría genial. de esa manera podríamos regular la cromática del conjunto por separado.

Difraccion de haces laserEl ultimo reto sería óptico..
3 láser de respectivos colores para formar un punto de color necesitan estar muy bien alineados para que no desdoblen la imagen, lo que ahora se consigue con espejos que filtran espectros de color. Y este es el punto flaco del proyecto. Si utilizamos un solo conjunto móvil para los 3 láser hay que unificarlos antes de proyectarlos contra el primer espejo, por lo que a mi solo se me ha ocurrido utilizar fibra óptica. Un hilo de fibra óptica se conectaría a cada láser unificando las puntas de los 3 en un solo extremo que enfocaríamos hacia el espejo, el efecto seria casi el mismo que el de las pantallas actuales de pixeles.