SMPFR

ca marche sous win j'ia fait une tite vidéo maintenatn j'essai de le monter sur la hdbox avec ubuntu cpa tout a fait gagné niveau soft

Faut que je trouve un moyen de vous filmer ca y'a plein de réglages à faire mais franchement !!!! ca rox du paté de poney
pourtant j'ai accroché ca en vrac derrière l'écran fait une conf vite fait
mais j'avoue que c'est magique photo incomming demain

Cela avance comme tu le souhaites ?

Ouais, on veut des tofs poulpi

alors oui ca avance comme je souhaite j'ai commandé des leds en plus
j'ai modifié le code du plugins xbmc pour faire ce que je veux et je suis en train de coder une appli android qui permet de regler la lumière d'ambiance quand la vidéo ne tourne pas

seul soucis avec les tofs / vidéo j'ai essayé avec apn tel et cie y'a rien qui fait pour rendre vriament on voit pas les couleurs ni les leds
faut que je trouve un moyen

pour l'install pour le moment c'est juste 'pendu' via des clous derrière l'écran du vidéoproj je dois aller récupérer des sections carrées de plexi pour percer et mettre les leds dedans et du coup augmenter la diffusion

je vais réessayer ce we de faire des photos correctes
sinon j'ai lancé deux personnes dans le projet qui sont en cours de commandes
ivanlefou a eu l'occasion de voir le résultat irl 10min et il a cédé à la folie de commande

une tite vidéo qui rend pas du tout honneur à l'ambilight
que ce soit avec apn / tel / gopro le résultat est le même ils ont tous des capteurs trop petits

les leds sont volontairement visibles car non fixées correctement et surtout ca permet de voir le changement d'état pour débugger
et les couleurs des leds ressortent pas sur la vidéo mais le résultat est la
c'est génial :bounce


http://www.youtube.com/watch?feature=pl ... 4cBornVEa8


sinon commande de 50 autres en cours (100 au total) pour augmenter la puissance de feu et la diffusion des couleurs

perso j'voudrais bien mais madame m'a dit n'y pense meme pas :/

pour s'amuer en manuel avec boblightd et initier le bout de code pour android


xbmc@hdbox:~/$ socket 127.0.0.1 19333
hello
>hello
set priority 100
set light 1 rgb 255 255 255
set light 1 rgb 0 0 0

et hop on peut piloter manuellement donc avec un client android / web tout ce qu'on veut du moment que ca gère les sockets

Sans faire le relou en critiquant bassement le principe de l'ambilight.

Ca détourne quand même pas mal l'attention et fait vachement ressortir les bordures de l'écran.

Y aurai pas moyen de foutre des cornière en plexi sablé sur les bordures de l'écran ?
Pour diffuser la lumière de l'ambi ...


s'trop kikooooo comme theckno.

Ok la je sort .....

et le code de xbmc-boblight pour avoir le proto de comm
tout est dedans suffit de lire

/*
 * boblight
 * Copyright (C) Bob  2009 
 * 
 * boblight is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * boblight is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see .
 */


#include "util/inclstdint.h"

#include 
#include  //debug
#include 

#include "boblight_client.h"
#include "util/misc.h"
#include "util/timeutils.h"
#include "protocolversion.h"

using namespace std;
using namespace boblight;

#define GAMMASIZE (sizeof(m_gammacurve) / sizeof(m_gammacurve[0]))

CLight::CLight()
{
  #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) variable = default;
  #include "options.h"
  #undef  BOBLIGHT_OPTION

  m_singlechange = 0.0;

  m_width = -1;
  m_height = -1;

  memset(m_rgb, 0, sizeof(m_rgb));
  m_rgbcount = 0;
  memset(m_prevrgb, 0, sizeof(m_prevrgb));
  memset(m_hscanscaled, 0, sizeof(m_hscanscaled));
  memset(m_vscanscaled, 0, sizeof(m_vscanscaled));

  for (int i = 0; i < GAMMASIZE; i++)
    m_gammacurve = i;
}

