Beiträge von kokoko3k

kokoko3k · 16. April 2019

I know I'm terribly late on this, but still i'm posting here because using ffmpeg in place of hypergrab-x11 was my first intent, but stumbling across this thread i tought it was just not possible, and i've had to search for alternatives (which, for instance, i found, but are far more complicated)

Anyway, it works for me the following way (tried with hypersim)

Code

#Grab at 10fps, source screen is 1920x1080
#output resolution sent to hyperiond is 64x36
source_w=1920 ; source_h=1080
dest_w=64 ;  dest_h=36
fps_in=10


  sudo rmmod v4l2loopback
  sudo modprobe v4l2loopback
  sudo v4l2loopback-ctl set-caps "video/x-raw,format=UYVY,width=$dest_w,height=$dest_h" /dev/video0
  ffmpeg -re -f x11grab -video_size "$source_w"x"$source_h" -framerate $fps_in -i :0.0 -vf scale=$dest_w:$dest_h:flags=neighbor  -pix_fmt  uyvy422  -f v4l2 /dev/video0

Alles anzeigen

kokoko3k · 10. April 2019

Hi guys, i made a new grabber that works with x11 and Linux (at least).
I modified the original HyperionScreen by ellisium, stripped something i didn't need and made some other modifications.

It is here, requires node and npm:
https://github.com/kokoko3k/hypergrabx11

Why another grabber if we already have hyperion-x11?
Since i really don't like how internal hyperion smoothing works for slow fades and since i like my fades to be really smooth and slow (1 or 2 seconds to go from black to white), i used ffmpeg and tmix filter to achieve that.
Since hypergrabx11 uses ffmpeg, it is really easy to expand his functionalities ( provided you know how to use ffmpeg).
Cpu use is good; on an i5-4590@3.3ghz i can grab 1920x1080 at 15fps with default settings, about 3%
All of the settings configurable in the settings.json file.

Have fun!

kokoko3k · 1. April 2019

Ok, after several testing, i understood that unfortunately the smooth routine "queues" fades.
I modified my sketch to fade itself and disabled the smoothing in hyperion, here it is, works well for me.

C

//put the following in Hyperion smoothing config :
/*  // SMOOTHING CONFIG
  "smoothing" :
  {
  "type"  : "linear",
  "time_ms"  : 0,
  "updateFrequency" : 60.0000,
  "updateDelay"  : 0
  }
*/


#include "FastLED.h"
// How many leds in your strip?
#define NUM_LEDS 33
// For led chips like Neopixels, which have a data line, ground, and power, you just
// need to define DATA_PIN.  For led chipsets that are SPI based (four wires - data, clock,
// ground, and power), like the LPD8806 define both DATA_PIN and CLOCK_PIN
#define DATA_PIN 3
#define CLOCK_PIN 13
#define COLOR_ORDER RGB
// Adalight sends a "Magic Word" (defined in /etc/boblight.conf) before sending the pixel data
uint8_t prefix[] = {'A', 'd', 'a'}, hi, lo, chk, i;
// Baudrate, higher rate allows faster refresh rate and more LEDs (defined in /etc/boblight.conf)
#define serialRate 500000






// Define the array of leds
CRGB leds[NUM_LEDS];
CRGB oldleds[NUM_LEDS];




float speed = 0.1; //0.0 -> 1.0




int ismooth_value_step(int iStart, int iEnd, int iStep ){
  int diff ;
  diff = iStart - iEnd ;
  if ( abs(diff) > iStep ) {

  if (iStart > iEnd) {
  return ( iStart - iStep );
  } else {
  return ( iStart + iStep );  
  }


  } else {
  return iEnd ;
  }
}


int ismooth_value_k(int iStart, int iEnd, float fSpeed){
  int diff, abs_diff ;
  diff = iStart - iEnd ;
  abs_diff = abs(diff);
  if ( abs_diff > 1 ) {

  if (iStart > iEnd) {
  return round ( iStart - (fSpeed * abs_diff) );
  } else {
  fSpeed = fSpeed / 2 ;
  return round ( iStart + (fSpeed * abs_diff ) );  
  }


  } else {
  return iEnd ;
  }
}


