Ambilight

  • VB.NET

Es gibt 8 Antworten in diesem Thema. Der letzte Beitrag () ist von Tsuyo.

    Ambilight

    Hallo,
    Ich habe mir in den Kopf gesetzt, zu versuchen "Ambilight" ganz einfach nachzubauen...einfach nur das Video in der Bildschirmmitte, und neber dem Video je links und rechts ne Picturebox, die die passende Farbe annimmt. Hätte gedacht ich nehme einfach einige Pixel am Rand und errechne daraus die Durchschnitts-Farbe (geht sowas überhaupt ?), die die Picturebox dann annehmen soll (Für den Anfang geht auch ein einzelner Pixel, soll sich aber später schon nach mehreren Pixeln richten). Später kann man das evtl. noch via Microcontroller und LED's nützlich verwenden. Soweit die Idee. Kann man sowas überhaupt realisieren ? Ich müsste ja jedes Einzelbild des Videos analysieren...Gibt es überhaupt eine Möglichkeit die Farbe eines bestimmten Pixels / durchschnitt mehrerer Pixel bei jedem Einzelbild zu erkennen und dann die Picturebox anzupassen ? Dann müsste die Picturebox ja auch 24 bzw. 30 mal pro Sekunde ihre Farbe ändern können...Hat jemand eine Idee ? :)

    „Was daraus gefolgert werden kann ist, dass jeder intelligentere User sein Geld lieber für Bier ausgibt, um einen schönen Rausch zu haben, und nicht dieses Ranzprodukt.“

    -Auszug aus einer Unterhaltung über das iPhone und dessen Vermarktung.

    Danke, das mit dem addieren klingt eigentlich logisch... ;)
    Nur wie kann ich denn jedes einzelne Frame eines Films ohne große Verzögerung analysieren ? Ich denke nicht, dass das mit der Mediaplayer-control funktioniert. Ist sowas überhaupt realisierbar ?

    der_Kurt schrieb:



    Mein Problem ist, ich will das Ganze ja nicht einfarbig. Beim Original-Ambilight ists ja auch so wenn oben blau und unten grün ist, dass die Beleuchtung auch 2farbig wird und nciht alles blau bzw. grün. Ich bin gerade dabei das erstmal an einer Picturebox auszuprobieren. Habe vor 4 Farben zu machen (links oben, links unten, rechts oben, rechts unten). Sieht bis jetzt schon mal ganz gut aus...

    Mit dem Vorschlag von Samus Aran werde ich mich mal genauer auseinandersetzen, danke !

    Dann musst du den Bereich eben in Reihen aufteilen. In Abständen von 4 oder 8 Pixeln jeweils die Farbe errechnen und für diesen Bereich setzen. (Das ist jetzt relativ theoretisch gedacht)
    „Was daraus gefolgert werden kann ist, dass jeder intelligentere User sein Geld lieber für Bier ausgibt, um einen schönen Rausch zu haben, und nicht dieses Ranzprodukt.“

    -Auszug aus einer Unterhaltung über das iPhone und dessen Vermarktung.

    Ich würde das per DirectX machen!
    SlimDX z.b kann dir sehr schnell einen 'Screenshot' eines Fensters machen das halt DX benutzt. Es gab ne Klasse von nem Spazzarama oderso. Die hatte ich Abgeändert, ist sehr sehr alter Code und man wird es aufjedenfall noch Optimieren können. Allein, dass das Device immer neu erstellt wird, macht das ganze schon wieder schlecht. Musste umschreiben, ist eh C#


    Spoiler anzeigen

    Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Text;
    4. using System.Drawing;
    5. using System.Runtime.InteropServices;
    6. using SlimDX.Direct3D9;
    7. using SlimDX;
    8. using System.Linq;
    11. namespace Spazzarama.ScreenCapture
    12. {
    13. public static class Direct3DCapture
    14. {
    15. private static SlimDX.Direct3D9.Direct3D _direct3D9 = new SlimDX.Direct3D9.Direct3D();
    16. private static Dictionary<IntPtr, SlimDX.Direct3D9.Device> _direct3DDeviceCache = new Dictionary<IntPtr, SlimDX.Direct3D9.Device>();
    18. public static Bitmap bitmap = null;
    19. public static IntPtr hWnd = IntPtr.Zero;
    20. public static SlimDX.Direct3D9.AdapterInformation adapterInfo = _direct3D9.Adapters.DefaultAdapter;
    21. public static SlimDX.Direct3D9.Device device;
    22. public static string f;
    23. public static unsafe Color CaptureRegionDirect3D(IntPtr handle, Rectangle region)
    24. {
    25. hWnd = handle;
    26. #region Get Direct3D Device
    27. if (_direct3DDeviceCache.ContainsKey(hWnd))
    28. {
    29. device = _direct3DDeviceCache[hWnd];
    30. }
    31. else
    32. {
    33. SlimDX.Direct3D9.PresentParameters parameters = new SlimDX.Direct3D9.PresentParameters();
    34. parameters.BackBufferFormat = adapterInfo.CurrentDisplayMode.Format;
    35. Rectangle clientRect = NativeMethods.GetAbsoluteClientRect(hWnd);
    36. parameters.BackBufferHeight = clientRect.Height;
    37. parameters.BackBufferWidth = clientRect.Width;
    38. parameters.Multisample = SlimDX.Direct3D9.MultisampleType.None;
    39. parameters.SwapEffect = SlimDX.Direct3D9.SwapEffect.Discard;
    40. parameters.DeviceWindowHandle = hWnd;
    41. parameters.PresentationInterval = SlimDX.Direct3D9.PresentInterval.Default;
    42. parameters.FullScreenRefreshRateInHertz = 0;
    43. try
    44. {
    45. device = new SlimDX.Direct3D9.Device(_direct3D9, adapterInfo.Adapter, SlimDX.Direct3D9.DeviceType.Hardware, hWnd, SlimDX.Direct3D9.CreateFlags.SoftwareVertexProcessing, parameters);
    46. _direct3DDeviceCache.Add(hWnd, device);
    47. }
    48. catch (SlimDX.Direct3D9.Direct3D9Exception ex) {
    49. f = ex.Message;
    51. }
    52. }
    53. #endregion
    55. using (SlimDX.Direct3D9.Surface surface = SlimDX.Direct3D9.Surface.CreateOffscreenPlain(device, adapterInfo.CurrentDisplayMode.Width, adapterInfo.CurrentDisplayMode.Height, SlimDX.Direct3D9.Format.A8R8G8B8, SlimDX.Direct3D9.Pool.SystemMemory))
    56. {
    57. device.GetFrontBufferData(0, surface);
    58. SlimDX.DataStream dat = surface.LockRectangle(region ,SlimDX.Direct3D9.LockFlags.None).Data;
    60. SlimDX.Direct3D9.SurfaceDescription desc;
    61. desc = surface.Description;
    62. /*SlimDX.Direct3D9.Texture textureCopy = new SlimDX.Direct3D9.Texture(device, desc.Width, desc.Height, 1, 0, desc.Format, SlimDX.Direct3D9.Pool.Managed);
    63. Surface dst = textureCopy.GetSurfaceLevel(0);
    64. Surface src = surface;
    65. Surface.FromSurface(dst, src, Filter.None, 0);
    66. desc = surface.Description;
    69. DataStream d = dst.LockRectangle(new Rectangle(0, 0, desc.Width, desc.Height), LockFlags.None).Data; */
    71. List<Color> l = new List<Color>();
    72. int* p = (int *)dat.DataPointer.ToPointer();
    73. for (int i = 0; i < desc.Width; i++) {
    74. int* ptr2 = (int*)((byte*)p);
    75. l.Add(Color.FromArgb(*ptr2));
    76. }
    77. // var query = l.GroupBy(item => item).OrderByDescending(g => g.Count()).Select(g => g.Key).First();
    78. var query = (from item in l
    79. group item by item into g
    80. orderby g.Count() descending
    81. select new { Item = g.Key, Count = g.Count() }).First();
    85. //int* ptr2 = (int*)((byte*)p);
    86. return (Color)query.Item ;
    87. }
    91. }
    92. }
    93. public struct ColorType
    94. {
    95. public byte b;
    96. public byte g;
    97. public byte r;
    98. public byte a;
    100. public ColorType(byte r, byte g, byte b)
    101. {
    102. this.r = r;
    103. this.g = g;
    104. this.b = b;
    105. this.a = 255;
    106. }
    107. public ColorType(Color c)
    108. {
    109. this.r = c.R;
    110. this.g = c.G;
    111. this.b = c.B;
    112. this.a = c.A;
    113. }
    114. }
    115. #region Native Win32 Interop
    116. /// <summary>
    117. /// The RECT structure defines the coordinates of the upper-left and lower-right corners of a rectangle.
    118. /// </summary>
    119. [Serializable, StructLayout(LayoutKind.Sequential)]
    120. internal struct RECT
    121. {
    122. public int Left;
    123. public int Top;
    124. public int Right;
    125. public int Bottom;
    127. public RECT(int left, int top, int right, int bottom)
    128. {
    129. this.Left = left;
    130. this.Top = top;
    131. this.Right = right;
    132. this.Bottom = bottom;
    133. }
    135. public Rectangle AsRectangle
    136. {
    137. get
    138. {
    139. return new Rectangle(this.Left, this.Top, this.Right - this.Left, this.Bottom - this.Top);
    140. }
    141. }
    143. public static RECT FromXYWH(int x, int y, int width, int height)
    144. {
    145. return new RECT(x, y, x + width, y + height);
    146. }
    148. public static RECT FromRectangle(Rectangle rect)
    149. {
    150. return new RECT(rect.Left, rect.Top, rect.Right, rect.Bottom);
    151. }
    152. }
    154. [System.Security.SuppressUnmanagedCodeSecurity()]
    155. internal sealed class NativeMethods
    156. {
    157. [DllImport("user32.dll")]
    158. internal static extern bool GetClientRect(IntPtr hWnd, out RECT lpRect);
    160. [DllImport("user32.dll")]
    161. [return: MarshalAs(UnmanagedType.Bool)]
    162. internal static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
    164. /// <summary>
    165. /// Get a windows client rectangle in a .NET structure
    166. /// </summary>
    167. /// <param name="hwnd">The window handle to look up</param>
    168. /// <returns>The rectangle</returns>
    169. internal static Rectangle GetClientRect(IntPtr hwnd)
    170. {
    171. RECT rect = new RECT();
    172. GetClientRect(hwnd, out rect);
    173. return rect.AsRectangle;
    174. }
    176. /// <summary>
    177. /// Get a windows rectangle in a .NET structure
    178. /// </summary>
    179. /// <param name="hwnd">The window handle to look up</param>
    180. /// <returns>The rectangle</returns>
    181. internal static Rectangle GetWindowRect(IntPtr hwnd)
    182. {
    183. RECT rect = new RECT();
    184. GetWindowRect(hwnd, out rect);
    185. return rect.AsRectangle;
    186. }
    188. internal static Rectangle GetAbsoluteClientRect(IntPtr hWnd)
    189. {
    190. Rectangle windowRect = NativeMethods.GetWindowRect(hWnd);
    191. Rectangle clientRect = NativeMethods.GetClientRect(hWnd);
    193. // This gives us the width of the left, right and bottom chrome - we can then determine the top height
    194. int chromeWidth = (int)((windowRect.Width - clientRect.Width) / 2);
    196. return new Rectangle(new Point(windowRect.X + chromeWidth, windowRect.Y + (windowRect.Height - clientRect.Height - chromeWidth)), clientRect.Size);
    197. }
    198. }
    199. #endregion
    200. }

Facebook
Telefonspende