string CLight::SetOption(const char* option, bool& send)
{
  string stroption = option;
  string strname;

  send = false;
  
  if (!GetWord(stroption, strname))
    return "emtpy option"; //string with only whitespace

  #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) \
  if (strname == #name) \
  { \
    type value; \
    if (#type == "bool")\
    {\
      if (!StrToBool(stroption, *(bool*)(&value)))\
        return "invalid value " + stroption + " for option " + strname + " with type " + #type; \
    }\
    else\
    {\
      stringstream stream; \
      stream > value; \
      if (stream.fail()) return "invalid value " + stroption + " for option " + strname + " with type " + #type; \
      \
    }\
    variable = value; \
    postprocess\
    \
    return ""; \
  }
  #include "options.h"
  #undef BOBLIGHT_OPTION

  return "unknown option " + strname;
}

std::string CLight::GetOption(const char* option, std::string& output)
{
  string stroption = option;
  string strname;

  if (!GetWord(stroption, strname))
    return "emtpy option"; //string with only whitespace

  #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) \
  if (#name == strname)\
  {\
    output = ToString(variable);\
    return "";\
  }
  #include "options.h"
  #undef BOBLIGHT_OPTION

  return "unknown option";
}

void CLight::AddPixel(int* rgb)
{
  if (rgb[0] >= m_threshold || rgb[1] >= m_threshold || rgb[2] >= m_threshold)
  {
    if (m_gamma == 1.0)
    {
      m_rgb[0] += Clamp(rgb[0], 0, 255);
      m_rgb[1] += Clamp(rgb[1], 0, 255);
      m_rgb[2] += Clamp(rgb[2], 0, 255);
    }
    else
    {
      m_rgb[0] += m_gammacurve[Clamp(rgb[0], 0, GAMMASIZE - 1)];
      m_rgb[1] += m_gammacurve[Clamp(rgb[1], 0, GAMMASIZE - 1)];
      m_rgb[2] += m_gammacurve[Clamp(rgb[2], 0, GAMMASIZE - 1)];
    }
  }
  m_rgbcount++;
}

void CLight::GetRGB(float* rgb)
{
  //if no pixels are set, the denominator is 0, so just return black
  if (m_rgbcount == 0)
  {
    for (int i = 0; i < 3; i++)
    {
      rgb = 0.0f;
      m_rgb = 0.0f;
    }

    return;
  }
  
  //convert from numerator/denominator to float
  for (int i = 0; i < 3; i++)
  {
    rgb = Clamp(m_rgb / (float)m_rgbcount / 255.0f, 0.0f, 1.0f);
    m_rgb = 0.0f;
  }
  m_rgbcount = 0;

  //this tries to set the speed based on how fast the input is changing
  //it needs sync mode to work properly
  if (m_autospeed > 0.0)
  {
    float change = Abs(rgb[0] - m_prevrgb[0]) + Abs(rgb[1] - m_prevrgb[1]) + Abs(rgb[2] - m_prevrgb[2]);
    change /= 3.0;

    //only apply singlechange if it's large enough, otherwise we risk sending it continously
    if (change > 0.001)
      m_singlechange = Clamp(change * m_autospeed / 10.0, 0.0, 1.0);
    else
      m_singlechange = 0.0;
  }

  memcpy(m_prevrgb, rgb, sizeof(m_prevrgb));

  //we need some hsv adjustments
  if (m_value != 1.0 || m_valuerange[0] != 0.0 || m_valuerange[1] != 1.0 ||
      m_saturation != 1.0  || m_satrange[0] != 0.0 || m_satrange[1] != 1.0)
  {
    //rgb - hsv conversion, thanks wikipedia!
    float hsv[3];
    float max = Max(rgb[0], rgb[1], rgb[2]);
    float min = Min(rgb[0], rgb[1], rgb[2]);

    if (min == max) //grayscale
    {
      hsv[0] = -1.0f; //undefined
      hsv[1] = 0.0; //no saturation
      hsv[2] = min; //value
    }
    else
    {
      if (max == rgb[0]) //red zone
      {
        hsv[0] = (60.0f * ((rgb[1] - rgb[2]) / (max - min)) + 360.0f);
        while (hsv[0] >= 360.0f)
          hsv[0] -= 360.0f;
      }
      else if (max == rgb[1]) //green zone
      {
        hsv[0] = 60.0f * ((rgb[2] - rgb[0]) / (max - min)) + 120.0f;
      }
      else if (max == rgb[2]) //blue zone
      {
        hsv[0] = 60.0f * ((rgb[0] - rgb[1]) / (max - min)) + 240.0f;
      }
      
      hsv[1] = (max - min) / max; //saturation
      hsv[2] = max; //value
    }

    //saturation and value adjustment
    hsv[1] = Clamp(hsv[1] * m_saturation, m_satrange[0],   m_satrange[1]);
    hsv[2] = Clamp(hsv[2] * m_value,      m_valuerange[0], m_valuerange[1]);

    if (hsv[0] == -1.0f) //grayscale
    {
      for (int i = 0; i < 3; i++)
        rgb = hsv[2];
    }
    else
    {
      int hi = (int)(hsv[0] / 60.0f) % 6;
      float f = (hsv[0] / 60.0f) - (float)(int)(hsv[0] / 60.0f);

      float s = hsv[1];
      float v = hsv[2];
      float p = v * (1.0f - s);
      float q = v * (1.0f - f * s);
      float t = v * (1.0f - (1.0f - f) * s);

      if (hi == 0)
      { rgb[0] = v; rgb[1] = t; rgb[2] = p; }
      else if (hi == 1)
      { rgb[0] = q; rgb[1] = v; rgb[2] = p; }
      else if (hi == 2)
      { rgb[0] = p; rgb[1] = v; rgb[2] = t; }
      else if (hi == 3)
      { rgb[0] = p; rgb[1] = q; rgb[2] = v; }
      else if (hi == 4)
      { rgb[0] = t; rgb[1] = p; rgb[2] = v; }
      else if (hi == 5)
      { rgb[0] = v; rgb[1] = p; rgb[2] = q; }               
    }

    for (int i = 0; i < 3; i++)
      rgb = Clamp(rgb, 0.0f, 1.0f);
  }
}

//scale the light's scanrange to the dimensions set with boblight_setscanrange()
void CLight::SetScanRange(int width, int height)
{
    m_width = width;
    m_height = height;

    m_hscanscaled[0] = Round32(m_hscan[0] / 100.0 * ((float)width  - 1));
    m_hscanscaled[1] = Round32(m_hscan[1] / 100.0 * ((float)width  - 1));
    m_vscanscaled[0] = Round32(m_vscan[0] / 100.0 * ((float)height - 1));
    m_vscanscaled[1] = Round32(m_vscan[1] / 100.0 * ((float)height - 1));
}

int CBoblight::Connect(const char* address, int port, int usectimeout)
{
  CMessage message;
  CTcpData data;
  int64_t  now;
  int64_t  target;
  string   word;

  //set address
  m_usectimeout = usectimeout;
  if (address)
    m_address = address;
  else
    m_address = "127.0.0.1";

  //set port
  if (port >= 0)
    m_port = port;
  else
    m_port = 19333;

  //try to open a tcp connection
  if (m_socket.Open(m_address, m_port, m_usectimeout) != SUCCESS)
  {
    m_error = m_socket.GetError();
    return 0;
  }

  //write hello to the server, we should get hello back
  if (!WriteDataToSocket("hello\n"))
    return 0;

  if (!ReadDataToQueue())
    return 0;

  message = m_messagequeue.GetMessage();
  if (!ParseWord(message, "hello"))
  {
    m_error = m_address + ":" + ToString(m_port) + " sent gibberish";
    return 0;
  }

  //get the protocol version from the server
  if (!WriteDataToSocket("get version\n"))
    return 0;

  if (!ReadDataToQueue())
    return 0;

  message = m_messagequeue.GetMessage();
  
  if (!ParseWord(message, "version") || !GetWord(message.message, word))
  {
    m_error = m_address + ":" + ToString(m_port) + " sent gibberish";
    return 0;
  }

  //if we don't get the same protocol version back as we have, we can't work together
  if (word != PROTOCOLVERSION)
  {
    m_error = "version mismatch, " + m_address + ":" + ToString(m_port) + " has version \"" + word +
              "\", libboblight has version \"" + PROTOCOLVERSION + "\"";
    return 0;
  }

  //get lights info, like number, names and area
  if (!WriteDataToSocket("get lights\n"))
    return 0;

  if (!ReadDataToQueue())
    return 0;

  message = m_messagequeue.GetMessage();
  if (!ParseLights(message))
  {
    m_error = m_address + ":" + ToString(m_port) + " sent gibberish";
    return 0;
  }
  
  return 1;
}

CBoblight::CBoblight()
{
  int padsize = 1;
  //get option name pad size so it looks pretty
  #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) \
  if (strlen(#name) + 1 > padsize)\
    padsize = strlen(#name) + 1;
  #include "options.h"
  #undef BOBLIGHT_OPTION

  //stick in a line that describes the options
  string option = "name";
  option.append(Max(padsize - option.length(), 1), ' ');
  option += "type    min     max     default";
  m_options.push_back(option);

  //fill vector with option strings
  #define BOBLIGHT_OPTION(name, type, min, max, default, variable, postprocess) \
  {\
    string option = #name;\
    option.append(padsize - strlen(#name), ' ');\
    \
    option += #type;\
    option.append(Max(8 - strlen(#type), 1), ' ');\
    \
    option += #min;\
    option.append(Max(8 - strlen(#min), 1), ' ');\
    \
    option += #max;\
    option.append(Max(8 - strlen(#max), 1), ' ');\
    \
    if (strcmp(#default, "-1.0") == 0)\
      option += "set by boblightd";\
    else\
      option += #default;\
    \
    m_options.push_back(option);\
  }
  #include "options.h"
  #undef BOBLIGHT_OPTION
}

//reads from socket until timeout or one message has arrived
bool CBoblight::ReadDataToQueue()
{
  CTcpData data;
  int64_t  now = GetTimeUs();
  int64_t  target = now + m_usectimeout; 
  int      nrmessages = m_messagequeue.GetNrMessages();

  while (now < target && m_messagequeue.GetNrMessages() == nrmessages)
  {
    if (m_socket.Read(data) != SUCCESS)
    {
      m_error = m_socket.GetError();
      return false;
    }

    m_messagequeue.AddData(data.GetData());

    if (m_messagequeue.GetRemainingDataSize() > MAXDATA)
    {
      m_error = m_address + ":" + ToString(m_port) + " sent too much data";
      return false;
    }

    now = GetTimeUs();
  }

  if (nrmessages == m_messagequeue.GetNrMessages())
  {
    m_error = m_address + ":" + ToString(m_port) + " read timed out";
    return false;
  }
  return true;
}

bool CBoblight::WriteDataToSocket(std::string strdata)
{
  CTcpData data;
  data.SetData(strdata);

  if (m_socket.Write(data) != SUCCESS)
  {
    m_error = m_socket.GetError();
    return false;
  }
  
  return true;
}

//removes one word from the string in the messages, and compares it to wordtocmp
bool CBoblight::ParseWord(CMessage& message, std::string wordtocmp)
{
  string readword;
  if (!GetWord(message.message, readword) || readword != wordtocmp)
    return false;

  return true;
}

bool CBoblight::ParseLights(CMessage& message)
{
  string word;
  int nrlights;

  //first word in the message is "lights", second word is the number of lights
  if (!ParseWord(message, "lights") || !GetWord(message.message, word) || !StrToInt(word, nrlights) || nrlights < 1)
    return false;

  for (int i = 0; i < nrlights; i++)
  {
    CLight light;

    //read some data to the message queue if we have no messages
    if (m_messagequeue.GetNrMessages() == 0)
    {
      if (!ReadDataToQueue())
        return false;
    }

    message = m_messagequeue.GetMessage();

    //first word sent is "light, second one is the name
    if (!ParseWord(message, "light") || !GetWord(message.message, light.m_name))
    {
      return false;
    }

    //third one is "scan"
    if (!ParseWord(message, "scan"))
      return false;

    //now we read the scanrange
    string scanarea;
    for (int i = 0; i < 4; i++)
    {
      if (!GetWord(message.message, word))
        return false;

      scanarea += word + " ";
    }

    ConvertFloatLocale(scanarea); //workaround for locale mismatch (, and .)

    if (sscanf(scanarea.c_str(), "%f %f %f %f", light.m_vscan, light.m_vscan + 1, light.m_hscan, light.m_hscan + 1) != 4)
      return false;    

    m_lights.push_back(light);
  }    
  return true;
}

const char* CBoblight::GetLightName(int lightnr)
{
  if (lightnr < 0) //negative lights don't exist, so we set it to an invalid number to get the error message
    lightnr = m_lights.size();

  if (CheckLightExists(lightnr))
    return m_lights[lightnr].m_name.c_str();

  return NULL;
}

int CBoblight::SetPriority(int priority)
{
  string data = "set priority " + ToString(priority) + "\n";

  return WriteDataToSocket(data);
}

bool CBoblight::CheckLightExists(int lightnr, bool printerror /*= true*/)
{
  if (lightnr >= (int)m_lights.size())
  {
    if (printerror)
    {
      m_error = "light " + ToString(lightnr) + " doesn't exist (have " + ToString(m_lights.size()) + " lights)";
    }
    return false;
  }
  return true;
}

void CBoblight::SetScanRange(int width, int height)
{
  for (int i = 0; i < m_lights.size(); i++)
  {
    m_lights.SetScanRange(width, height);
  }
}

int CBoblight::AddPixel(int lightnr, int* rgb)
{
  if (!CheckLightExists(lightnr))
    return 0;

  if (lightnr < 0)
  {
    for (int i = 0; i < m_lights.size(); i++)
      m_lights[i].AddPixel(rgb);
  }
  else
  {
    m_lights[lightnr].AddPixel(rgb);
  }

  return 1;
}

void CBoblight::AddPixel(int* rgb, int x, int y)
{
  for (int i = 0; i < m_lights.size(); i++)
  {
    if (x >= m_lights[i].m_hscanscaled[0] && x = m_lights[i].m_vscanscaled[0] && y  0.0 && m_lights[i].m_singlechange > 0.0)
      data += "set light " + m_lights[i].m_name + " singlechange " + ToString(m_lights[i].m_singlechange) + "\n";
  }

  //send a message that we want devices to sync to our input
  if (sync)
    data += "sync\n";

  //if we want to check if our output is used, send a ping message
  if (outputused)
    data += "ping\n";

  if (!WriteDataToSocket(data))
    return 0;

  if (outputused)
    return Ping(outputused, false);
  else
    return 1;
}

int CBoblight::Ping(int* outputused, bool send)
{
  string word;
  
  if (send)
  {
    if (!WriteDataToSocket("ping\n"))
      return 0;
  }

  if (!ReadDataToQueue())
    return 0;

  CMessage message = m_messagequeue.GetMessage();

  if (!GetWord(message.message, word) || word != "ping")
  {
    m_error = m_address + ":" + ToString(m_port) + " sent gibberish";
    return 0;
  }

  //client can set outputused to NULL
  if (outputused)
  {
    if (!GetWord(message.message, word) || !StrToInt(word, *outputused))
    {
      m_error = m_address + ":" + ToString(m_port) + " sent gibberish";
      return 0;
    }
  }

  return 1;
}

int CBoblight::GetNrOptions()
{
  return m_options.size();
}

const char* CBoblight::GetOptionDescription(int option)
{
  if (option < 0 || option >= m_options.size())
    return NULL;

  return m_options[option].c_str();
}

int CBoblight::SetOption(int lightnr, const char* option)
{
  string error;
  string data;
  bool   send;
  
  if (!CheckLightExists(lightnr))
    return 0;

  if (lightnr < 0)
  {
    for (int i = 0; i < m_lights.size(); i++)
    {
      error = m_lights[i].SetOption(option, send);
      if (!error.empty())
      {
        m_error = error;
        return 0;
      }
      if (send)
      {
        data += "set light " + m_lights[i].m_name + " " + option + "\n";
      }
    }
  }
  else
  {
    error = m_lights[lightnr].SetOption(option, send);
    if (!error.empty())
    {
      m_error = error;
      return 0;
    }
    if (send)
    {
      data += "set light " + m_lights[lightnr].m_name + " " + option + "\n";
    }
  }

  if (!WriteDataToSocket(data))
    return 0;

  return 1;
}

int CBoblight::GetOption(int lightnr, const char* option, const char** output)
{
  if (lightnr < 0) //negative lights don't exist, so we set it to an invalid number to get the error message
    lightnr = m_lights.size();

  if (!CheckLightExists(lightnr))
    return 0;

  string error = m_lights[lightnr].GetOption(option, m_lastoption);
  if (!error.empty())
  {
    m_error = error;
    return 0;
  }

  *output = m_lastoption.c_str();
  
  return 1;
}

et mosie la c'est juste en attendant
je dois aller récup de la section carrée de plexi diffusant de 25*25mm pour percer et mettre les leds dedans
le tout sera en retrait du bord d'affichage
et non ca attire pas les yeux c'est vachement reposant en fait

ca rend encore mieux sur une télé ou c'est diffus vers l'arrière et vers le mur

Ha bien, donc tu fais le truc avec le plexi

C'est vrai que sur une grande surface de diffusion ça peut le faire.

Mais implique une bonne distance entre écran/mur. + pas de bibelot/tableau.. Derrière

Dans ton cas ca ilumine aussi en lateral les mur ? ? pas que en arriére ?

alors le truc avec le plexi pas comme sur les images ou les mecs se servent de plexi juste comme support

moi les leds diffusent dans la section carré et pour moi comme j'ai pas de recul pour els leds (3cm) je diffuse uniquement sur les côtés
d'ou la nécessité d'en mettre plus + le plexi pour pas voir le spot de chaque led

et pour simplifier les insctructions une fois le socket ouvert

[#FF0000]hello[/#FF0000] > pour avoir un retour d'ack
[#FF0000]ping[/#FF0000] > ca se passe de comm
[#FF0000]get lights[/#FF0000] > pour avoir le nombre de leds et leur cablage
[#FF0000]set priority x[/#FF0000] > 0 à 255 128 défaut pour la priorité des clients sur boblightd
[#FF0000]set light x rgb rrr ggg bbb[/#FF0000] >pour balancer une couleur à une led n°x basé sur l'ordre de config get lights

avec ca enjoy les clients sur n'importe quelle plateforme

''d'ou la nécessité d'en mettre plus + le plexi pour pas voir le spot de chaque led''

+1

Je voyer justement une corniere voir meme un U de plexi sablé/opaque avec les led enfoncer dans la bordure de la plaque de dériére.

qq un a testé avec raspberry pour le decodage video + ambilight ?

y'en a mais au final je doute que ce soit suffisant
le raspbe c'est vraiment trop petit comme bestiole

Si tu utilise les capacité du gpu (encodage décodage ) chat devrait le faire

nop enfin ca dépend combien de leds mais la réponse est non ^^ pour uen conf sympa ce sera trop limite ou alors faut bidouiller les clients

moi j'ai tweak un peu le plugin xbmc-boblight et ca me prend facile 20-25% cpu sur un i3 (c'est du screen capture 60x / seconde qd meme + analyse)

Heyuuuu 60fois par seconds?
Amha au dela de 25 par secondes OSEF

ca depend ce que tu regarde

Tu fera une recap des tarots de l'ensemble aussi (en prix public...) ???

Bah pour faire simple
Arduino 20€
Leds 25x : 25€ la bande

J'ai du m'en tirer avec un transfo et 4 bandes pour 150€ 170€ en tout

des fois que , puisque ca a l'air d’être tendance : http://forum.hardware.fr/hfr/AchatsVent ... _1.htm#bas

le systeme est fort sympa en tout cas

sur la baie y a des arduino like a 25€ sinon des mega 2590 ou 2560 je sais plus la reference