void setup() {
  FastLED.addLeds<WS2811, DATA_PIN, RGB>(leds, 100);  //reset a zero di tutti i led
  delay(500);
  LEDS.showColor(CRGB(0, 0, 0));
  delay(250);
  FastLED.addLeds<WS2812, DATA_PIN, RGB>(leds, NUM_LEDS);

  // initial RGB flash
  LEDS.showColor(CRGB(32, 0, 0));
  delay(100);
  LEDS.showColor(CRGB(0, 32, 0));
  delay(100);
  LEDS.showColor(CRGB(0, 0, 32));
  delay(100);
  LEDS.showColor(CRGB(0, 0, 0));
 
  Serial.begin(serialRate);
  Serial.print("Ada\n"); // Send "Magic Word" string to host
}
void loop() {
  // wait for first byte of Magic Word
  for(i = 0; i < sizeof prefix; ++i) {
  waitLoop: while (!Serial.available()) ;;
  // Check next byte in Magic Word
  if(prefix[i] == Serial.read()) continue;
  // otherwise, start over
  i = 0;
  goto waitLoop;
  }
  // Hi, Lo, Checksum
  while (!Serial.available()) ;;
  hi=Serial.read();
  while (!Serial.available()) ;;
  lo=Serial.read();
  while (!Serial.available()) ;;
  chk=Serial.read();
  // if checksum does not match go back to wait
  if (chk != (hi ^ lo ^ 0x55))
  {
  i=0;
  goto waitLoop;
  }
  memset(leds, 0, NUM_LEDS * sizeof(struct CRGB));
  // read the transmission data and set LED values
  for (uint8_t i = 0; i < NUM_LEDS; i++) {
  byte r, g, b;  
  while(!Serial.available());
  r = Serial.read();
  while(!Serial.available());
  g = Serial.read();
  while(!Serial.available());
  b = Serial.read();


  leds[i].r = ismooth_value_k(oldleds[i].r,r,speed);
  leds[i].g = ismooth_value_k(oldleds[i].g,g,speed);
  leds[i].b = ismooth_value_k(oldleds[i].b,b,speed);


  oldleds[i].r = leds[i].r ;
  oldleds[i].g = leds[i].g ;
  oldleds[i].b = leds[i].b ;


  }
  // shows new values
FastLED.show();
}

Alles anzeigen

It provides smooth and slow (play with the speed value) color fades; it differs by the hyperion implementation because it reacts immediately to the requested changes instead of waiting for the previous fade to complete.
Think at it as a sort of real time temporal smoothing.

kokoko3k · 27. März 2019

Hi, i'd like to understand better how color smoothing works.
I know, given a start color and an end color, it interpolates between them over a specified amount of time at a specified refresh rate, fine.
What i've not understood is the timing, an example with just one led should be clear:

[INDENT]Imagine i've set a slooow smoothing over 1000ms.

a) time 0ms : tell hyperiond to display 0,0,0
b) time 500ms: tell hyperiond to display 255,255,255
c) time 1000ms: tell hyperiond to display 0,255,0

What will happen?
a) To simplify things, suppose that at time 0 there is no smoothing triggered.
b) At time 500ms, hyperion will start to fade from black to white; and given the high smoothing time of 1000ms, the fade is expected to stop at time 1500ms.
c) "BUT" at time 1000ms, i tell hyperiond i want green instead, and by that time, the previous fade (b2w) is still going on, it is in the middle, and probably the led is a perfect gray (128,128,128).

So i'd like to know what would the happen at time 1000ms.
Does the fading stop and another fade starts just from 128,128,128 to 0,255,0 or will hyperiond wait for the first fade (b2w) to finish, before starting the new one from 255,255,255 to 0,255,0?[/INDENT]

I hope i've been clear enough, thanks.

kokoko3k · 15. März 2019

The following works:

Code

#include "FastLED.h"


#define NUM_LEDS 33 //<-how many leds in your strip
#define DATA_PIN 3
#define CLOCK_PIN 13


#define COLOR_ORDER RGB
#define INITIAL_DELAY 100


#define serialRate 500000


#define Gamma 2.6


CRGB leds[NUM_LEDS];


float gamma[256];






uint8_t prefix[] = {'A', 'd', 'a'}, hi, lo, chk, i;
float fR;
float fG;
float fB;
float fMax;
float fNfactor;
float fGammaOrig;
float fGammaadj;
float fMaximum;
byte r, g, b;


//Calculate gamma and return it as float
float fCalculate_Gamma( uint8_t brightness, float gamma) {
  float fGammaOrig;
  float fGammaadj;
  fGammaOrig = (float)(brightness) / (255.0);
  fGammaadj =  pow( fGammaOrig, gamma)  * (255.0);
  return fGammaadj;
}


//Find the maximum of the three
float maximum( float a, float b, float c )
{
  float max = ( a < b ) ? b : a;
  return ( ( max < c ) ? c : max );
}


//Display something to notify that arduino is working
void StartupNotification() {
  for (uint8_t i = 0; i < NUM_LEDS; i++) {
  leds[i].r = 255;
  leds[i].g = 255;
  leds[i].b = 255;
  }


  FastLED.setBrightness(255);
  FastLED.show();
  //FastLED.delay(1000);


  for (uint8_t i = 0; i < NUM_LEDS; i++) {
  leds[i].r = 0;
  leds[i].g = 0;
  leds[i].b = 0;
  }
  FastLED.show();
}




void setup() {
  FastLED.addLeds<WS2811, DATA_PIN, RGB>(leds, NUM_LEDS);
  Serial.begin(serialRate);
  Serial.print("Ada\n"); // Send "Magic Word" string to host


  //Create and fill gamma lookup tables
  for (i = 0; i < 255; i++) {
  gamma[i] = fCalculate_Gamma(i, Gamma);
  //Serial.print(gamma[i]);
  //Serial.print("\n");
  }
  gamma[255] = 255; //cant' cycle to 256 because i is byte (0..255)


  delay(INITIAL_DELAY);
  StartupNotification();


}






void loop() {
  // wait for first byte of Magic Word
  for (i = 0; i < sizeof prefix; ++i) {
  waitLoop: while (!Serial.available()) { }
  // Check next byte in Magic Word
  if (prefix[i] == Serial.read()) continue;
  // otherwise, start over
  i = 0;

  goto waitLoop;
  }


  // Hi, Lo, Checksum
  while (!Serial.available()) ;;
  hi = Serial.read();
  while (!Serial.available()) ;;
  lo = Serial.read();
  while (!Serial.available()) ;;
  chk = Serial.read();


  // if checksum does not match go back to wait
  if (chk != (hi ^ lo ^ 0x55))
  {
  i = 0;

  goto waitLoop;
  }
  memset(leds, 0, NUM_LEDS * sizeof(struct CRGB));




  int iMaximum;


  // read the transmission data and store LED values
  for (uint8_t i = 0; i < NUM_LEDS; i++) {
  while (!Serial.available());
  r = Serial.read();
  while (!Serial.available());
  g = Serial.read();
  while (!Serial.available());
  b = Serial.read();
  leds[i].r = r ;
  leds[i].g = g ;
  leds[i].b = b ;
  }


  // Normalize the strip
  //find maximum value of the "gammed" strip
  float Maximum_found=0;
  for (uint8_t i = 0; i < NUM_LEDS; i++) {
  fR = gamma[leds[i].r];
  if ( fR > Maximum_found ) { Maximum_found = fR ;}
  fG = gamma[leds[i].g];
  if ( fG > Maximum_found ) { Maximum_found = fG ;}
  fB = gamma[leds[i].b];
  if ( fB > Maximum_found ) { Maximum_found = fB ;}
  }
  fNfactor = 255 / Maximum_found;
 
 
  //normalize the strip and apply gamma
  for (uint8_t i = 0; i < NUM_LEDS; i++) {
  fR = gamma[leds[i].r];
  leds[i].r = (uint8_t)(fNfactor * fR);
  fG = gamma[leds[i].g];
  leds[i].g = (uint8_t)(fNfactor * fG);
  fB = gamma[leds[i].b];
  leds[i].b = (uint8_t)(fNfactor * fB);
  }
 
  // shows new values
  int newBrightness;
  newBrightness=(uint8_t)(Maximum_found);
  if (newBrightness == 0) {newBrightness=1;};


Serial.print("Maximum_found:") ;Serial.println(Maximum_found);
Serial.print("fNfactor:") ;Serial.println(fNfactor);
Serial.print("newBrightness:") ;Serial.println(newBrightness);


  FastLED.setBrightness(newBrightness);
  FastLED.show();
}

Alles anzeigen

What one should expect from the code above is to gain more precision at lower brightness, NOT better color fidelity.
In fact, you actually lose the ability to set different gamma values for r,g,b.
So, a dark color will appear dithered (better), but a color like this: 255,255,1 would not gain anything; this is because FastLed library does not provide different brightness per channel, just a global one; that means that 255,255,1 wil still be reproduced (after applying gamma) as 255,255,0.

You will notice that gamma correction is done inside the sketch (#define Gamma 2.6), and it is done using float values; this is needed to gain extra precision (or hyperion would just cut it to integer).

What the code does:
1 reads the color to display, and compute its gamma and store it in float.
2 Find the maximum value and use it as the master brightness factor
3 stretch/normalize the color to full range/brightness
4 display

That way, the FastLed dithering should work; one thing i'm not 100% sure is still where to put FastLED.delay.
By now i've put it inside the main waitloop, and it will wait/dither in 16ms steps; this means that arduino will see if there is data available on the serial every 16ms; this could introuduce some lag (well...16ms is not that much).

I hope to receive some code review

kokoko3k · 14. März 2019

Hi, i'm finally playing with hyperion and a ws2811 led strip.

I'm using PC -> Arduino+fastled (adalight) -> led strip.

After i configured the gamma ramp, i'm facing the problem that the lower btightness appears just black.
So i documented myself and i've found that the fastled library actually implements temporal dithering, but the way it does it is not directly accessible by hyperion, because, as stated here:

Zitat

[INDENT] * Code your animations as if they were going to run at normal full brightness; use the full range of 0..255 for RGB and HSV values as much as you wish.
* Use FastLED.setBrightness( 0..255) to adjust the brightness of your whole animation. The FastLED temporal dithering will 'kick in' automatically as you lower the master brightness control.
* In place of the standard "delay(...)" function, use "FastLED.delay(...)". FastLED will use the 'delay time' to keep the LEDs refreshed with dithered pixel values.
* Temporal dithering has no effect at full brightness (255). It exists to preserve high quality color and accurate light output when the master brightness control is turned down to save power or manage brightness.
* The more often your code calls FastLED.show(), or FastLED.delay(), the higher-quality the dithering will be, because FastLED can refresh the LEDs faster and more often.[/INDENT]

Alles anzeigen

I'm using a sketch from here, and in the code i read the following:

Code

leds[i].r = r;
    leds[i].g = g;
    leds[i].b = b;
  }
  // shows new values
FastLED.show();

...but what if we do something like this:

Code

//imagine we want to show a perfect gray (127,127,127)
   leds[i].r = 255;
   leds[i].g = 255;
   leds[i].b = 255;
FastLED.setBrightness(127);
FastLED.show();

Basically, my idea is to stretch the luma component to full range, and then call setBrightness accordingly to scale them down so that the fastled temporal dithering would kick in.
I suppose we also need to add FastLED.delay() into the sketch main loop (it is not clear to me if it needs to be done or not)

Q: "Why don't you test it by yourself?"
A: "Because i will be back at home in a month, and i just have had this idea :)"

What do you think? would it work?

Beiträge von kokoko3k

Virtual capture device /dev/video0

hypergrabx11: yet another Linux/X11 grabber, using ffmpeg

Question about color smoothing

Question about color smoothing

Arduino+ws2811 and the gamma issue.

Arduino+ws2811 and the gamma issue.