PageRenderTime 462ms CodeModel.GetById 232ms RepoModel.GetById 4ms app.codeStats 0ms

/ImportedSources/vlc/modules/video_filter/atmo/atmo.cpp

https://bitbucket.org/erndev/dreambox-live
C++ | 2827 lines | 1804 code | 432 blank | 591 comment | 229 complexity | 1567ae33e47c0f83325cc129e406fec1 MD5 | raw file
Possible License(s): CC-BY-SA-3.0, WTFPL, LGPL-2.0, GPL-2.0, GPL-3.0, LGPL-2.1, LGPL-3.0 
    

  1. /*****************************************************************************
    2. 

  2. * atmo.cpp : "Atmo Light" video filter
    3. 

  3. *****************************************************************************
    4. 

  4. * Copyright (C) 2000-2006 the VideoLAN team
    5. 

  5. * $Id: 1145e0e2266bda71e1d28c2b1468ee99b5dcc31a $
    6. 

  6. *
    7. 

  7. * Authors: André Weber (WeberAndre@gmx.de)
    8. 

  8. *
    9. 

  9. * This program is free software; you can redistribute it and/or modify
    10. 

  10. * it under the terms of the GNU General Public License as published by
    11. 

  11. * the Free Software Foundation; either version 2 of the License, or
    12. 

  12. * (at your option) any later version.
    13. 

  13. *
    14. 

  14. * This program is distributed in the hope that it will be useful,
    15. 

  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16. 

  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17. 

  17. * GNU General Public License for more details.
    18. 

  18. *
    19. 

  19. * You should have received a copy of the GNU General Public License
    20. 

  20. * along with this program; if not, write to the Free Software
    21. 

  21. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
    22. 

  22. *****************************************************************************/
    23. 

  23. 

  24. /*****************************************************************************
    25. 

  25. * Preamble
    26. 

  26. *****************************************************************************/
    27. 

  27. #define __STDC_FORMAT_MACROS 1
    28. 

  28. #include <stdlib.h>                                      /* malloc(), free() */
    29. 

  29. #include <string.h>
    30. 

  30. #include <math.h>                                            /* sin(), cos() */
    31. 

  31. #include <assert.h>
    32. 

  32. 

  33. #ifdef HAVE_CONFIG_H
    34. 

  34. # include "config.h"
    35. 

  35. #endif
    36. 

  36. 

  37. // #define __ATMO_DEBUG__
    38. 

  38. 

  39. // [:Zs]+$
    40. 

  40. #include <vlc_common.h>
    41. 

  41. #include <vlc_plugin.h>
    42. 

  42. #include <vlc_vout.h>
    43. 

  43. 

  44. #include <vlc_playlist.h>
    45. 

  45. #include <vlc_filter.h>
    46. 

  46. 

  47. #include "filter_picture.h"
    48. 

  48. 

  49. #include "AtmoDefs.h"
    50. 

  50. #include "AtmoDynData.h"
    51. 

  51. #include "AtmoLiveView.h"
    52. 

  52. #include "AtmoTools.h"
    53. 

  53. #include "AtmoExternalCaptureInput.h"
    54. 

  54. #include "AtmoConfig.h"
    55. 

  55. #include "AtmoConnection.h"
    56. 

  56. #include "AtmoClassicConnection.h"
    57. 

  57. 

  58. 

  59. /*****************************************************************************
    60. 

  60. * Local prototypes
    61. 

  61. *****************************************************************************/
    62. 

  62. /* directly to vlc related functions required that the module is accepted */
    63. 

  63. static int  CreateFilter    ( vlc_object_t * );
    64. 

  64. static void DestroyFilter   ( vlc_object_t * );
    65. 

  65. static picture_t * Filter( filter_t *, picture_t *);
    66. 

  66. 

  67. /* callback for global variable state pause / continue / stop events */
    68. 

  68. static void AddStateVariableCallback( filter_t *);
    69. 

  69. static void DelStateVariableCallback( filter_t *);
    70. 

  70. static int StateCallback(vlc_object_t *, char const *,
    71. 

  71.                          vlc_value_t, vlc_value_t, void *);
    72. 

  72. 

  73. /* callback for atmo settings variables whose change
    74. 

  74.    should be immediately realized and applied to output
    75. 

  75. */
    76. 

  76. static void DelAtmoSettingsVariablesCallbacks(filter_t *);
    77. 

  77. static void AddAtmoSettingsVariablesCallbacks(filter_t *);
    78. 

  78. static int AtmoSettingsCallback(vlc_object_t *, char const *,
    79. 

  79.                                 vlc_value_t, vlc_value_t, void *);
    80. 

  80. 

  81. 

  82. #if defined(__ATMO_DEBUG__)
    83. 

  83. static void atmo_parse_crop(char *psz_cropconfig,
    84. 

  84.                             video_format_t fmt_in,
    85. 

  85.                             video_format_t fmt_render,
    86. 

  86.                             int &i_visible_width,
    87. 

  87.                             int &i_visible_height,
    88. 

  88.                             int &i_x_offset,
    89. 

  89.                             int &i_y_offset );
    90. 

  90. #endif
    91. 

  91. 

  92. 

  93. /* function to shutdown the fade thread which is started on pause*/
    94. 

  94. static void CheckAndStopFadeThread(filter_t *);
    95. 

  95. 

  96. /* extracts a small RGB (BGR) Image from an YUV image */
    97. 

  97. static void ExtractMiniImage_YUV(filter_sys_t *, picture_t *, uint8_t *);
    98. 

  98. 

  99. #if defined(__ATMO_DEBUG__)
    100. 

  100. void SaveBitmap(filter_sys_t *p_sys, uint8_t *p_pixels, char *psz_filename);
    101. 

  101. #endif
    102. 

  102. 

  103. /*****************************************************************************
    104. 

  104. * External Prototypes for the AtmoCtrlLib.DLL
    105. 

  105. *****************************************************************************/
    106. 

  106. /*
    107. 

  107. * if effectmode = emLivePicture then the source could be GDI (Screencapture)
    108. 

  108. * or External - this means another application delivers Pixeldata to AtmoWin
    109. 

  109. * Clientsoftware through  AtmoCtrlLib.DLL and the COM Api
    110. 

  110. */
    111. 

  111. #define lvsGDI           0
    112. 

  112. #define lvsExternal      1
    113. 

  113. 

  114. #define CLASSIC_ATMO_NUM_ZONES  5
    115. 

  115. 

  116. 

  117. /*
    118. 

  118. strings for settings menus and hints
    119. 

  119. */
    120. 

  120. #define MODULE_DESCRIPTION N_ ( \
    121. 

  121.  "This module allows to control an so called AtmoLight device "\
    122. 

  122.  "connected to your computer.\n"\
    123. 

  123.  "AtmoLight is the homegrown version of what Philips calls AmbiLight.\n"\
    124. 

  124.  "If you need further information feel free to visit us at\n\n"\
    125. 

  125.  "http://www.vdr-wiki.de/wiki/index.php/Atmo-plugin\n"\
    126. 

  126.  "http://www.vdr-wiki.de/wiki/index.php/AtmoWin\n\n"\
    127. 

  127.  "You can find there detailed descriptions on how to build it for yourself "\
    128. 

  128.  "and where to get the required parts.\n" \
    129. 

  129.  "You can also have a look at pictures and some movies showing such a device " \
    130. 

  130.  "in live action.")
    131. 

  131. 

  132. #define DRIVER_TEXT            N_("Device type")
    133. 

  133. #define DRIVER_LONGTEXT        N_("Choose your preferred hardware from " \
    134. 

  134.                                   "the list, or choose AtmoWin Software " \
    135. 

  135.                                   "to delegate processing to the external " \
    136. 

  136.                                   "process - with more options")
    137. 

  137. 

  138. static const int pi_device_type_values[] = {
    139. 

  139. #if defined( WIN32 )
    140. 

  140.      0, /* use AtmoWinA.exe userspace driver */
    141. 

  141. #endif
    142. 

  142.      1, /* AtmoLight classic */
    143. 

  143.      2, /* Quattro AtmoLight */
    144. 

  144.      3, /* DMX Device */
    145. 

  145.      4, /* MoMoLight device */
    146. 

  146.      5  /* fnordlicht */
    147. 

  147. };
    148. 

  148. static const char *const ppsz_device_type_descriptions[] = {
    149. 

  149. #if defined( WIN32 )
    150. 

  150.         N_("AtmoWin Software"),
    151. 

  151. #endif
    152. 

  152.         N_("Classic AtmoLight"),
    153. 

  153.         N_("Quattro AtmoLight"),
    154. 

  154.         N_("DMX"),
    155. 

  155.         N_("MoMoLight"),
    156. 

  156.         N_("fnordlicht")
    157. 

  157. };
    158. 

  158. 

  159. #define DMX_CHANNELS_TEXT      N_("Count of AtmoLight channels")
    160. 

  160. #define DMX_CHANNELS_LONGTEXT  N_("How many AtmoLight channels, should be " \
    161. 

  161.                                   "emulated with that DMX device")
    162. 

  162. #define DMX_CHBASE_TEXT        N_("DMX address for each channel")
    163. 

  163. #define DMX_CHBASE_LONGTEXT    N_("Define here the DMX base address for each " \
    164. 

  164.                                   "channel use , or ; to separate the values")
    165. 

  165. 

  166. #define MOMO_CHANNELS_TEXT      N_("Count of channels")
    167. 

  167. #define MOMO_CHANNELS_LONGTEXT  N_("Depending on your MoMoLight hardware " \
    168. 

  168.                                    "choose 3 or 4 channels")
    169. 

  169. 

  170. #define FNORDLICHT_AMOUNT_TEXT      N_("Count of fnordlicht's")
    171. 

  171. #define FNORDLICHT_AMOUNT_LONGTEXT  N_("Depending on the amount your " \
    172. 

  172.                                    "fnordlicht hardware " \
    173. 

  173.                                    "choose 1 to 254 channels")
    174. 

  174. 

  175. #if defined( WIN32 )
    176. 

  176. #  define DEFAULT_DEVICE   0
    177. 

  177. #else
    178. 

  178. #  define DEFAULT_DEVICE   1
    179. 

  179. #endif
    180. 

  180. 

  181. #if defined( __ATMO_DEBUG__ )
    182. 

  182. #   define SAVEFRAMES_TEXT     N_("Save Debug Frames")
    183. 

  183. #   define SAVEFRAMES_LONGTEXT N_("Write every 128th miniframe to a folder.")
    184. 

  184. #   define FRAMEPATH_TEXT      N_("Debug Frame Folder")
    185. 

  185. #   define FRAMEPATH_LONGTEXT  N_("The path where the debugframes " \
    186. 

  186.                                   "should be saved")
    187. 

  187. #endif
    188. 

  188. 

  189. #define WIDTH_TEXT             N_("Extracted Image Width")
    190. 

  190. #define WIDTH_LONGTEXT         N_("The width of the mini image for " \
    191. 

  191.                                   "further processing (64 is default)")
    192. 

  192. 

  193. #define HEIGHT_TEXT            N_("Extracted Image Height")
    194. 

  194. #define HEIGHT_LONGTEXT        N_("The height of the mini image for " \
    195. 

  195.                                   "further processing (48 is default)")
    196. 

  196. 

  197. #define SHOW_DOTS_TEXT         N_("Mark analyzed pixels")
    198. 

  198. #define SHOW_DOTS_LONGTEXT     N_("makes the sample grid visible on screen as "\
    199. 

  199.                                   "white pixels")
    200. 

  200. 

  201. #define PCOLOR_TEXT            N_("Color when paused")
    202. 

  202. #define PCOLOR_LONGTEXT        N_("Set the color to show if the user " \
    203. 

  203.                                   "pauses the video. (Have light to get " \
    204. 

  204.                                   "another beer?)")
    205. 

  205. #define PCOLOR_RED_TEXT        N_("Pause-Red")
    206. 

  206. #define PCOLOR_RED_LONGTEXT    N_("Red component of the pause color")
    207. 

  207. #define PCOLOR_GREEN_TEXT      N_("Pause-Green")
    208. 

  208. #define PCOLOR_GREEN_LONGTEXT  N_("Green component of the pause color")
    209. 

  209. #define PCOLOR_BLUE_TEXT       N_("Pause-Blue")
    210. 

  210. #define PCOLOR_BLUE_LONGTEXT   N_("Blue component of the pause color")
    211. 

  211. #define FADESTEPS_TEXT         N_("Pause-Fadesteps")
    212. 

  212. #define FADESTEPS_LONGTEXT     N_("Number of steps to change current color " \
    213. 

  213.                                   "to pause color (each step takes 40ms)")
    214. 

  214. 

  215. #define ECOLOR_RED_TEXT        N_("End-Red")
    216. 

  216. #define ECOLOR_RED_LONGTEXT    N_("Red component of the shutdown color")
    217. 

  217. #define ECOLOR_GREEN_TEXT      N_("End-Green")
    218. 

  218. #define ECOLOR_GREEN_LONGTEXT  N_("Green component of the shutdown color")
    219. 

  219. #define ECOLOR_BLUE_TEXT       N_("End-Blue")
    220. 

  220. #define ECOLOR_BLUE_LONGTEXT   N_("Blue component of the shutdown color")
    221. 

  221. #define EFADESTEPS_TEXT        N_("End-Fadesteps")
    222. 

  222. #define EFADESTEPS_LONGTEXT  N_("Number of steps to change current color to " \
    223. 

  223.                              "end color for dimming up the light in cinema " \
    224. 

  224.                              "style... (each step takes 40ms)")
    225. 

  225. 

  226. #define ZONE_TOP_TEXT          N_("Number of zones on top")
    227. 

  227. #define ZONE_TOP_LONGTEXT      N_("Number of zones on the top of the screen")
    228. 

  228. #define ZONE_BOTTOM_TEXT       N_("Number of zones on bottom")
    229. 

  229. #define ZONE_BOTTOM_LONGTEXT   N_("Number of zones on the bottom of the screen")
    230. 

  230. #define ZONE_LR_TEXT           N_("Zones on left / right side")
    231. 

  231. #define ZONE_LR_LONGTEXT       N_("left and right side having allways the " \
    232. 

  232.                                   "same number of zones")
    233. 

  233. #define ZONE_SUMMARY_TEXT      N_("Calculate a average zone")
    234. 

  234. #define ZONE_SUMMARY_LONGTEXT  N_("it contains the average of all pixels " \
    235. 

  235.                                   "in the sample image (only useful for " \
    236. 

  236.                                   "single channel AtmoLight)")
    237. 

  237. 

  238. 

  239. #define USEWHITEADJ_TEXT       N_("Use Software White adjust")
    240. 

  240. #define USEWHITEADJ_LONGTEXT   N_("Should the buildin driver do a white " \
    241. 

  241.                                   "adjust or your LED stripes? recommend.")
    242. 

  242. #define WHITE_RED_TEXT         N_("White Red")
    243. 

  243. #define WHITE_RED_LONGTEXT     N_("Red value of a pure white on your "\
    244. 

  244.                                   "LED stripes.")
    245. 

  245. #define WHITE_GREEN_TEXT       N_("White Green")
    246. 

  246. #define WHITE_GREEN_LONGTEXT   N_("Green value of a pure white on your "\
    247. 

  247.                                   "LED stripes.")
    248. 

  248. #define WHITE_BLUE_TEXT        N_("White Blue")
    249. 

  249. #define WHITE_BLUE_LONGTEXT    N_("Blue value of a pure white on your "\
    250. 

  250.                                   "LED stripes.")
    251. 

  251. 

  252. #define SERIALDEV_TEXT         N_("Serial Port/Device")
    253. 

  253. #define SERIALDEV_LONGTEXT   N_("Name of the serial port where the AtmoLight "\
    254. 

  254.                                 "controller is attached to.\n" \
    255. 

  255.                                 "On Windows usually something like COM1 or " \
    256. 

  256.                                 "COM2. On Linux /dev/ttyS01 f.e.")
    257. 

  257. 

  258. #define EDGE_TEXT            N_("Edge Weightning")
    259. 

  259. #define EDGE_LONGTEXT        N_("Increasing this value will result in color "\
    260. 

  260.                                 "more depending on the border of the frame.")
    261. 

  261. #define BRIGHTNESS_TEXT     N_("Brightness")
    262. 

  262. #define BRIGHTNESS_LONGTEXT N_("Overall brightness of your LED stripes")
    263. 

  263. #define DARKNESS_TEXT       N_("Darkness Limit")
    264. 

  264. #define DARKNESS_LONGTEXT   N_("Pixels with a saturation lower than this will "\
    265. 

  265.                                "be ignored. Should be greater than one for "\
    266. 

  266.                                "letterboxed videos.")
    267. 

  267. #define HUEWINSIZE_TEXT     N_("Hue windowing")
    268. 

  268. #define HUEWINSIZE_LONGTEXT N_("Used for statistics.")
    269. 

  269. #define SATWINSIZE_TEXT     N_("Sat windowing")
    270. 

  270. #define SATWINSIZE_LONGTEXT N_("Used for statistics.")
    271. 

  271. 

  272. #define MEANLENGTH_TEXT     N_("Filter length (ms)")
    273. 

  273. #define MEANLENGTH_LONGTEXT N_("Time it takes until a color is completely "\
    274. 

  274.                                 "changed. This prevents flickering.")
    275. 

  275. #define MEANTHRESHOLD_TEXT     N_("Filter threshold")
    276. 

  276. #define MEANTHRESHOLD_LONGTEXT N_("How much a color has to be changed for an "\
    277. 

  277.                                   "immediate color change.")
    278. 

  278. #define MEANPERCENTNEW_TEXT     N_("Filter Smoothness (in %)")
    279. 

  279. #define MEANPERCENTNEW_LONGTEXT N_("Filter Smoothness")
    280. 

  280. 

  281. #define FILTERMODE_TEXT        N_("Output Color filter mode")
    282. 

  282. #define FILTERMODE_LONGTEXT    N_("defines the how the output color should " \
    283. 

  283.                                   "be calculated based on previous color")
    284. 

  284. 

  285. static const int pi_filtermode_values[] = {
    286. 

  286.        (int)afmNoFilter,
    287. 

  287.        (int)afmCombined,
    288. 

  288.        (int)afmPercent
    289. 

  289. };
    290. 

  290. static const char *const ppsz_filtermode_descriptions[] = {
    291. 

  291.         N_("No Filtering"),
    292. 

  292.         N_("Combined"),
    293. 

  293.         N_("Percent")
    294. 

  294. };
    295. 

  295. 

  296. #define FRAMEDELAY_TEXT       N_("Frame delay (ms)")
    297. 

  297. #define FRAMEDELAY_LONGTEXT   N_("Helps to get the video output and the light "\
    298. 

  298.                                  "effects in sync. Values around 20ms should " \
    299. 

  299.                                  "do the trick.")
    300. 

  300. 

  301. 

  302. #define CHANNEL_0_ASSIGN_TEXT N_("Channel 0: summary")
    303. 

  303. #define CHANNEL_1_ASSIGN_TEXT N_("Channel 1: left")
    304. 

  304. #define CHANNEL_2_ASSIGN_TEXT N_("Channel 2: right")
    305. 

  305. #define CHANNEL_3_ASSIGN_TEXT N_("Channel 3: top")
    306. 

  306. #define CHANNEL_4_ASSIGN_TEXT N_("Channel 4: bottom")
    307. 

  307. 

  308. #define CHANNELASSIGN_LONGTEXT N_("Maps the hardware channel X to logical "\
    309. 

  309.                                   "zone Y to fix wrong wiring :-)")
    310. 

  310. static const int pi_zone_assignment_values[] = {
    311. 

  311.     -1,
    312. 

  312.      4,
    313. 

  313.      3,
    314. 

  314.      1,
    315. 

  315.      0,
    316. 

  316.      2
    317. 

  317. };
    318. 

  318. static const char *const ppsz_zone_assignment_descriptions[] = {
    319. 

  319.         N_("disabled"),
    320. 

  320.         N_("Zone 4:summary"),
    321. 

  321.         N_("Zone 3:left"),
    322. 

  322.         N_("Zone 1:right"),
    323. 

  323.         N_("Zone 0:top"),
    324. 

  324.         N_("Zone 2:bottom")
    325. 

  325. };
    326. 

  326. #define CHANNELS_ASSIGN_TEXT        N_("Channel / Zone Assignment")
    327. 

  327. #define CHANNELS_ASSIGN_LONGTEXT N_("for devices with more than five " \
    328. 

  328.                   "channels / zones write down here for each channel " \
    329. 

  329.                   "the zone number to show and separate the values with " \
    330. 

  330.                   ", or ; and use -1 to not use some channels. For the " \
    331. 

  331.                   "classic AtmoLight the sequence 4,3,1,0,2 would set the " \
    332. 

  332.                   "default channel/zone mapping. " \
    333. 

  333.                   "Having only two zones on top, and one zone on left and " \
    334. 

  334.                   "right and no summary zone the mapping for classic " \
    335. 

  335.                   "AtmoLight would be -1,3,2,1,0")
    336. 

  336. 

  337. #define ZONE_0_GRADIENT_TEXT N_("Zone 0: Top gradient")
    338. 

  338. #define ZONE_1_GRADIENT_TEXT N_("Zone 1: Right gradient")
    339. 

  339. #define ZONE_2_GRADIENT_TEXT N_("Zone 2: Bottom gradient")
    340. 

  340. #define ZONE_3_GRADIENT_TEXT N_("Zone 3: Left gradient")
    341. 

  341. #define ZONE_4_GRADIENT_TEXT N_("Zone 4: Summary gradient")
    342. 

  342. #define ZONE_X_GRADIENT_LONG_TEXT N_("Defines a small bitmap with 64x48 "\
    343. 

  343.                                      "pixels, containing a grayscale gradient")
    344. 

  344. 

  345. #define GRADIENT_PATH_TEXT      N_("Gradient bitmap searchpath")
    346. 

  346. #define GRADIENT_PATH_LONGTEXT  N_("Now preferred option to assign gradient "\
    347. 

  347.     "bitmaps, put them as zone_0.bmp, zone_1.bmp etc. into one folder and "\
    348. 

  348.     "set the foldername here")
    349. 

  349. 

  350. #if defined( WIN32 )
    351. 

  351. #   define ATMOWINEXE_TEXT      N_("Filename of AtmoWin*.exe")
    352. 

  352. #   define ATMOWINEXE_LONGTEXT  N_("if you want the AtmoLight control "\
    353. 

  353.                                    "software to be launched by VLC, enter the "\
    354. 

  354.                                    "complete path of AtmoWinA.exe here.")
    355. 

  355. #endif
    356. 

  356. 

  357. #define CFG_PREFIX "atmo-"
    358. 

  358. 

  359. /*****************************************************************************
    360. 

  360. * Module descriptor
    361. 

  361. *****************************************************************************/
    362. 

  362. vlc_module_begin ()
    363. 

  363. set_description( N_("AtmoLight Filter") )
    364. 

  364. set_help( MODULE_DESCRIPTION )
    365. 

  365. set_shortname( N_( "AtmoLight" ))
    366. 

  366. set_category( CAT_VIDEO )
    367. 

  367. set_subcategory( SUBCAT_VIDEO_VFILTER )
    368. 

  368. 

  369. set_capability( "video filter2", 0 )
    370. 

  370. 

  371. 

  372. set_section( N_("Choose Devicetype and Connection" ), 0 )
    373. 

  373. 

  374. add_integer( CFG_PREFIX "device", DEFAULT_DEVICE,
    375. 

  375.             DRIVER_TEXT, DRIVER_LONGTEXT, false )
    376. 

  376. change_integer_list( pi_device_type_values,
    377. 

  377.                      ppsz_device_type_descriptions )
    378. 

  378. 

  379. #if defined(WIN32)
    380. 

  380. add_string(CFG_PREFIX "serialdev", "COM1",
    381. 

  381.            SERIALDEV_TEXT, SERIALDEV_LONGTEXT, false )
    382. 

  382. /*
    383. 

  383.     on win32 the executeable external driver application
    384. 

  384.     for automatic start if needed
    385. 

  385. */
    386. 

  386. add_loadfile(CFG_PREFIX "atmowinexe", NULL,
    387. 

  387.              ATMOWINEXE_TEXT, ATMOWINEXE_LONGTEXT, false )
    388. 

  388. #else
    389. 

  389. add_string(CFG_PREFIX "serialdev", "/dev/ttyUSB0",
    390. 

  390.            SERIALDEV_TEXT, SERIALDEV_LONGTEXT, false )
    391. 

  391. #endif
    392. 

  392. 

  393. /*
    394. 

  394.     color which is showed if you want durring pausing
    395. 

  395.     your movie ... used for both buildin / external
    396. 

  396. */
    397. 

  397. set_section( N_("Illuminate the room with this color on pause" ), 0 )
    398. 

  398. add_bool(CFG_PREFIX "usepausecolor", false,
    399. 

  399.          PCOLOR_TEXT, PCOLOR_LONGTEXT, false)
    400. 

  400. add_integer_with_range(CFG_PREFIX "pcolor-red",   0, 0, 255, NULL,
    401. 

  401.                        PCOLOR_RED_TEXT, PCOLOR_RED_LONGTEXT, false)
    402. 

  402. add_integer_with_range(CFG_PREFIX "pcolor-green", 0, 0, 255, NULL,
    403. 

  403.                        PCOLOR_GREEN_TEXT, PCOLOR_GREEN_LONGTEXT, false)
    404. 

  404. add_integer_with_range(CFG_PREFIX "pcolor-blue",  192, 0, 255, NULL,
    405. 

  405.                        PCOLOR_BLUE_TEXT, PCOLOR_BLUE_LONGTEXT, false)
    406. 

  406. add_integer_with_range(CFG_PREFIX "fadesteps", 50, 1, 250, NULL,
    407. 

  407.                        FADESTEPS_TEXT, FADESTEPS_LONGTEXT, false)
    408. 

  408. 

  409. /*
    410. 

  410.     color which is showed if you finished watching your movie ...
    411. 

  411.     used for both buildin / external
    412. 

  412. */
    413. 

  413. set_section( N_("Illuminate the room with this color on shutdown" ), 0 )
    414. 

  414. add_integer_with_range(CFG_PREFIX "ecolor-red",   192, 0, 255, NULL,
    415. 

  415.                        ECOLOR_RED_TEXT,   ECOLOR_RED_LONGTEXT,   false)
    416. 

  416. add_integer_with_range(CFG_PREFIX "ecolor-green", 192, 0, 255, NULL,
    417. 

  417.                        ECOLOR_GREEN_TEXT, ECOLOR_GREEN_LONGTEXT, false)
    418. 

  418. add_integer_with_range(CFG_PREFIX "ecolor-blue",  192, 0, 255, NULL,
    419. 

  419.                        ECOLOR_BLUE_TEXT,  ECOLOR_BLUE_LONGTEXT,  false)
    420. 

  420. add_integer_with_range(CFG_PREFIX "efadesteps",    50, 1, 250, NULL,
    421. 

  421.                        EFADESTEPS_TEXT,   EFADESTEPS_LONGTEXT,    false)
    422. 

  422. 

  423. 

  424. set_section( N_("DMX options" ), 0 )
    425. 

  425. add_integer_with_range(CFG_PREFIX "dmx-channels",   5, 1, 64, NULL,
    426. 

  426.                        DMX_CHANNELS_TEXT, DMX_CHANNELS_LONGTEXT, false)
    427. 

  427. add_string(CFG_PREFIX "dmx-chbase", "0,3,6,9,12",
    428. 

  428.                        DMX_CHBASE_TEXT, DMX_CHBASE_LONGTEXT, false )
    429. 

  429. 

  430. set_section( N_("MoMoLight options" ), 0 )
    431. 

  431. add_integer_with_range(CFG_PREFIX "momo-channels",   3, 3, 4, NULL,
    432. 

  432.                        MOMO_CHANNELS_TEXT, MOMO_CHANNELS_LONGTEXT, false)
    433. 

  433. 

  434. /* 2,2,4 means 2 is the default value, 1 minimum amount,
    435. 

  435.    4 maximum amount
    436. 

  436. */
    437. 

  437. set_section( N_("fnordlicht options" ), 0 )
    438. 

  438. add_integer_with_range(CFG_PREFIX "fnordlicht-amount",   2, 1, 254, NULL,
    439. 

  439.                        FNORDLICHT_AMOUNT_TEXT,
    440. 

  440.                        FNORDLICHT_AMOUNT_LONGTEXT, false)
    441. 

  441. 

  442. 

  443. /*
    444. 

  444.   instead of redefining the original AtmoLight zones with gradient
    445. 

  445.   bitmaps, we can now define the layout of the zones useing these
    446. 

  446.   parameters - the function with the gradient bitmaps would still
    447. 

  447.   work (but for most cases its no longer required)
    448. 

    449. 

  449.   short description whats this means - f.e. the classic atmo would
    450. 

  450.   have this layout
    451. 

  451.   zones-top    = 1  - zone 0
    452. 

  452.   zones-lr     = 1  - zone 1 und zone 3
    453. 

  453.   zones-bottom = 1  - zone 2
    454. 

  454.   zone-summary = true - zone 4
    455. 

  455.          Z0
    456. 

  456.    ,------------,
    457. 

  457.    |            |
    458. 

  458.  Z3|     Z4     | Z1
    459. 

  459.    |____________|
    460. 

  460.          Z2
    461. 

    462. 

  462.   the zone numbers will be counted clockwise starting at top / left
    463. 

  463.   if you want to split the light at the top, without having a bottom zone
    464. 

  464.   (which is my private config)
    465. 

    466. 

  466.   zones-top    = 2  - zone 0, zone 1
    467. 

  467.   zones-lr     = 1  - zone 2 und zone 3
    468. 

  468.   zones-bottom = 0
    469. 

  469.   zone-summary = false
    470. 

    471. 

  471.       Z0    Z1
    472. 

  472.    ,------------,
    473. 

  473.    |            |
    474. 

  474.  Z3|            | Z2
    475. 

  475.    |____________|
    476. 

    477. 

  477. */
    478. 

  478. 

  479. set_section( N_("Zone Layout for the build-in Atmo" ), 0 )
    480. 

  480. add_integer_with_range(CFG_PREFIX "zones-top",   1, 0, 16, NULL,
    481. 

  481.                        ZONE_TOP_TEXT, ZONE_TOP_LONGTEXT, false)
    482. 

  482. add_integer_with_range(CFG_PREFIX "zones-bottom",   1, 0, 16, NULL,
    483. 

  483.                        ZONE_BOTTOM_TEXT, ZONE_BOTTOM_LONGTEXT, false)
    484. 

  484. add_integer_with_range(CFG_PREFIX "zones-lr",   1, 0, 16, NULL,
    485. 

  485.                        ZONE_LR_TEXT, ZONE_LR_LONGTEXT, false)
    486. 

  486. add_bool(CFG_PREFIX "zone-summary", false,
    487. 

  487.          ZONE_SUMMARY_TEXT, ZONE_SUMMARY_LONGTEXT, false)
    488. 

  488. 

  489. /*
    490. 

  490.  settings only for the buildin driver (if external driver app is used
    491. 

  491.  these parameters are ignored.)
    492. 

    493. 

  493.  definition of parameters for the buildin filter ...
    494. 

  494. */
    495. 

  495. set_section( N_("Settings for the built-in Live Video Processor only" ), 0 )
    496. 

  496. 

  497. add_integer_with_range(CFG_PREFIX "edgeweightning",   3, 1, 30, NULL,
    498. 

  498.                        EDGE_TEXT, EDGE_LONGTEXT, false)
    499. 

  499. 

  500. add_integer_with_range(CFG_PREFIX "brightness",   100, 50, 300, NULL,
    501. 

  501.                        BRIGHTNESS_TEXT, BRIGHTNESS_LONGTEXT, false)
    502. 

  502. 

  503. add_integer_with_range(CFG_PREFIX "darknesslimit",   3, 0, 10, NULL,
    504. 

  504.                        DARKNESS_TEXT, DARKNESS_LONGTEXT, false)
    505. 

  505. 

  506. add_integer_with_range(CFG_PREFIX "huewinsize",   3, 0, 5, NULL,
    507. 

  507.                        HUEWINSIZE_TEXT, HUEWINSIZE_LONGTEXT, false)
    508. 

  508. 

  509. add_integer_with_range(CFG_PREFIX "satwinsize",   3, 0, 5, NULL,
    510. 

  510.                        SATWINSIZE_TEXT, SATWINSIZE_LONGTEXT, false)
    511. 

  511. 

  512. add_integer(CFG_PREFIX "filtermode", (int)afmCombined,
    513. 

  513.             FILTERMODE_TEXT, FILTERMODE_LONGTEXT, false )
    514. 

  514. 

  515. change_integer_list(pi_filtermode_values, ppsz_filtermode_descriptions )
    516. 

  516. 

  517. add_integer_with_range(CFG_PREFIX "meanlength",    300, 300, 5000, NULL,
    518. 

  518.                        MEANLENGTH_TEXT, MEANLENGTH_LONGTEXT, false)
    519. 

  519. 

  520. add_integer_with_range(CFG_PREFIX "meanthreshold",  40, 1, 100, NULL,
    521. 

  521.                        MEANTHRESHOLD_TEXT, MEANTHRESHOLD_LONGTEXT, false)
    522. 

  522. 

  523. add_integer_with_range(CFG_PREFIX "percentnew", 50, 1, 100, NULL,
    524. 

  524.                       MEANPERCENTNEW_TEXT, MEANPERCENTNEW_LONGTEXT, false)
    525. 

  525. 

  526. add_integer_with_range(CFG_PREFIX "framedelay", 18, 0, 200, NULL,
    527. 

  527.                        FRAMEDELAY_TEXT, FRAMEDELAY_LONGTEXT, false)
    528. 

  528. 

  529. /*
    530. 

  530.   output channel reordering
    531. 

  531. */
    532. 

  532. set_section( N_("Change channel assignment (fixes wrong wiring)" ), 0 )
    533. 

  533. add_integer( CFG_PREFIX "channel_0", 4,
    534. 

  534.             CHANNEL_0_ASSIGN_TEXT, CHANNELASSIGN_LONGTEXT, false )
    535. 

  535. change_integer_list( pi_zone_assignment_values,
    536. 

  536.                      ppsz_zone_assignment_descriptions )
    537. 

  537. 

  538. add_integer( CFG_PREFIX "channel_1", 3,
    539. 

  539.             CHANNEL_1_ASSIGN_TEXT, CHANNELASSIGN_LONGTEXT, false )
    540. 

  540. change_integer_list( pi_zone_assignment_values,
    541. 

  541.                      ppsz_zone_assignment_descriptions )
    542. 

  542. 

  543. add_integer( CFG_PREFIX "channel_2", 1,
    544. 

  544.             CHANNEL_2_ASSIGN_TEXT, CHANNELASSIGN_LONGTEXT, false )
    545. 

  545. change_integer_list( pi_zone_assignment_values,
    546. 

  546.                      ppsz_zone_assignment_descriptions )
    547. 

  547. 

  548. add_integer( CFG_PREFIX "channel_3", 0,
    549. 

  549.             CHANNEL_3_ASSIGN_TEXT, CHANNELASSIGN_LONGTEXT, false )
    550. 

  550. change_integer_list( pi_zone_assignment_values,
    551. 

  551.                      ppsz_zone_assignment_descriptions )
    552. 

  552. 

  553. add_integer( CFG_PREFIX "channel_4", 2,
    554. 

  554.             CHANNEL_4_ASSIGN_TEXT, CHANNELASSIGN_LONGTEXT, false )
    555. 

  555. change_integer_list( pi_zone_assignment_values,
    556. 

  556.                      ppsz_zone_assignment_descriptions )
    557. 

  557. 

  558. add_string(CFG_PREFIX "channels", "",
    559. 

  559.            CHANNELS_ASSIGN_TEXT, CHANNELS_ASSIGN_LONGTEXT, false )
    560. 

  560. 

  561. 

  562. /*
    563. 

  563.   LED color white calibration
    564. 

  564. */
    565. 

  565. set_section( N_("Adjust the white light to your LED stripes" ), 0 )
    566. 

  566. add_bool(CFG_PREFIX "whiteadj", true,
    567. 

  567.          USEWHITEADJ_TEXT, USEWHITEADJ_LONGTEXT, false)
    568. 

  568. add_integer_with_range(CFG_PREFIX "white-red",   255, 0, 255, NULL,
    569. 

  569.                        WHITE_RED_TEXT,   WHITE_RED_LONGTEXT,   false)
    570. 

  570. 

  571. add_integer_with_range(CFG_PREFIX "white-green", 255, 0, 255, NULL,
    572. 

  572.                        WHITE_GREEN_TEXT, WHITE_GREEN_LONGTEXT, false)
    573. 

  573. 

  574. add_integer_with_range(CFG_PREFIX "white-blue",  255, 0, 255, NULL,
    575. 

  575.                        WHITE_BLUE_TEXT,  WHITE_BLUE_LONGTEXT,  false)
    576. 

  576. /* end of definition of parameter for the buildin filter ... part 1 */
    577. 

  577. 

  578. 

  579. /*
    580. 

  580. only for buildin (external has own definition) per default the calucation
    581. 

  581. used linear gradients for assigning a priority to the pixel - depending
    582. 

  582. how near they are to the border ...for changing this you can create 64x48
    583. 

  583. Pixel BMP files - which contain your own grayscale... (you can produce funny
    584. 

  584. effects with this...) the images MUST not compressed, should have 24-bit per
    585. 

  585. pixel, or a simple 256 color grayscale palette
    586. 

  586. */
    587. 

  587. set_section( N_("Change gradients" ), 0 )
    588. 

  588. add_loadfile(CFG_PREFIX "gradient_zone_0", NULL,
    589. 

  589.              ZONE_0_GRADIENT_TEXT, ZONE_X_GRADIENT_LONG_TEXT, true )
    590. 

  590. add_loadfile(CFG_PREFIX "gradient_zone_1", NULL,
    591. 

  591.              ZONE_1_GRADIENT_TEXT, ZONE_X_GRADIENT_LONG_TEXT, true )
    592. 

  592. add_loadfile(CFG_PREFIX "gradient_zone_2", NULL,
    593. 

  593.              ZONE_2_GRADIENT_TEXT, ZONE_X_GRADIENT_LONG_TEXT, true )
    594. 

  594. add_loadfile(CFG_PREFIX "gradient_zone_3", NULL,
    595. 

  595.              ZONE_3_GRADIENT_TEXT, ZONE_X_GRADIENT_LONG_TEXT, true )
    596. 

  596. add_loadfile(CFG_PREFIX "gradient_zone_4", NULL,
    597. 

  597.              ZONE_4_GRADIENT_TEXT, ZONE_X_GRADIENT_LONG_TEXT, true )
    598. 

  598. add_directory(CFG_PREFIX "gradient_path", NULL,
    599. 

  599.            GRADIENT_PATH_TEXT, GRADIENT_PATH_LONGTEXT, false )
    600. 

  600. 

  601. #if defined(__ATMO_DEBUG__)
    602. 

  602. add_bool(CFG_PREFIX "saveframes", false,
    603. 

  603.          SAVEFRAMES_TEXT, SAVEFRAMES_LONGTEXT, false)
    604. 

  604. add_string(CFG_PREFIX "framepath", "",
    605. 

  605.            FRAMEPATH_TEXT, FRAMEPATH_LONGTEXT, false )
    606. 

  606. #endif
    607. 

  607. /*
    608. 

  608.    may be later if computers gets more power ;-) than now we increase
    609. 

  609.    the samplesize from which we do the stats for output color calculation
    610. 

  610. */
    611. 

  611. add_integer_with_range(CFG_PREFIX "width",  64, 64, 512, NULL,
    612. 

  612.                        WIDTH_TEXT,  WIDTH_LONGTEXT, true)
    613. 

  613. add_integer_with_range(CFG_PREFIX "height", 48, 48, 384, NULL,
    614. 

  614.                        HEIGHT_TEXT,  HEIGHT_LONGTEXT, true)
    615. 

  615. add_bool(CFG_PREFIX "showdots", false,
    616. 

  616.                    SHOW_DOTS_TEXT, SHOW_DOTS_LONGTEXT, false)
    617. 

  617. add_shortcut( "atmo" )
    618. 

  618. set_callbacks( CreateFilter, DestroyFilter  )
    619. 

  619. vlc_module_end ()
    620. 

  620. 

  621. 

  622. static const char *const ppsz_filter_options[] = {
    623. 

  623.         "device",
    624. 

  624. 

  625.         "serialdev",
    626. 

  626. 

  627. 

  628.         "edgeweightning",
    629. 

  629.         "brightness",
    630. 

  630.         "darknesslimit",
    631. 

  631.         "huewinsize",
    632. 

  632.         "satwinsize",
    633. 

  633. 

  634.         "filtermode",
    635. 

  635. 

  636.         "meanlength",
    637. 

  637.         "meanthreshold",
    638. 

  638.         "percentnew",
    639. 

  639.         "framedelay",
    640. 

  640. 

  641.         "zones-top",
    642. 

  642.         "zones-bottom",
    643. 

  643.         "zones-lr",
    644. 

  644.         "zone-summary",
    645. 

  645. 

  646.         "channel_0",
    647. 

  647.         "channel_1",
    648. 

  648.         "channel_2",
    649. 

  649.         "channel_3",
    650. 

  650.         "channel_4",
    651. 

  651.         "channels",
    652. 

  652. 

  653.         "whiteadj",
    654. 

  654.         "white-red",
    655. 

  655.         "white-green",
    656. 

  656.         "white-blue",
    657. 

  657. 

  658.         "usepausecolor",
    659. 

  659.         "pcolor-red",
    660. 

  660.         "pcolor-green",
    661. 

  661.         "pcolor-blue",
    662. 

  662.         "fadesteps",
    663. 

  663. 

  664.         "ecolor-red",
    665. 

  665.         "ecolor-green",
    666. 

  666.         "ecolor-blue",
    667. 

  667.         "efadesteps",
    668. 

  668. 

  669.         "dmx-channels",
    670. 

  670.         "dmx-chbase",
    671. 

  671.         "momo-channels",
    672. 

  672.         "fnordlicht-amount",
    673. 

  673. 

  674. #if defined(WIN32 )
    675. 

  675.         "atmowinexe",
    676. 

  676. #endif
    677. 

  677. #if defined(__ATMO_DEBUG__)
    678. 

  678.         "saveframes" ,
    679. 

  679.         "framepath",
    680. 

  680. #endif
    681. 

  681.         "width",
    682. 

  682.         "height",
    683. 

  683.         "showdots",
    684. 

  684.         "gradient_zone_0",
    685. 

  685.         "gradient_zone_1",
    686. 

  686.         "gradient_zone_2",
    687. 

  687.         "gradient_zone_3",
    688. 

  688.         "gradient_zone_4",
    689. 

  689.         "gradient_path",
    690. 

  690.         NULL
    691. 

  691. };
    692. 

  692. 

  693. 

  694. /*****************************************************************************
    695. 

  695. * fadethread_t: Color Fading Thread
    696. 

  696. *****************************************************************************
    697. 

  697. * changes slowly the color of the output if videostream gets paused...
    698. 

  698. *****************************************************************************
    699. 

  699. */
    700. 

  700. typedef struct
    701. 

  701. {
    702. 

  702.     VLC_COMMON_MEMBERS
    703. 

  703.         filter_t *p_filter;
    704. 

  704.     /* tell the thread which color should be the target of fading */
    705. 

  705.     uint8_t ui_red;
    706. 

  706.     uint8_t ui_green;
    707. 

  707.     uint8_t ui_blue;
    708. 

  708.     /* how many steps should happen until this */
    709. 

  709.     int i_steps;
    710. 

  710. 

  711. } fadethread_t;
    712. 

  712. 

  713. static void *FadeToColorThread(vlc_object_t *);
    714. 

  714. 

  715. 

  716. /*****************************************************************************
    717. 

  717. * filter_sys_t: AtmoLight filter method descriptor
    718. 

  718. *****************************************************************************
    719. 

  719. * It describes the AtmoLight specific properties of an video filter.
    720. 

  720. *****************************************************************************/
    721. 

  721. struct filter_sys_t
    722. 

  722. {
    723. 

  723.     /*
    724. 

  724.     special for the access of the p_fadethread member all other members
    725. 

  725.     need no special protection so far!
    726. 

  726.     */
    727. 

  727.     vlc_mutex_t filter_lock;
    728. 

  728. 

  729.     bool b_enabled;
    730. 

  730.     int32_t i_AtmoOldEffect;
    731. 

  731.     bool b_pause_live;
    732. 

  732.     bool b_show_dots;
    733. 

  733.     int32_t i_device_type;
    734. 

  734. 

  735.     int32_t i_atmo_width;
    736. 

  736.     int32_t i_atmo_height;
    737. 

  737.     /* used to disable fadeout if less than 50 frames are processed
    738. 

  738.        used to avoid long time waiting when switch quickly between
    739. 

  739.        deinterlaceing modes, where the output filter chains is rebuild
    740. 

  740.        on each switch
    741. 

  741.     */
    742. 

  742.     int32_t i_frames_processed;
    743. 

  743. 

  744. #if defined(__ATMO_DEBUG__)
    745. 

  745.     bool  b_saveframes;
    746. 

  746.     uint32_t ui_frame_counter;
    747. 

  747.     char sz_framepath[MAX_PATH];
    748. 

  748. #endif
    749. 

  749. 

  750.     /* light color durring movie pause ... */
    751. 

  751.     bool  b_usepausecolor;
    752. 

  752.     uint8_t ui_pausecolor_red;
    753. 

  753.     uint8_t ui_pausecolor_green;
    754. 

  754.     uint8_t ui_pausecolor_blue;
    755. 

  755.     int i_fadesteps;
    756. 

  756. 

  757.     /* light color on movie finish ... */
    758. 

  758.     uint8_t ui_endcolor_red;
    759. 

  759.     uint8_t ui_endcolor_green;
    760. 

  760.     uint8_t ui_endcolor_blue;
    761. 

  761.     int i_endfadesteps;
    762. 

  762. 

  763.     fadethread_t *p_fadethread;
    764. 

  764. 

  765.     /* Variables for buildin driver only... */
    766. 

  766. 

  767.     /* is only present and initialized if the internal driver is used*/
    768. 

  768.     CAtmoConfig *p_atmo_config;
    769. 

  769.     /* storage for temporal settings "volatile" */
    770. 

  770.     CAtmoDynData *p_atmo_dyndata;
    771. 

  771.     /* initialized for buildin driver with AtmoCreateTransferBuffers */
    772. 

  772.     BITMAPINFOHEADER mini_image_format;
    773. 

  773.     /* is only use buildin driver! */
    774. 

  774.     uint8_t *p_atmo_transfer_buffer;
    775. 

  775.     /* end buildin driver */
    776. 

  776. 

  777.     /*
    778. 

  778.     contains the real output size of the video calculated on
    779. 

  779.     change event of the variable "crop" from vout
    780. 

  780.     */
    781. 

  781.     int32_t i_crop_x_offset;
    782. 

  782.     int32_t i_crop_y_offset;
    783. 

  783.     int32_t i_crop_width;
    784. 

  784.     int32_t i_crop_height;
    785. 

  785. 

  786.     void (*pf_extract_mini_image) (filter_sys_t *p_sys,
    787. 

  787.         picture_t *p_inpic,
    788. 

  788.         uint8_t *p_transfer_dest);
    789. 

  789. 

  790. #if defined( WIN32 )
    791. 

  791.     /* External Library as wrapper arround COM Stuff */
    792. 

  792.     HINSTANCE h_AtmoCtrl;
    793. 

  793.     int32_t (*pf_ctrl_atmo_initialize) (void);
    794. 

  794.     void (*pf_ctrl_atmo_finalize) (int32_t what);
    795. 

  795.     int32_t (*pf_ctrl_atmo_switch_effect) (int32_t);
    796. 

  796.     int32_t (*pf_ctrl_atmo_set_live_source) (int32_t);
    797. 

  797.     void (*pf_ctrl_atmo_create_transfer_buffers) (int32_t, int32_t,
    798. 

  798.                                                   int32_t , int32_t);
    799. 

  799.     uint8_t* (*pf_ctrl_atmo_lock_transfer_buffer) (void);
    800. 

  800.     void (*pf_ctrl_atmo_send_pixel_data) (void);
    801. 

  801.     void (*pf_ctrl_atmo_get_image_size)(int32_t *,int32_t *);
    802. 

  802. #endif
    803. 

  803. };
    804. 

  804. 

  805. /*
    806. 

  806. initialize previously configured Atmo Light environment
    807. 

  807. - if internal is enabled try to access the device on the serial port
    808. 

  808. - if not internal is enabled and we are on win32 try to initialize
    809. 

  809. the previously loaded DLL ...
    810. 

    811. 

  811. Return Values may be: -1 (failed for some reason - filter will be disabled)
    812. 

  812. 1 Ok. lets rock
    813. 

  813. */
    814. 

  814. static int32_t AtmoInitialize(filter_t *p_filter, bool b_for_thread)
    815. 

  815. {
    816. 

  816.     filter_sys_t *p_sys = p_filter->p_sys;
    817. 

  817.     if(p_sys->p_atmo_config)
    818. 

  818.     {
    819. 

  819.         if(b_for_thread == false)
    820. 

  820.         {
    821. 

  821.             /* open com port */
    822. 

  822.             /* setup Output Threads ... */
    823. 

  823.             msg_Dbg( p_filter, "open atmo device...");
    824. 

  824.             if(CAtmoTools::RecreateConnection(p_sys->p_atmo_dyndata)
    825. 

  825.                == ATMO_TRUE)
    826. 

  826.             {
    827. 

  827.                 return 1;
    828. 

  828.             } else {
    829. 

  829.                 msg_Err( p_filter,"failed to open atmo device, "\
    830. 

  830.                                   "some other software/driver may use it?");
    831. 

  831.             }
    832. 

  832.         }
    833. 

  833. #if defined(WIN32)
    834. 

  834.     } else if(p_sys->pf_ctrl_atmo_initialize)
    835. 

  835.     {
    836. 

  836.         /* on win32 with active ctrl dll */
    837. 

  837.         return p_sys->pf_ctrl_atmo_initialize();
    838. 

  838. #endif
    839. 

  839.     }
    840. 

  840.     return -1;
    841. 

  841. }
    842. 

  842. 

  843. /*
    844. 

  844. prepare the shutdown of the effect threads,
    845. 

  845. for build in filter - close the serialport after finishing the threads...
    846. 

  846. cleanup possible loaded DLL...
    847. 

  847. */
    848. 

  848. static void AtmoFinalize(filter_t *p_filter, int32_t what)
    849. 

  849. {
    850. 

  850.     filter_sys_t *p_sys = p_filter->p_sys;
    851. 

  851.     if(p_sys->p_atmo_config)
    852. 

  852.     {
    853. 

  853.         if(what == 1)
    854. 

  854.         {
    855. 

  855.             CAtmoDynData *p_atmo_dyndata = p_sys->p_atmo_dyndata;
    856. 

  856.             if(p_atmo_dyndata)
    857. 

  857.             {
    858. 

  858.                 p_atmo_dyndata->LockCriticalSection();
    859. 

  859. 

  860.                 CAtmoInput *p_input = p_atmo_dyndata->getLiveInput();
    861. 

  861.                 p_atmo_dyndata->setLiveInput( NULL );
    862. 

  862.                 if(p_input != NULL)
    863. 

  863.                 {
    864. 

  864.                     p_input->Terminate();
    865. 

  865.                     delete p_input;
    866. 

  866.                     msg_Dbg( p_filter, "input thread died peacefully");
    867. 

  867.                 }
    868. 

  868. 

  869.                 CThread *p_effect_thread = p_atmo_dyndata->getEffectThread();
    870. 

  870.                 p_atmo_dyndata->setEffectThread(NULL);
    871. 

  871.                 if(p_effect_thread != NULL)
    872. 

  872.                 {
    873. 

  873.                     /*
    874. 

  874.                     forced the thread to die...
    875. 

  875.                     and wait for termination of the thread
    876. 

  876.                     */
    877. 

  877.                     p_effect_thread->Terminate();
    878. 

  878.                     delete p_effect_thread;
    879. 

  879.                     msg_Dbg( p_filter, "effect thread died peacefully");
    880. 

  880.                 }
    881. 

  881. 

  882.                 CAtmoPacketQueue *p_queue =
    883. 

  883.                                            p_atmo_dyndata->getLivePacketQueue();
    884. 

  884.                 p_atmo_dyndata->setLivePacketQueue( NULL );
    885. 

  885.                 if(p_queue != NULL)
    886. 

  886.                 {
    887. 

  887.                    delete p_queue;
    888. 

  888.                    msg_Dbg( p_filter, "packetqueue removed");
    889. 

  889.                 }
    890. 

  890. 

  891.                 /*
    892. 

  892.                 close serial port if it is open (all OS specific is inside
    893. 

  893.                 CAtmoSerialConnection implemented / defined)
    894. 

  894.                 */
    895. 

  895.                 CAtmoConnection *p_atmo_connection =
    896. 

  896.                                  p_atmo_dyndata->getAtmoConnection();
    897. 

  897.                 p_atmo_dyndata->setAtmoConnection(NULL);
    898. 

  898.                 if(p_atmo_connection) {
    899. 

  899.                     p_atmo_connection->CloseConnection();
    900. 

  900.                     delete p_atmo_connection;
    901. 

  901.                 }
    902. 

  902.                 p_atmo_dyndata->UnLockCriticalSection();
    903. 

  903.             }
    904. 

  904.         }
    905. 

  905. #if defined(WIN32)
    906. 

  906.     } else if(p_sys->pf_ctrl_atmo_finalize)
    907. 

  907.     {
    908. 

  908.         /* on win32 with active ctrl dll */
    909. 

  909.         p_sys->pf_ctrl_atmo_finalize(what);
    910. 

  910. #endif
    911. 

  911.     }
    912. 

  912. }
    913. 

  913. 

  914. /*
    915. 

  915.   switch the current light effect to LiveView
    916. 

  916. */
    917. 

  917. static int32_t AtmoSwitchEffect(filter_t *p_filter, int32_t newMode)
    918. 

  918. {
    919. 

  919.     filter_sys_t *p_sys = p_filter->p_sys;
    920. 

  920. 

  921.     msg_Dbg( p_filter, "AtmoSwitchEffect %d", newMode );
    922. 

  922. 

  923.     if(p_sys->p_atmo_config)
    924. 

  924.     {
    925. 

  925.        return CAtmoTools::SwitchEffect(p_sys->p_atmo_dyndata, emLivePicture);
    926. 

  926. #if defined(WIN32)
    927. 

  927.     } else if(p_sys->pf_ctrl_atmo_switch_effect)
    928. 

  928.     {
    929. 

  929.         /* on win32 with active ctrl dll */
    930. 

  930.         return p_sys->pf_ctrl_atmo_switch_effect( newMode );
    931. 

  931. #endif
    932. 

  932.     }
    933. 

  933.     return emDisabled;
    934. 

  934. }
    935. 

  935. 

  936. /*
    937. 

  937. set the current live picture source, does only something on win32,
    938. 

  938. with the external libraries - if the buildin effects are used nothing
    939. 

  939. happens...
    940. 

  940. */
    941. 

  941. static int32_t AtmoSetLiveSource(filter_t *p_filter, int32_t newSource)
    942. 

  942. {
    943. 

  943.     filter_sys_t *p_sys = p_filter->p_sys;
    944. 

  944. 

  945.     msg_Dbg( p_filter, "AtmoSetLiveSource %d", newSource );
    946. 

  946. 

  947.     if(p_sys->p_atmo_config)
    948. 

  948.     {
    949. 

  949.         /*
    950. 

  950.         buildin driver
    951. 

    952. 

  952.         doesnt know different sources so this
    953. 

  953.         function call would just do nothing special
    954. 

  954.         in this case
    955. 

  955.         */
    956. 

  956. #if defined(WIN32)
    957. 

  957.     } else if(p_sys->pf_ctrl_atmo_set_live_source)
    958. 

  958.     {
    959. 

  959.         /* on win32 with active ctrl dll */
    960. 

  960.         return p_sys->pf_ctrl_atmo_set_live_source(newSource);
    961. 

  961. #endif
    962. 

  962.     }
    963. 

  963.     return lvsGDI;
    964. 

  964. }
    965. 

  965. 

  966. /*
    967. 

  967. setup the pixel transferbuffers which is used to transfer pixeldata from
    968. 

  968. the filter to the effect thread, and possible accross the process
    969. 

  969. boundaries on win32, with the external DLL
    970. 

  970. */
    971. 

  971. static void AtmoCreateTransferBuffers(filter_t *p_filter,
    972. 

  972.                                       int32_t FourCC,
    973. 

  973.                                       int32_t bytePerPixel,
    974. 

  974.                                       int32_t width,
    975. 

  975.                                       int32_t height)
    976. 

  976. {
    977. 

  977.     filter_sys_t *p_sys = p_filter->p_sys;
    978. 

  978.     if(p_sys->p_atmo_config)
    979. 

  979.     {
    980. 

  980.         /*
    981. 

  981.         we need a buffer where the image is stored (only for transfer
    982. 

  982.         to the processing thread)
    983. 

  983.         */
    984. 

  984.         free( p_sys->p_atmo_transfer_buffer );
    985. 

  985. 

  986.         p_sys->p_atmo_transfer_buffer = (uint8_t *)malloc(bytePerPixel *
    987. 

  987.                                                           width *  height);
    988. 

  988. 

  989.         memset(&p_sys->mini_image_format,0,sizeof(BITMAPINFOHEADER));
    990. 

  990. 

  991.         p_sys->mini_image_format.biSize = sizeof(BITMAPINFOHEADER);
    992. 

  992.         p_sys->mini_image_format.biWidth = width;
    993. 

  993.         p_sys->mini_image_format.biHeight = height;
    994. 

  994.         p_sys->mini_image_format.biBitCount = bytePerPixel*8;
    995. 

  995.         p_sys->mini_image_format.biCompression = FourCC;
    996. 

  996. 

  997. #if defined(WIN32)
    998. 

  998.     } else if(p_sys->pf_ctrl_atmo_create_transfer_buffers)
    999. 

  999.     {
    1000. 

  1000.         /* on win32 with active ctrl dll */
    1001. 

  1001.         p_sys->pf_ctrl_atmo_create_transfer_buffers(FourCC,
    1002. 

  1002.             bytePerPixel,
    1003. 

  1003.             width,
    1004. 

  1004.             height);
    1005. 

  1005. #endif
    1006. 

  1006.     }
    1007. 

  1007. }
    1008. 

  1008. 

  1009. /*
    1010. 

  1010. acquire the transfer buffer pointer the buildin version only
    1011. 

  1011. returns the pointer to the allocated buffer ... the
    1012. 

  1012. external version on win32 has to do some COM stuff to lock the
    1013. 

  1013. Variant Byte array which is behind the buffer
    1014. 

  1014. */
    1015. 

  1015. static uint8_t* AtmoLockTransferBuffer(filter_t *p_filter)
    1016. 

  1016. {
    1017. 

  1017.     filter_sys_t *p_sys = p_filter->p_sys;
    1018. 

  1018.     if(p_sys->p_atmo_config)
    1019. 

  1019.     {
    1020. 

  1020.         return p_sys->p_atmo_transfer_buffer;
    1021. 

  1021. #if defined(WIN32)
    1022. 

  1022.     } else if(p_sys->pf_ctrl_atmo_lock_transfer_buffer)
    1023. 

  1023.     {
    1024. 

  1024.         /* on win32 with active ctrl dll */
    1025. 

  1025.         return p_sys->pf_ctrl_atmo_lock_transfer_buffer();
    1026. 

  1026. #endif
    1027. 

  1027.     }
    1028. 

  1028.     return NULL;
    1029. 

  1029. }
    1030. 

  1030. 

  1031. /*
    1032. 

  1032. send the content of current pixel buffer got with AtmoLockTransferBuffer
    1033. 

  1033. to the processing threads
    1034. 

  1034. - build in version - will forward the data to AtmoExternalCaptureInput Thread
    1035. 

  1035. - win32 external - will do the same, but across the process boundaries via
    1036. 

  1036. COM to the AtmoWinA.exe Process
    1037. 

  1037. */
    1038. 

  1038. static void AtmoSendPixelData(filter_t *p_filter)
    1039. 

  1039. {
    1040. 

  1040.     filter_sys_t *p_sys = p_filter->p_sys;
    1041. 

  1041.     if(p_sys->p_atmo_config && p_sys->p_atmo_transfer_buffer)
    1042. 

  1042.     {
    1043. 

  1043.         CAtmoDynData *p_atmo_dyndata = p_sys->p_atmo_dyndata;
    1044. 

  1044.         if(p_atmo_dyndata &&
    1045. 

  1045.           (p_atmo_dyndata->getLivePictureSource() == lpsExtern))
    1046. 

  1046.         {
    1047. 

  1047.             /*
    1048. 

  1048.             the cast will go Ok because we are inside videolan there is only
    1049. 

  1049.             this kind of effect thread implemented!
    1050. 

  1050.             */
    1051. 

  1051.             CAtmoExternalCaptureInput *p_atmo_external_capture_input_thread =
    1052. 

  1052.                 (CAtmoExternalCaptureInput *)p_atmo_dyndata->getLiveInput();
    1053. 

  1053. 

  1054.             if(p_atmo_external_capture_input_thread)
    1055. 

  1055.             {
    1056. 

  1056.                 /*
    1057. 

  1057.                 the same as above inside videolan only this single kind of
    1058. 

  1058.                 input exists so we can cast without further tests!
    1059. 

    1060. 

  1060.                 this call will do a 1:1 copy of this buffer, and wakeup
    1061. 

  1061.                 the thread from normal sleeping
    1062. 

  1062.                 */
    1063. 

  1063.                 p_atmo_external_capture_input_thread->
    1064. 

  1064.                      DeliverNewSourceDataPaket(&p_sys->mini_image_format,
    1065. 

  1065.                                                p_sys->p_atmo_transfer_buffer);
    1066. 

  1066.             }
    1067. 

  1067.         }
    1068. 

  1068. #if defined(WIN32)
    1069. 

  1069.     } else if(p_sys->pf_ctrl_atmo_send_pixel_data)
    1070. 

  1070.     {
    1071. 

  1071.         /* on win32 with active ctrl dll */
    1072. 

  1072.         p_sys->pf_ctrl_atmo_send_pixel_data();
    1073. 

  1073. #endif
    1074. 

  1074.     } else
    1075. 

  1075.     {
    1076. 

  1076.        msg_Warn( p_filter, "AtmoSendPixelData no method");
    1077. 

  1077.     }
    1078. 

  1078. }
    1079. 

  1079. 

  1080. /*
    1081. 

  1081.     Shutdown AtmoLight finally - is call from DestroyFilter
    1082. 

  1082.     does the cleanup restores the effectmode on the external Software
    1083. 

  1083.     (only win32) and possible setup the final light ...
    1084. 

  1084. */
    1085. 

  1085. static void Atmo_Shutdown(filter_t *p_filter)
    1086. 

  1086. {
    1087. 

  1087.     filter_sys_t *p_sys = p_filter->p_sys;
    1088. 

  1088. 

  1089.     if(p_sys->b_enabled == true)
    1090. 

  1090.     {
    1091. 

  1091.         msg_Dbg( p_filter, "shut down atmo!");
    1092. 

  1092.         /*
    1093. 

  1093.         if there is a still running show pause color thread kill him!
    1094. 

  1094.         */
    1095. 

  1095.         CheckAndStopFadeThread(p_filter);
    1096. 

  1096. 

  1097.         // perpare spawn fadeing thread
    1098. 

  1098.         vlc_mutex_lock( &p_sys->filter_lock );
    1099. 

  1099. 

  1100.         /*
    1101. 

  1101.         fade to end color (in case of external AtmoWin Software
    1102. 

  1102.         assume that the static color will equal to this
    1103. 

  1103.         one to get a soft change and no flash!
    1104. 

  1104.         */
    1105. 

  1105.         p_sys->b_pause_live = true;
    1106. 

  1106. 

  1107. 

  1108.         p_sys->p_fadethread = (fadethread_t *)vlc_object_create( p_filter,
    1109. 

  1109.                                                     sizeof(fadethread_t) );
    1110. 

  1110. 

  1111.         p_sys->p_fadethread->p_filter = p_filter;
    1112. 

  1112.         p_sys->p_fadethread->ui_red   = p_sys->ui_endcolor_red;
    1113. 

  1113.         p_sys->p_fadethread->ui_green = p_sys->ui_endcolor_green;
    1114. 

  1114.         p_sys->p_fadethread->ui_blue  = p_sys->ui_endcolor_blue;
    1115. 

  1115.         if(p_sys->i_frames_processed < 50)
    1116. 

  1116.           p_sys->p_fadethread->i_steps  = 1;
    1117. 

  1117.         else
    1118. 

  1118.           p_sys->p_fadethread->i_steps  = p_sys->i_endfadesteps;
    1119. 

  1119. 

  1120.         if( vlc_thread_create( p_sys->p_fadethread,
    1121. 

  1121.             "AtmoLight fadeing",
    1122. 

  1122.             FadeToColorThread,
    1123. 

  1123.             VLC_THREAD_PRIORITY_LOW ) )
    1124. 

  1124.         {
    1125. 

  1125.             msg_Err( p_filter, "cannot create FadeToColorThread" );
    1126. 

  1126.             vlc_object_release( p_sys->p_fadethread );
    1127. 

  1127.             p_sys->p_fadethread = NULL;
    1128. 

  1128.             vlc_mutex_unlock( &p_sys->filter_lock );
    1129. 

  1129. 

  1130.         } else {
    1131. 

  1131. 

  1132.             vlc_mutex_unlock( &p_sys->filter_lock );
    1133. 

  1133. 

  1134.             /* wait for the thread... */
    1135. 

  1135.             vlc_thread_join(p_sys->p_fadethread);
    1136. 

  1136. 

  1137.             vlc_object_release(p_sys->p_fadethread);
    1138. 

  1138. 

  1139.             p_sys->p_fadethread = NULL;
    1140. 

  1140.         }
    1141. 

  1141. 

  1142.         /*
    1143. 

  1143.            the following happens only useing the
    1144. 

  1144.            external AtmoWin Device Software
    1145. 

  1145.         */
    1146. 

  1146.         if( !p_sys->p_atmo_config )
    1147. 

  1147.         {
    1148. 

  1148.            if(p_sys->i_AtmoOldEffect != emLivePicture)
    1149. 

  1149.               AtmoSwitchEffect( p_filter, p_sys->i_AtmoOldEffect);
    1150. 

  1150.            else
    1151. 

  1151.               AtmoSetLiveSource( p_filter, lvsGDI );
    1152. 

  1152.         }
    1153. 

  1153. 

  1154.         /* close device connection etc. */
    1155. 

  1155.         AtmoFinalize(p_filter, 1);
    1156. 

  1156. 

  1157.         /* disable filter method .. */
    1158. 

  1158.         p_sys->b_enabled = false;
    1159. 

  1159.     }
    1160. 

  1160. }
    1161. 

  1161. 

  1162. /*
    1163. 

  1163. depending on mode setup imagesize to 64x48(classic), or defined
    1164. 

  1164. resolution of external atmowin.exe on windows
    1165. 

  1165. */
    1166. 

  1166. static void Atmo_SetupImageSize(filter_t *p_filter)
    1167. 

  1167. {
    1168. 

  1168.     filter_sys_t *p_sys = p_filter->p_sys;
    1169. 

  1169.     /*
    1170. 

  1170.        size of extracted image by default 64x48 (other imagesizes are
    1171. 

  1171.        currently ignored by AtmoWin)
    1172. 

  1172.     */
    1173. 

  1173.     p_sys->i_atmo_width  = var_CreateGetIntegerCommand( p_filter,
    1174. 

  1174.         CFG_PREFIX "width");
    1175. 

  1175.     p_sys->i_atmo_height = var_CreateGetIntegerCommand( p_filter,
    1176. 

  1176.         CFG_PREFIX "height");
    1177. 

  1177. 

  1178.     if(p_sys->p_atmo_config)
    1179. 

  1179.     {
    1180. 

  1180. #if defined(WIN32)
    1181. 

  1181.     } else if(p_sys->pf_ctrl_atmo_get_image_size)
    1182. 

  1182.     {
    1183. 

  1183.         /* on win32 with active ctrl dll */
    1184. 

  1184.         p_sys->pf_ctrl_atmo_get_image_size( &p_sys->i_atmo_width,
    1185. 

  1185.                                             &p_sys->i_atmo_height );
    1186. 

  1186. #endif
    1187. 

  1187.     }
    1188. 

  1188. 

  1189.     msg_Dbg(p_filter,"sample image size %d * %d pixels", p_sys->i_atmo_width,
    1190. 

  1190.         p_sys->i_atmo_height);
    1191. 

  1191. }
    1192. 

  1192. 

  1193. /*
    1194. 

  1194. initialize the zone and channel mapping for the buildin atmolight adapter
    1195. 

  1195. */
    1196. 

  1196. static void Atmo_SetupBuildZones(filter_t *p_filter)
    1197. 

  1197. {
    1198. 

  1198.     filter_sys_t *p_sys = p_filter->p_sys;
    1199. 

  1199. 

  1200.     p_sys->p_atmo_dyndata->LockCriticalSection();
    1201. 

  1201. 

  1202.     CAtmoConfig *p_atmo_config = p_sys->p_atmo_config;
    1203. 

  1203. 

  1204. 

  1205.     CAtmoChannelAssignment *p_channel_assignment =
    1206. 

  1206.                             p_atmo_config->getChannelAssignment(0);
    1207. 

  1207. 

  1208.     // channel 0 - zone 4
    1209. 

  1209.     p_channel_assignment->setZoneIndex( 0, var_CreateGetIntegerCommand(
    1210. 

  1210.                                         p_filter, CFG_PREFIX "channel_0")
    1211. 

  1211.                                         );
    1212. 

  1212. 

  1213.     // channel 1 - zone 3
    1214. 

  1214.     p_channel_assignment->setZoneIndex( 1, var_CreateGetIntegerCommand(
    1215. 

  1215.                                         p_filter, CFG_PREFIX "channel_1")
    1216. 

  1216.                                         );
    1217. 

  1217. 

  1218.     // channel 2 - zone 1
    1219. 

  1219.     p_channel_assignment->setZoneIndex( 2, var_CreateGetIntegerCommand(
    1220. 

  1220.                                         p_filter, CFG_PREFIX "channel_2")
    1221. 

  1221.                                         );
    1222. 

  1222. 

  1223.     // channel 3 - zone 0
    1224. 

  1224.     p_channel_assignment->setZoneIndex( 3, var_CreateGetIntegerCommand(
    1225. 

  1225.                                         p_filter, CFG_PREFIX "channel_3")
    1226. 

  1226.                                         );
    1227. 

  1227. 

  1228.     // channel 4 - zone 2
    1229. 

  1229.     p_channel_assignment->setZoneIndex( 4, var_CreateGetIntegerCommand(
    1230. 

  1230.                                         p_filter, CFG_PREFIX "channel_4")
    1231. 

  1231.                                         );
    1232. 

  1232. 

  1233.     char *psz_channels = var_CreateGetStringCommand(
    1234. 

  1234.               p_filter,
    1235. 

  1235.               CFG_PREFIX "channels"
    1236. 

  1236.             );
    1237. 

  1237.     if( !EMPTY_STR(psz_channels) )
    1238. 

  1238.     {
    1239. 

  1239.         msg_Dbg( p_filter, "deal with new zone mapping %s", psz_channels );
    1240. 

  1240.         int channel = 0;
    1241. 

  1241.         char *psz_temp = psz_channels;
    1242. 

  1242.         char *psz_start = psz_temp;
    1243. 

  1243.         while( *psz_temp )
    1244. 

  1244.         {
    1245. 

  1245.             if(*psz_temp == ',' || *psz_temp == ';')
    1246. 

  1246.             {
    1247. 

  1247.                 *psz_temp = 0;
    1248. 

  1248.                 if(*psz_start)
    1249. 

  1249.                 {
    1250. 

  1250.                     int zone = atoi( psz_start );
    1251. 

  1251.                     if( zone < -1 ||
    1252. 

  1252.                         zone >= p_channel_assignment->getSize()) {
    1253. 

  1253.                          msg_Warn( p_filter, "Zone %d out of range -1..%d",
    1254. 

  1254.                                 zone, p_channel_assignment->getSize()-1 );
    1255. 

  1255.                     } else {
    1256. 

  1256.                         p_channel_assignment->setZoneIndex( channel, zone );
    1257. 

  1257.                         channel++;
    1258. 

  1258.                     }
    1259. 

  1259.                 }
    1260. 

  1260.                 psz_start = psz_temp;
    1261. 

  1261.                 psz_start++;
    1262. 

  1262.             }
    1263. 

  1263. 

  1264.             psz_temp++;
    1265. 

  1265.         }
    1266. 

  1266. 

  1267.         /*
    1268. 

  1268.           process the rest of the string
    1269. 

  1269.         */
    1270. 

  1270.         if( *psz_start && !*psz_temp )
    1271. 

  1271.         {
    1272. 

  1272.             int zone = atoi( psz_start );
    1273. 

  1273.             if( zone < -1 ||
    1274. 

  1274.                 zone >= p_channel_assignment->getSize()) {
    1275. 

  1275.                 msg_Warn( p_filter, "Zone %d out of range -1..%d",
    1276. 

  1276.                             zone, p_channel_assignment->getSize()-1 );
    1277. 

  1277.             } else {
    1278. 

  1278.                 p_channel_assignment->setZoneIndex( channel, zone );
    1279. 

  1279.             }
    1280. 

  1280.         }
    1281. 

  1281.     }
    1282. 

  1282.     free( psz_channels );
    1283. 

  1283. 

  1284.     for(int i=0;i< p_channel_assignment->getSize() ;i++)
    1285. 

  1285.         msg_Info( p_filter, "map zone %d to hardware channel %d",
    1286. 

  1286.         p_channel_assignment->getZoneIndex( i ),
    1287. 

  1287.         i
    1288. 

  1288.         );
    1289. 

  1289.     p_sys->p_atmo_dyndata->getAtmoConnection()
    1290. 

  1290.          ->SetChannelAssignment( p_channel_assignment );
    1291. 

  1291. 

  1292. 

  1293. 

  1294. 

  1295. 

  1296.     /*
    1297. 

  1297.       calculate the default gradients for each zone!
    1298. 

  1298.       depending on the zone layout set before, this now
    1299. 

  1299.       supports also multiple gradients on each side
    1300. 

  1300.       (older versions could do this only with external
    1301. 

  1301.       gradient bitmaps)
    1302. 

  1302.     */
    1303. 

  1303.     p_sys->p_atmo_dyndata->CalculateDefaultZones();
    1304. 

  1304. 

  1305. 

  1306.     /*
    1307. 

  1307.       first try to load the old style defined gradient bitmaps
    1308. 

  1308.       this could only be done for the first five zones
    1309. 

  1309.       - should be deprecated -
    1310. 

  1310.     */
    1311. 

  1311.     CAtmoZoneDefinition *p_zone;
    1312. 

  1312.     char psz_gradient_var_name[30];
    1313. 

  1313.     char *psz_gradient_file;
    1314. 

  1314.     for(int i=0;i<CLASSIC_ATMO_NUM_ZONES;i++)
    1315. 

  1315.     {
    1316. 

  1316.         sprintf(psz_gradient_var_name, CFG_PREFIX "gradient_zone_%d", i);
    1317. 

  1317.         psz_gradient_file = var_CreateGetStringCommand(
    1318. 

  1318.             p_filter,
    1319. 

  1319.             psz_gradient_var_name
    1320. 

  1320.             );
    1321. 

  1321.         if( !EMPTY_STR(psz_gradient_file) )
    1322. 

  1322.         {
    1323. 

  1323.             msg_Dbg( p_filter, "loading gradientfile %s for "\
    1324. 

  1324.                                 "zone %d", psz_gradient_file, i);
    1325. 

  1325. 

  1326.             p_zone = p_atmo_config->getZoneDefinition(i);
    1327. 

  1327.             if( p_zone )
    1328. 

  1328.             {
    1329. 

  1329.                 int i_res = p_zone->LoadGradientFromBitmap(psz_gradient_file);
    1330. 

  1330. 

  1331.                 if(i_res != ATMO_LOAD_GRADIENT_OK)
    1332. 

  1332.                 {
    1333. 

  1333.                     msg_Err( p_filter,"failed to load gradient '%s' with "\
    1334. 

  1334.                                     "error %d",psz_gradient_file,i_res);
    1335. 

  1335.                 }
    1336. 

  1336.             }
    1337. 

  1337.         }
    1338. 

  1338.         free( psz_gradient_file );
    1339. 

  1339.     }
    1340. 

  1340. 

  1341. 

  1342.     /*
    1343. 

  1343.       the new approach try to load a gradient bitmap for each zone
    1344. 

  1344.       from a previously defined folder containing
    1345. 

  1345.       zone_0.bmp
    1346. 

  1346.       zone_1.bmp
    1347. 

  1347.       zone_2.bmp etc.
    1348. 

  1348.     */
    1349. 

  1349.     char *psz_gradient_path = var_CreateGetStringCommand(
    1350. 

  1350.               p_filter,
    1351. 

  1351.               CFG_PREFIX "gradient_path"
    1352. 

  1352.             );
    1353. 

  1353.     if( EMPTY_STR(psz_gradient_path) )
    1354. 

  1354.     {
    1355. 

  1355.         char *psz_file_name = (char *)malloc( strlen(psz_gradient_path) + 16 );
    1356. 

  1356.         assert( psz_file_name );
    1357. 

  1357. 

  1358.         for(int i=0; i < p_atmo_config->getZoneCount(); i++ )
    1359. 

  1359.         {
    1360. 

  1360.             p_zone = p_atmo_config->getZoneDefinition(i);
    1361. 

  1361. 

  1362.             if( p_zone )
    1363. 

  1363.             {
    1364. 

  1364.                 sprintf(psz_file_name, "%s%szone_%d.bmp",
    1365. 

  1365.                                             psz_gradient_path, DIR_SEP, i );
    1366. 

  1366. 

  1367.                 int i_res = p_zone->LoadGradientFromBitmap( psz_file_name );
    1368. 

  1368. 

  1369.                 if( i_res == ATMO_LOAD_GRADIENT_OK )
    1370. 

  1370.                 {
    1371. 

  1371.                 msg_Dbg( p_filter, "loaded gradientfile %s for "\
    1372. 

  1372.                                    "zone %d", psz_file_name, i);
    1373. 

  1373.                 }
    1374. 

  1374. 

  1375.                 if( (i_res != ATMO_LOAD_GRADIENT_OK) &&
    1376. 

  1376.                     (i_res != ATMO_LOAD_GRADIENT_FILENOTFOND) )
    1377. 

  1377.                 {
    1378. 

  1378.                     msg_Err( p_filter,"failed to load gradient '%s' with "\
    1379. 

  1379.                                     "error %d",psz_file_name,i_res);
    1380. 

  1380.                 }
    1381. 

  1381.             }
    1382. 

  1382.         }
    1383. 

  1383. 

  1384.         free( psz_file_name );
    1385. 

  1385.     }
    1386. 

  1386.     free( psz_gradient_path );
    1387. 

  1387. 

  1388. 

  1389.     p_sys->p_atmo_dyndata->UnLockCriticalSection();
    1390. 

  1390. 

  1391. }
    1392. 

  1392. 

  1393. static void Atmo_SetupConfig(filter_t *p_filter, CAtmoConfig *p_atmo_config)
    1394. 

  1394. {
    1395. 

  1395.     /*
    1396. 

  1396.        figuring out the device ports (com-ports, ttys)
    1397. 

  1397.     */
    1398. 

  1398.     char *psz_serialdev = var_CreateGetStringCommand( p_filter,
    1399. 

  1399.                                                       CFG_PREFIX "serialdev" );
    1400. 

  1400.     char *psz_temp = psz_serialdev;
    1401. 

  1401. 

  1402.     if( !EMPTY_STR(psz_serialdev) )
    1403. 

  1403.     {
    1404. 

  1404.         char *psz_token;
    1405. 

  1405.         int i_port = 0;
    1406. 

  1406.         int i;
    1407. 

  1407.         int j;
    1408. 

  1408. 

  1409.         msg_Dbg( p_filter, "use port(s) %s",psz_serialdev);
    1410. 

  1410. 

  1411.         /*
    1412. 

  1412.           psz_serialdev - may contain up to 4 COM ports for the quattro device
    1413. 

  1413.           the quattro device is just hack of useing 4 classic devices as one
    1414. 

  1414.           logical device - thanks that usb-com-ports exists :)
    1415. 

  1415.           as Seperator I defined , or ; with the hope that these
    1416. 

  1416.           characters are never part of a device name
    1417. 

  1417.         */
    1418. 

  1418.         while( (psz_token = strsep(&psz_temp, ",;")) != NULL && i_port < 4 )
    1419. 

  1419.         {
    1420. 

  1420.             /*
    1421. 

  1421.               psz_token may contain spaces we have to trim away
    1422. 

  1422.             */
    1423. 

  1423.             i = 0;
    1424. 

  1424.             j = 0;
    1425. 

  1425.             /*
    1426. 

  1426.               find first none space in string
    1427. 

  1427.             */
    1428. 

  1428.             while( psz_token[i] == 32 ) i++;
    1429. 

  1429.             /*
    1430. 

  1430.               contains string only spaces or is empty? skip it
    1431. 

  1431.             */
    1432. 

  1432.             if( !psz_token[i] )
    1433. 

  1433.                 continue;
    1434. 

  1434. 

  1435.             /*
    1436. 

  1436.               trim
    1437. 

  1437.             */
    1438. 

  1438.             while( psz_token[i] && psz_token[i] != 32 )
    1439. 

  1439.                 psz_token[ j++ ] = psz_token[ i++ ];
    1440. 

  1440.             psz_token[j++] = 0;
    1441. 

  1441. 

  1442.             msg_Dbg( p_filter, "Serial Device [%d]: %s", i_port, psz_token );
    1443. 

  1443. 

  1444.             p_atmo_config->setSerialDevice( i_port, psz_token );
    1445. 

  1445. 

  1446.             i_port++;
    1447. 

  1447.         }
    1448. 

  1448.     }
    1449. 

  1449.     else
    1450. 

  1450.     {
    1451. 

  1451.        msg_Err(p_filter,"no serial devicename(s) set");
    1452. 

  1452.     }
    1453. 

  1453.     free( psz_serialdev );
    1454. 

  1454. 

  1455.     /*
    1456. 

  1456.       configuration of light source layout arround the display
    1457. 

  1457.     */
    1458. 

  1458.     p_atmo_config->setZonesTopCount(
    1459. 

  1459.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "zones-top")
    1460. 

  1460.         );
    1461. 

  1461.     p_atmo_config->setZonesBottomCount(
    1462. 

  1462.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "zones-bottom")
    1463. 

  1463.         );
    1464. 

  1464.     p_atmo_config->setZonesLRCount(
    1465. 

  1465.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "zones-lr")
    1466. 

  1466.         );
    1467. 

  1467.     p_atmo_config->setZoneSummary(
    1468. 

  1468.         var_CreateGetBoolCommand( p_filter, CFG_PREFIX "zone-summary")
    1469. 

  1469.         );
    1470. 

  1470. 

  1471. 

  1472.     p_atmo_config->setLiveViewFilterMode(
    1473. 

  1473.         (AtmoFilterMode)var_CreateGetIntegerCommand( p_filter,
    1474. 

  1474.                                                 CFG_PREFIX "filtermode")
    1475. 

  1475.         );
    1476. 

  1476. 

  1477.     p_atmo_config->setLiveViewFilter_PercentNew(
    1478. 

  1478.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "percentnew")
    1479. 

  1479.         );
    1480. 

  1480.     p_atmo_config->setLiveViewFilter_MeanLength(
    1481. 

  1481.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "meanlength")
    1482. 

  1482.         );
    1483. 

  1483.     p_atmo_config->setLiveViewFilter_MeanThreshold(
    1484. 

  1484.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "meanthreshold")
    1485. 

  1485.         );
    1486. 

  1486. 

  1487.     p_atmo_config->setLiveView_EdgeWeighting(
    1488. 

  1488.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "edgeweightning")
    1489. 

  1489.         );
    1490. 

  1490.     p_atmo_config->setLiveView_BrightCorrect(
    1491. 

  1491.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "brightness")
    1492. 

  1492.         );
    1493. 

  1493.     p_atmo_config->setLiveView_DarknessLimit(
    1494. 

  1494.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "darknesslimit")
    1495. 

  1495.         );
    1496. 

  1496.     p_atmo_config->setLiveView_HueWinSize(
    1497. 

  1497.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "huewinsize")
    1498. 

  1498.         );
    1499. 

  1499.     p_atmo_config->setLiveView_SatWinSize(
    1500. 

  1500.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "satwinsize")
    1501. 

  1501.         );
    1502. 

  1502. 

  1503.     /* currently not required inside vlc */
    1504. 

  1504.     p_atmo_config->setLiveView_WidescreenMode( 0 );
    1505. 

  1505. 

  1506.     p_atmo_config->setLiveView_FrameDelay(
    1507. 

  1507.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "framedelay")
    1508. 

  1508.         );
    1509. 

  1509. 

  1510. 

  1511.     p_atmo_config->setUseSoftwareWhiteAdj(
    1512. 

  1512.         var_CreateGetBoolCommand( p_filter, CFG_PREFIX "whiteadj")
    1513. 

  1513.         );
    1514. 

  1514.     p_atmo_config->setWhiteAdjustment_Red(
    1515. 

  1515.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "white-red")
    1516. 

  1516.         );
    1517. 

  1517.     p_atmo_config->setWhiteAdjustment_Green(
    1518. 

  1518.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "white-green")
    1519. 

  1519.         );
    1520. 

  1520.     p_atmo_config->setWhiteAdjustment_Blue(
    1521. 

  1521.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "white-blue")
    1522. 

  1522.         );
    1523. 

  1523. 

  1524.     /*
    1525. 

  1525.       settings for DMX device only
    1526. 

  1526.     */
    1527. 

  1527.     p_atmo_config->setDMX_RGB_Channels(
    1528. 

  1528.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "dmx-channels")
    1529. 

  1529.         );
    1530. 

  1530. 

  1531.     char *psz_chbase = var_CreateGetStringCommand( p_filter,
    1532. 

  1532.                                                    CFG_PREFIX "dmx-chbase" );
    1533. 

  1533.     if( !EMPTY_STR(psz_chbase) )
    1534. 

  1534.         p_atmo_config->setDMX_BaseChannels( psz_chbase );
    1535. 

  1535. 

  1536.     free( psz_chbase );
    1537. 

  1537. 

  1538.     /*
    1539. 

  1539.       momolight options
    1540. 

  1540.     */
    1541. 

  1541.     p_atmo_config->setMoMo_Channels(
    1542. 

  1542.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "momo-channels")
    1543. 

  1543.        );
    1544. 

  1544. 

  1545.     /*
    1546. 

  1546.       fnordlicht options
    1547. 

  1547.     */
    1548. 

  1548.     p_atmo_config->setFnordlicht_Amount(
    1549. 

  1549.         var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "fnordlicht-amount")
    1550. 

  1550.        );
    1551. 

  1551. 

  1552. }
    1553. 

  1553. 

  1554. 

  1555. /*
    1556. 

  1556. initialize the filter_sys_t structure with the data from the settings
    1557. 

  1557. variables - if the external filter on win32 is enabled try loading the DLL,
    1558. 

  1558. if this fails fallback to the buildin software
    1559. 

  1559. */
    1560. 

  1560. static void Atmo_SetupParameters(filter_t *p_filter)
    1561. 

  1561. {
    1562. 

  1562.     char *psz_path;
    1563. 

  1563.     filter_sys_t *p_sys =  p_filter->p_sys;
    1564. 

  1564. 

  1565. 

  1566.     /* default filter disabled until DLL loaded and Init Success!*/
    1567. 

  1567.     p_sys->b_enabled             = false;
    1568. 

  1568. 

  1569.     /* setup default mini image size (may be later a user option) */
    1570. 

  1570.     p_sys->i_atmo_width          = 64;
    1571. 

  1571.     p_sys->i_atmo_height         = 48;
    1572. 

  1572. 

  1573.     p_sys->i_device_type = var_CreateGetIntegerCommand( p_filter,
    1574. 

  1574.                                                         CFG_PREFIX "device");
    1575. 

  1575. 

  1576.     /*
    1577. 

  1577.       i_device_type
    1578. 

  1578.        0 => use AtmoWin Software (only win32)
    1579. 

  1579.        1 => use AtmoClassicConnection (direct)
    1580. 

  1580.        2 => use AtmoMultiConnection (direct up to four serial ports required)
    1581. 

  1581.        3 => use AtmoDmxConnection (simple serial DMX Device up to 255 channels)
    1582. 

  1582.     */
    1583. 

  1583. 

  1584. 

  1585. #if defined(WIN32)
    1586. 

  1586.     /*
    1587. 

  1587.     only on WIN32 the user has the choice between
    1588. 

  1588.     internal driver and external
    1589. 

  1589.     */
    1590. 

  1590. 

  1591.     if(p_sys->i_device_type == 0) {
    1592. 

  1592. 

  1593.         /* Load the Com Wrapper Library (source available) */
    1594. 

  1594.         p_sys->h_AtmoCtrl = LoadLibraryA("AtmoCtrlLib.dll");
    1595. 

  1595.         if(p_sys->h_AtmoCtrl == NULL)
    1596. 

  1596.         {
    1597. 

  1597.             /*
    1598. 

  1598.               be clever if the location of atmowina.exe is set
    1599. 

  1599.               try to load the dll from the same folder :-)
    1600. 

  1600.             */
    1601. 

  1601.             char *psz_path = var_CreateGetStringCommand( p_filter,
    1602. 

  1602.                                                CFG_PREFIX "atmowinexe" );
    1603. 

  1603.             if( !EMPTY_STR(psz_path) )
    1604. 

  1604.             {
    1605. 

  1605.                 char *psz_bs = strrchr( psz_path , '\\');
    1606. 

  1606.                 if( psz_bs )
    1607. 

  1607.                 {
    1608. 

  1608.                     *psz_bs = 0;
    1609. 

  1609.                     /*
    1610. 

  1610.                       now format a new dll filename with complete path
    1611. 

  1611.                     */
    1612. 

  1612.                     char *psz_dllname = NULL;
    1613. 

  1613.                     asprintf( &psz_dllname, "%s\\AtmoCtrlLib.dll", psz_path );
    1614. 

  1614.                     if( psz_dllname )
    1615. 

  1615.                     {
    1616. 

  1616.                         msg_Dbg( p_filter, "Try Loading '%s'", psz_dllname );
    1617. 

  1617.                         p_sys->h_AtmoCtrl = LoadLibraryA( psz_dllname );
    1618. 

  1618.                     }
    1619. 

  1619.                     free( psz_dllname );
    1620. 

  1620.                 }
    1621. 

  1621.             }
    1622. 

  1622.             free( psz_path );
    1623. 

  1623.         }
    1624. 

  1624. 

  1625. 

  1626.         if(p_sys->h_AtmoCtrl != NULL)
    1627. 

  1627.         {
    1628. 

  1628.             msg_Dbg( p_filter, "Load Library ok!");
    1629. 

  1629. 

  1630.             /* importing all required functions I hope*/
    1631. 

  1631.             p_sys->pf_ctrl_atmo_initialize =
    1632. 

  1632.                 (int32_t (*)(void))GetProcAddress(p_sys->h_AtmoCtrl,
    1633. 

  1633.                             "AtmoInitialize");
    1634. 

  1634.             if(!p_sys->pf_ctrl_atmo_initialize)
    1635. 

  1635.                 msg_Err( p_filter, "export AtmoInitialize missing.");
    1636. 

  1636. 

  1637.             p_sys->pf_ctrl_atmo_finalize =
    1638. 

  1638.                 (void (*)(int32_t))GetProcAddress(p_sys->h_AtmoCtrl,
    1639. 

  1639.                             "AtmoFinalize");
    1640. 

  1640.             if(!p_sys->pf_ctrl_atmo_finalize)
    1641. 

  1641.                 msg_Err( p_filter, "export AtmoFinalize missing.");
    1642. 

  1642. 

  1643.             p_sys->pf_ctrl_atmo_switch_effect =
    1644. 

  1644.                 (int32_t(*)(int32_t))GetProcAddress(p_sys->h_AtmoCtrl,
    1645. 

  1645.                             "AtmoSwitchEffect");
    1646. 

  1646.             if(!p_sys->pf_ctrl_atmo_switch_effect)
    1647. 

  1647.                 msg_Err( p_filter, "export AtmoSwitchEffect missing.");
    1648. 

  1648. 

  1649.             p_sys->pf_ctrl_atmo_set_live_source =
    1650. 

  1650.                 (int32_t(*)(int32_t))GetProcAddress(p_sys->h_AtmoCtrl,
    1651. 

  1651.                             "AtmoSetLiveSource");
    1652. 

  1652.             if(!p_sys->pf_ctrl_atmo_set_live_source)
    1653. 

  1653.                 msg_Err( p_filter, "export AtmoSetLiveSource missing.");
    1654. 

  1654. 

  1655.             p_sys->pf_ctrl_atmo_create_transfer_buffers =
    1656. 

  1656.                 (void (*)(int32_t, int32_t, int32_t , int32_t))
    1657. 

  1657.                     GetProcAddress(p_sys->h_AtmoCtrl,"AtmoCreateTransferBuffers");
    1658. 

  1658.             if(!p_sys->pf_ctrl_atmo_create_transfer_buffers)
    1659. 

  1659.                 msg_Err( p_filter, "export AtmoCreateTransferBuffers missing.");
    1660. 

  1660. 

  1661.             p_sys->pf_ctrl_atmo_lock_transfer_buffer=
    1662. 

  1662.                 (uint8_t*(*) (void))GetProcAddress(p_sys->h_AtmoCtrl,
    1663. 

  1663.                             "AtmoLockTransferBuffer");
    1664. 

  1664.             if(!p_sys->pf_ctrl_atmo_lock_transfer_buffer)
    1665. 

  1665.                 msg_Err( p_filter, "export AtmoLockTransferBuffer missing.");
    1666. 

  1666. 

  1667.             p_sys->pf_ctrl_atmo_send_pixel_data =
    1668. 

  1668.                 (void (*)(void))GetProcAddress(p_sys->h_AtmoCtrl,
    1669. 

  1669.                             "AtmoSendPixelData");
    1670. 

  1670.             if(!p_sys->pf_ctrl_atmo_send_pixel_data)
    1671. 

  1671.                 msg_Err( p_filter, "export AtmoSendPixelData missing.");
    1672. 

  1672. 

  1673.             p_sys->pf_ctrl_atmo_get_image_size =
    1674. 

  1674.                 (void (*)(int32_t*,int32_t*))GetProcAddress(p_sys->h_AtmoCtrl,
    1675. 

  1675.                             "AtmoWinGetImageSize");
    1676. 

  1676.             if(!p_sys->pf_ctrl_atmo_get_image_size)
    1677. 

  1677.                 msg_Err( p_filter, "export AtmoWinGetImageSize missing.");
    1678. 

  1678. 

  1679.         } else {
    1680. 

  1680.             /* the DLL is missing try internal filter ...*/
    1681. 

  1681.             msg_Warn( p_filter,
    1682. 

  1682.                 "AtmoCtrlLib.dll missing fallback to internal atmo classic driver");
    1683. 

  1683.             p_sys->i_device_type = 1;
    1684. 

  1684.         }
    1685. 

  1685.     }
    1686. 

  1686. #endif
    1687. 

  1687. 

  1688.     if(p_sys->i_device_type >= 1) {
    1689. 

  1689.         msg_Dbg( p_filter, "try use buildin driver %d ", p_sys->i_device_type);
    1690. 

  1690.         /*
    1691. 

  1691.         now we have to read a lof of options from the config dialog
    1692. 

  1692.         most important the serial device if not set ... we can skip
    1693. 

  1693.         the rest and disable the filter...
    1694. 

  1694.         */
    1695. 

  1695. 

  1696.         p_sys->p_atmo_config = new CAtmoConfig();
    1697. 

  1697. 

  1698.         p_sys->p_atmo_dyndata = new CAtmoDynData(
    1699. 

  1699.                    (vlc_object_t *)p_filter,
    1700. 

  1700.                    p_sys->p_atmo_config
    1701. 

  1701.         );
    1702. 

  1702. 

  1703.         Atmo_SetupConfig( p_filter, p_sys->p_atmo_config );
    1704. 

  1704.         switch(p_sys->i_device_type)
    1705. 

  1705.         {
    1706. 

  1706.             case 1:
    1707. 

  1707.                 p_sys->p_atmo_config->setConnectionType( actClassicAtmo );
    1708. 

  1708.                 break;
    1709. 

  1709. 

  1710.             case 2:
    1711. 

  1711.                 p_sys->p_atmo_config->setConnectionType( actMultiAtmo );
    1712. 

  1712.                 break;
    1713. 

  1713. 

  1714.             case 3:
    1715. 

  1715.                 p_sys->p_atmo_config->setConnectionType( actDMX );
    1716. 

  1716.                 break;
    1717. 

  1717. 

  1718.             case 4:
    1719. 

  1719.                 p_sys->p_atmo_config->setConnectionType( actMoMoLight );
    1720. 

  1720.                 break;
    1721. 

  1721. 

  1722.             case 5:
    1723. 

  1723.                 p_sys->p_atmo_config->setConnectionType( actFnordlicht );
    1724. 

  1724.                 break;
    1725. 

  1725. 

  1726.             default:
    1727. 

  1727.                 msg_Warn( p_filter, "invalid device type %d found",
    1728. 

  1728.                                     p_sys->i_device_type );
    1729. 

  1729.         }
    1730. 

  1730. 

  1731.         msg_Dbg( p_filter, "buildin driver config set");
    1732. 

  1732. 

  1733.     }
    1734. 

  1734. 

  1735.     switch( p_filter->fmt_in.video.i_chroma )
    1736. 

  1736.     {
    1737. 

  1737.     case VLC_CODEC_I420:
    1738. 

  1738.     case VLC_CODEC_YV12:
    1739. 

  1739.         p_sys->pf_extract_mini_image = ExtractMiniImage_YUV;
    1740. 

  1740.         break;
    1741. 

  1741.     default:
    1742. 

  1742.         msg_Warn( p_filter, "InitFilter-unsupported chroma: %4.4s",
    1743. 

  1743.                             (char *)&p_filter->fmt_in.video.i_chroma);
    1744. 

  1744.         p_sys->pf_extract_mini_image = NULL;
    1745. 

  1745.     }
    1746. 

  1746. 

  1747.     /*
    1748. 

  1748.     for debugging purpose show the samplinggrid on each frame as
    1749. 

  1749.     white dots
    1750. 

  1750.     */
    1751. 

  1751.     p_sys->b_show_dots = var_CreateGetBoolCommand( p_filter,
    1752. 

  1752.         CFG_PREFIX "showdots"
    1753. 

  1753.         );
    1754. 

  1754. 

  1755. #if defined(__ATMO_DEBUG__)
    1756. 

  1756.     /* save debug images to a folder as Bitmap files ? */
    1757. 

  1757.     p_sys->b_saveframes  = var_CreateGetBoolCommand( p_filter,
    1758. 

  1758.         CFG_PREFIX "saveframes"
    1759. 

  1759.         );
    1760. 

  1760.     msg_Dbg(p_filter,"saveframes = %d", (int)p_sys->b_saveframes);
    1761. 

  1761. 

  1762.     /*
    1763. 

  1763.     read debug image folder from config
    1764. 

  1764.     */
    1765. 

  1765.     psz_path = var_CreateGetStringCommand( p_filter, CFG_PREFIX "framepath" );
    1766. 

  1766.     if(psz_path != NULL)
    1767. 

  1767.     {
    1768. 

  1768.         strcpy(p_sys->sz_framepath, psz_path);
    1769. 

  1769. #if defined( WIN32 )
    1770. 

  1770.         size_t i_strlen = strlen(p_sys->sz_framepath);
    1771. 

  1771.         if((i_strlen>0) && (p_sys->sz_framepath[i_strlen-1] != '\\'))
    1772. 

  1772.         {
    1773. 

  1773.             p_sys->sz_framepath[i_strlen] = '\\';
    1774. 

  1774.             p_sys->sz_framepath[i_strlen+1] = 0;
    1775. 

  1775.         }
    1776. 

  1776. #endif
    1777. 

  1777.         free(psz_path);
    1778. 

  1778.     }
    1779. 

  1779.     msg_Dbg(p_filter,"saveframesfolder %s",p_sys->sz_framepath);
    1780. 

  1780. #endif
    1781. 

  1781. 

  1782. 

  1783.     /*
    1784. 

  1784.     because atmowin could also be used for lighten up the room - I think if you
    1785. 

  1785.     pause the video it would be useful to get a little bit more light into to
    1786. 

  1786.     your living room? - instead switching on a lamp?
    1787. 

  1787.     */
    1788. 

  1788.     p_sys->b_usepausecolor = var_CreateGetBoolCommand( p_filter,
    1789. 

  1789.         CFG_PREFIX "usepausecolor" );
    1790. 

  1790.     p_sys->ui_pausecolor_red = (uint8_t)var_CreateGetIntegerCommand( p_filter,
    1791. 

  1791.         CFG_PREFIX "pcolor-red");
    1792. 

  1792.     p_sys->ui_pausecolor_green = (uint8_t)var_CreateGetIntegerCommand( p_filter,
    1793. 

  1793.         CFG_PREFIX "pcolor-green");
    1794. 

  1794.     p_sys->ui_pausecolor_blue = (uint8_t)var_CreateGetIntegerCommand( p_filter,
    1795. 

  1795.         CFG_PREFIX "pcolor-blue");
    1796. 

  1796.     p_sys->i_fadesteps = var_CreateGetIntegerCommand( p_filter,
    1797. 

  1797.         CFG_PREFIX "fadesteps");
    1798. 

  1798.     if(p_sys->i_fadesteps < 1)
    1799. 

  1799.         p_sys->i_fadesteps = 1;
    1800. 

  1800.     msg_Dbg(p_filter,"use pause color %d, RGB: %d, %d, %d, Fadesteps: %d",
    1801. 

  1801.         (int)p_sys->b_usepausecolor,
    1802. 

  1802.         p_sys->ui_pausecolor_red,
    1803. 

  1803.         p_sys->ui_pausecolor_green,
    1804. 

  1804.         p_sys->ui_pausecolor_blue,
    1805. 

  1805.         p_sys->i_fadesteps);
    1806. 

  1806. 

  1807.     /*
    1808. 

  1808.     this color is use on shutdown of the filter - the define the
    1809. 

  1809.     final light after playback... may be used to dim up the light -
    1810. 

  1810.     how it happens in the cinema...
    1811. 

  1811.     */
    1812. 

  1812.     p_sys->ui_endcolor_red = (uint8_t)var_CreateGetIntegerCommand( p_filter,
    1813. 

  1813.         CFG_PREFIX "ecolor-red");
    1814. 

  1814.     p_sys->ui_endcolor_green = (uint8_t)var_CreateGetIntegerCommand( p_filter,
    1815. 

  1815.         CFG_PREFIX "ecolor-green");
    1816. 

  1816.     p_sys->ui_endcolor_blue = (uint8_t)var_CreateGetIntegerCommand( p_filter,
    1817. 

  1817.         CFG_PREFIX "ecolor-blue");
    1818. 

  1818.     p_sys->i_endfadesteps = var_CreateGetIntegerCommand( p_filter,
    1819. 

  1819.         CFG_PREFIX "efadesteps");
    1820. 

  1820.     if(p_sys->i_endfadesteps < 1)
    1821. 

  1821.         p_sys->i_endfadesteps = 1;
    1822. 

  1822.     msg_Dbg(p_filter,"use ende color RGB: %d, %d, %d, Fadesteps: %d",
    1823. 

  1823.         p_sys->ui_endcolor_red,
    1824. 

  1824.         p_sys->ui_endcolor_green,
    1825. 

  1825.         p_sys->ui_endcolor_blue,
    1826. 

  1826.         p_sys->i_endfadesteps);
    1827. 

  1827. 

  1828. 

  1829. 

  1830.     /*
    1831. 

  1831.       if the external DLL was loaded successfully call AtmoInitialize -
    1832. 

  1832.       (must be done for each thread where you want to use AtmoLight!)
    1833. 

  1833.     */
    1834. 

  1834.     int i = AtmoInitialize(p_filter, false);
    1835. 

  1835. 

  1836. #if defined( WIN32 )
    1837. 

  1837.     if((i != 1) && (p_sys->i_device_type == 0))
    1838. 

  1838.     {
    1839. 

  1839.         /*
    1840. 

  1840.           COM Server for AtmoLight not running ?
    1841. 

  1841.           if the exe path is configured try to start the "userspace" driver
    1842. 

  1842.         */
    1843. 

  1843.         psz_path = var_CreateGetStringCommand( p_filter,
    1844. 

  1844.                                                CFG_PREFIX "atmowinexe" );
    1845. 

  1845.         if(psz_path != NULL)
    1846. 

  1846.         {
    1847. 

  1847.             STARTUPINFO startupinfo;
    1848. 

  1848.             PROCESS_INFORMATION pinfo;
    1849. 

  1849.             memset(&startupinfo, 0, sizeof(STARTUPINFO));
    1850. 

  1850.             startupinfo.cb = sizeof(STARTUPINFO);
    1851. 

  1851.             if(CreateProcess(psz_path, NULL, NULL, NULL,
    1852. 

  1852.                 FALSE, 0, NULL, NULL, &startupinfo, &pinfo) == TRUE)
    1853. 

  1853.             {
    1854. 

  1854.                 msg_Dbg(p_filter,"launched AtmoWin from %s",psz_path);
    1855. 

  1855.                 WaitForInputIdle(pinfo.hProcess, 5000);
    1856. 

  1856.                 /*
    1857. 

  1857.                   retry to initialize the library COM ... functionality
    1858. 

  1858.                   after the server was launched
    1859. 

  1859.                 */
    1860. 

  1860.                 i = AtmoInitialize(p_filter, false);
    1861. 

  1861.             } else {
    1862. 

  1862.                 msg_Err(p_filter,"failed to launch AtmoWin from %s", psz_path);
    1863. 

  1863.             }
    1864. 

  1864.             free(psz_path);
    1865. 

  1865.         }
    1866. 

  1866.     }
    1867. 

  1867. #endif
    1868. 

  1868. 

  1869.     if(i == 1) /* Init Atmolight success... */
    1870. 

  1870.     {
    1871. 

  1871.         msg_Dbg( p_filter, "AtmoInitialize Ok!");
    1872. 

  1872.         /*
    1873. 

  1873.         configure
    1874. 

  1874.            p_sys->i_atmo_width and p_sys->i_atmo_height
    1875. 

  1875.            if the external AtmoWinA.exe is used, it may require
    1876. 

  1876.            a other sample image size than 64 x 48
    1877. 

  1877.            (this overrides the settings of the filter)
    1878. 

  1878.         */
    1879. 

  1879.         Atmo_SetupImageSize( p_filter );
    1880. 

  1880. 

  1881. 

  1882.         if( p_sys->i_device_type >= 1 )
    1883. 

  1883.         {
    1884. 

  1884.            /*
    1885. 

  1885.              AtmoConnection class initialized now we can initialize
    1886. 

  1886.              the default zone and channel mappings
    1887. 

  1887.            */
    1888. 

  1888.            Atmo_SetupBuildZones( p_filter );
    1889. 

  1889.         }
    1890. 

  1890. 

  1891.         /* Setup Transferbuffers for 64 x 48 , RGB with 32bit Per Pixel */
    1892. 

  1892.         AtmoCreateTransferBuffers(p_filter, BI_RGB, 4,
    1893. 

  1893.             p_sys->i_atmo_width,
    1894. 

  1894.             p_sys->i_atmo_height
    1895. 

  1895.             );
    1896. 

  1896. 

  1897.         /* say the userspace driver that a live mode should be activated
    1898. 

  1898.         the functions returns the old mode for later restore!
    1899. 

  1899.         - the buildin driver launches the live view thread in that case
    1900. 

  1900.         */
    1901. 

  1901.         p_sys->i_AtmoOldEffect = AtmoSwitchEffect(p_filter, emLivePicture);
    1902. 

  1902. 

  1903.         /*
    1904. 

  1904.         live view can have two differnt source the AtmoWinA
    1905. 

  1905.         internal GDI Screencapture and the external one - which we
    1906. 

  1906.         need here...
    1907. 

  1907.         */
    1908. 

  1908.         AtmoSetLiveSource(p_filter, lvsExternal);
    1909. 

  1909. 

  1910.         /* enable other parts only if everything is fine */
    1911. 

  1911.         p_sys->b_enabled = true;
    1912. 

  1912. 

  1913.         msg_Dbg( p_filter, "Atmo Filter Enabled Ok!");
    1914. 

  1914.     }
    1915. 

  1915. 

  1916. }
    1917. 

  1917. 

  1918. 

  1919. /*****************************************************************************
    1920. 

  1920. * CreateFilter: allocates AtmoLight video thread output method
    1921. 

  1921. *****************************************************************************
    1922. 

  1922. * This function allocates and initializes a AtmoLight vout method.
    1923. 

  1923. *****************************************************************************/
    1924. 

  1924. static int CreateFilter( vlc_object_t *p_this )
    1925. 

  1925. {
    1926. 

  1926.     filter_t *p_filter = (filter_t *)p_this;
    1927. 

  1927.     filter_sys_t *p_sys;
    1928. 

  1928. 

  1929.     /* Allocate structure */
    1930. 

  1930.     p_sys = (filter_sys_t *)malloc( sizeof( filter_sys_t ) );
    1931. 

  1931.     p_filter->p_sys = p_sys;
    1932. 

  1932.     if( p_filter->p_sys == NULL )
    1933. 

  1933.         return VLC_ENOMEM;
    1934. 

  1934.     /* set all entries to zero */
    1935. 

  1935.     memset(p_sys, 0, sizeof( filter_sys_t ));
    1936. 

  1936.     vlc_mutex_init( &p_sys->filter_lock );
    1937. 

  1937. 

  1938.     msg_Dbg( p_filter, "Create Atmo Filter");
    1939. 

  1939. 

  1940.     /* further Setup Function pointers for videolan for calling my filter */
    1941. 

  1941.     p_filter->pf_video_filter = Filter;
    1942. 

  1942. 

  1943.     config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
    1944. 

  1944.                        p_filter->p_cfg );
    1945. 

  1945. 

  1946.     AddStateVariableCallback(p_filter);
    1947. 

  1947. 

  1948.     AddAtmoSettingsVariablesCallbacks(p_filter);
    1949. 

  1949. 

  1950.     Atmo_SetupParameters(p_filter);
    1951. 

  1951. 

  1952. 

  1953.     return VLC_SUCCESS;
    1954. 

  1954. }
    1955. 

  1955. 

  1956. 

  1957. 

  1958. /*****************************************************************************
    1959. 

  1959. * DestroyFilter: destroy AtmoLight video thread output method
    1960. 

  1960. *****************************************************************************
    1961. 

  1961. * Terminate an output method created by CreateFilter
    1962. 

  1962. *****************************************************************************/
    1963. 

  1963. 

  1964. static void DestroyFilter( vlc_object_t *p_this )
    1965. 

  1965. {
    1966. 

  1966.     filter_t *p_filter = (filter_t *)p_this;
    1967. 

  1967.     filter_sys_t *p_sys =  p_filter->p_sys;
    1968. 

  1968. 

  1969.     msg_Dbg( p_filter, "Destroy Atmo Filter");
    1970. 

  1970. 

  1971.     DelStateVariableCallback(p_filter);
    1972. 

  1972. 

  1973.     DelAtmoSettingsVariablesCallbacks(p_filter);
    1974. 

  1974. 

  1975.     Atmo_Shutdown(p_filter);
    1976. 

  1976. 

  1977. #if defined( WIN32 )
    1978. 

  1978.     if(p_sys->h_AtmoCtrl != NULL)
    1979. 

  1979.     {
    1980. 

  1980.         FreeLibrary(p_sys->h_AtmoCtrl);
    1981. 

  1981.     }
    1982. 

  1982. #endif
    1983. 

  1983. 

  1984.     delete p_sys->p_atmo_dyndata;
    1985. 

  1985.     delete p_sys->p_atmo_config;
    1986. 

  1986. 

  1987.     vlc_mutex_destroy( &p_sys->filter_lock );
    1988. 

  1988. 

  1989.     free( p_sys );
    1990. 

  1990. }
    1991. 

  1991. 

  1992. 

  1993. /*
    1994. 

  1994. function stolen from some other videolan source filter ;-)
    1995. 

  1995. for the moment RGB is OK... but better would be a direct transformation
    1996. 

  1996. from YUV --> HSV
    1997. 

  1997. */
    1998. 

  1998. static inline void yuv_to_rgb( uint8_t *r, uint8_t *g, uint8_t *b,
    1999. 

  1999.                               uint8_t y1, uint8_t u1, uint8_t v1 )
    2000. 

  2000. {
    2001. 

  2001.     /* macros used for YUV pixel conversions */
    2002. 

  2002. #   define SCALEBITS 10
    2003. 

  2003. #   define ONE_HALF  (1 << (SCALEBITS - 1))
    2004. 

  2004. #   define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
    2005. 

  2005. #   define CLAMP( x ) (((x) > 255) ? 255 : ((x) < 0) ? 0 : (x));
    2006. 

  2006. 

  2007.     int y, cb, cr, r_add, g_add, b_add;
    2008. 

  2008. 

  2009.     cb = u1 - 128;
    2010. 

  2010.     cr = v1 - 128;
    2011. 

  2011.     r_add = FIX(1.40200*255.0/224.0) * cr + ONE_HALF;
    2012. 

  2012.     g_add = - FIX(0.34414*255.0/224.0) * cb
    2013. 

  2013.         - FIX(0.71414*255.0/224.0) * cr + ONE_HALF;
    2014. 

  2014.     b_add = FIX(1.77200*255.0/224.0) * cb + ONE_HALF;
    2015. 

  2015.     y = (y1 - 16) * FIX(255.0/219.0);
    2016. 

  2016.     *r = CLAMP((y + r_add) >> SCALEBITS);
    2017. 

  2017.     *g = CLAMP((y + g_add) >> SCALEBITS);
    2018. 

  2018.     *b = CLAMP((y + b_add) >> SCALEBITS);
    2019. 

  2019. }
    2020. 

  2020. /******************************************************************************
    2021. 

  2021. * ExtractMiniImage_YUV: extract a small image from the picture as 24-bit RGB
    2022. 

  2022. *******************************************************************************
    2023. 

  2023. * p_sys is a pointer to
    2024. 

  2024. * p_inpic is the source frame
    2025. 

  2025. * p_transfer_dest is the target buffer for the picture must be big enough!
    2026. 

  2026. * (in win32 environment this buffer comes from the external DLL where it is
    2027. 

  2027. * create as "variant array" and returned through the AtmoLockTransferbuffer
    2028. 

  2028. */
    2029. 

  2029. static void ExtractMiniImage_YUV(filter_sys_t *p_sys,
    2030. 

  2030.                                  picture_t *p_inpic,
    2031. 

  2031.                                  uint8_t *p_transfer_dest)
    2032. 

  2032. {
    2033. 

  2033.     int i_col;
    2034. 

  2034.     int i_row;
    2035. 

  2035.     uint8_t *p_src_y;
    2036. 

  2036.     uint8_t *p_src_u;
    2037. 

  2037.     uint8_t *p_src_v;
    2038. 

  2038.     uint8_t *p_rgb_dst_line_red;
    2039. 

  2039.     uint8_t *p_rgb_dst_line_green;
    2040. 

  2040.     uint8_t *p_rgb_dst_line_blue;
    2041. 

  2041.     int i_xpos_y;
    2042. 

  2042.     int i_xpos_u;
    2043. 

  2043.     int i_xpos_v;
    2044. 

  2044. 

  2045.     /* calcute Pointers for Storage of B G R (A) */
    2046. 

  2046.     p_rgb_dst_line_blue      = p_transfer_dest;
    2047. 

  2047.     p_rgb_dst_line_green     = p_transfer_dest + 1;
    2048. 

  2048.     p_rgb_dst_line_red       = p_transfer_dest + 2 ;
    2049. 

  2049. 

  2050.     int i_row_count = p_sys->i_atmo_height + 1;
    2051. 

  2051.     int i_col_count = p_sys->i_atmo_width + 1;
    2052. 

  2052.     int i_y_row,i_u_row,i_v_row,i_pixel_row;
    2053. 

  2053.     int i_pixel_col;
    2054. 

  2054. 

  2055. 

  2056.     /*  these two ugly loops extract the small image - goes it faster? how?
    2057. 

  2057.     the loops are so designed that there is a small border around the extracted
    2058. 

  2058.     image so we wont get column and row - zero from the frame, and not the most
    2059. 

  2059.     right and bottom pixels --- which may be clipped on computers useing TV out
    2060. 

  2060.     - through overscan!
    2061. 

    2062. 

  2062.     TODO: try to find out if the output is clipped through VLC - and try here
    2063. 

  2063.     to ingore the clipped away area for a better result!
    2064. 

    2065. 

  2065.     TODO: performance improvement in InitFilter percalculated the offsets of
    2066. 

  2066.     the lines inside the planes so I can save (i_row_count * 3) 2xMUL and
    2067. 

  2067.     one time DIV the same could be done for the inner loop I think...
    2068. 

  2068.     */
    2069. 

  2069.     for(i_row = 1; i_row < i_row_count; i_row++)
    2070. 

  2070.     {
    2071. 

  2071.         // calcute the current Lines in the source planes for this outputrow
    2072. 

  2072.         /*  Adresscalcuation  pointer to plane  Length of one pixelrow in bytes
    2073. 

  2073.         calculate row now number
    2074. 

  2074.         */
    2075. 

  2075.         /*
    2076. 

  2076.            p_inpic->format? transform Pixel row into row of plane...
    2077. 

  2077.            how? simple? fast? good?
    2078. 

  2078.         */
    2079. 

  2079. 

  2080.         /* compute the source pixel row and respect the active cropping */
    2081. 

  2081.         i_pixel_row = (i_row * p_sys->i_crop_height) / i_row_count
    2082. 

  2082.             + p_sys->i_crop_y_offset;
    2083. 

  2083. 

  2084.         /*
    2085. 

  2085.         trans for these Pixel row into the row of each plane ..
    2086. 

  2086.         because planesize can differ from image size
    2087. 

  2087.         */
    2088. 

  2088.         i_y_row = (i_pixel_row * p_inpic->p[Y_PLANE].i_visible_lines) /
    2089. 

  2089.             p_inpic->format.i_visible_height;
    2090. 

  2090. 

  2091.         i_u_row = (i_pixel_row * p_inpic->p[U_PLANE].i_visible_lines) /
    2092. 

  2092.             p_inpic->format.i_visible_height;
    2093. 

  2093. 

  2094.         i_v_row = (i_pixel_row * p_inpic->p[V_PLANE].i_visible_lines) /
    2095. 

  2095.             p_inpic->format.i_visible_height;
    2096. 

  2096. 

  2097.         /* calculate  the pointers to the pixeldata for this row
    2098. 

  2098.            in each plane
    2099. 

  2099.         */
    2100. 

  2100.         p_src_y = p_inpic->p[Y_PLANE].p_pixels +
    2101. 

  2101.             p_inpic->p[Y_PLANE].i_pitch * i_y_row;
    2102. 

  2102.         p_src_u = p_inpic->p[U_PLANE].p_pixels +
    2103. 

  2103.             p_inpic->p[U_PLANE].i_pitch * i_u_row;
    2104. 

  2104.         p_src_v = p_inpic->p[V_PLANE].p_pixels +
    2105. 

  2105.             p_inpic->p[V_PLANE].i_pitch * i_v_row;
    2106. 

  2106. 

  2107.         for(i_col = 1; i_col < i_col_count; i_col++)
    2108. 

  2108.         {
    2109. 

  2109.             i_pixel_col = (i_col * p_sys->i_crop_width) / i_col_count +
    2110. 

  2110.                 p_sys->i_crop_x_offset;
    2111. 

  2111.             /*
    2112. 

  2112.             trans for these Pixel row into the row of each plane ..
    2113. 

  2113.             because planesize can differ from image size
    2114. 

  2114.             */
    2115. 

  2115.             i_xpos_y = (i_pixel_col * p_inpic->p[Y_PLANE].i_visible_pitch) /
    2116. 

  2116.                 p_inpic->format.i_visible_width;
    2117. 

  2117.             i_xpos_u = (i_pixel_col * p_inpic->p[U_PLANE].i_visible_pitch) /
    2118. 

  2118.                 p_inpic->format.i_visible_width;
    2119. 

  2119.             i_xpos_v = (i_pixel_col * p_inpic->p[V_PLANE].i_visible_pitch) /
    2120. 

  2120.                 p_inpic->format.i_visible_width;
    2121. 

  2121. 

  2122.             yuv_to_rgb(p_rgb_dst_line_red,
    2123. 

  2123.                 p_rgb_dst_line_green,
    2124. 

  2124.                 p_rgb_dst_line_blue,
    2125. 

  2125. 

  2126.                 p_src_y[i_xpos_y],
    2127. 

  2127.                 p_src_u[i_xpos_u],
    2128. 

  2128.                 p_src_v[i_xpos_v]);
    2129. 

  2129. 

  2130.             /* +4 because output image should be RGB32 with dword alignment! */
    2131. 

  2131.             p_rgb_dst_line_red   += 4;
    2132. 

  2132.             p_rgb_dst_line_green += 4;
    2133. 

  2133.             p_rgb_dst_line_blue  += 4;
    2134. 

  2134.         }
    2135. 

  2135.    }
    2136. 

  2136. 

  2137.    if(p_sys->b_show_dots)
    2138. 

  2138.    {
    2139. 

  2139.        for(i_row = 1; i_row < i_row_count; i_row++)
    2140. 

  2140.        {
    2141. 

  2141.            i_pixel_row = (i_row * p_sys->i_crop_height) / i_row_count
    2142. 

  2142.                    + p_sys->i_crop_y_offset;
    2143. 

  2143. 

  2144.            i_y_row = (i_pixel_row * p_inpic->p[Y_PLANE].i_visible_lines) /
    2145. 

  2145.                    p_inpic->format.i_visible_height;
    2146. 

  2146. 

  2147.            p_src_y = p_inpic->p[Y_PLANE].p_pixels +
    2148. 

  2148.                    p_inpic->p[Y_PLANE].i_pitch * i_y_row;
    2149. 

  2149. 

  2150.            for(i_col = 1; i_col < i_col_count; i_col++)
    2151. 

  2151.            {
    2152. 

  2152.               i_pixel_col = (i_col * p_sys->i_crop_width) / i_col_count +
    2153. 

  2153.                             p_sys->i_crop_x_offset;
    2154. 

  2154.               i_xpos_y = (i_pixel_col * p_inpic->p[Y_PLANE].i_visible_pitch) /
    2155. 

  2155.                          p_inpic->format.i_visible_width;
    2156. 

  2156. 

  2157.               p_src_y[i_xpos_y] = 255;
    2158. 

  2158.            }
    2159. 

  2159.        }
    2160. 

  2160.    }
    2161. 

  2161. 

  2162. }
    2163. 

  2163. 

  2164. 

  2165. /******************************************************************************
    2166. 

  2166. * SaveBitmap: Saves the content of a transferbuffer as Bitmap to disk
    2167. 

  2167. *******************************************************************************
    2168. 

  2168. * just for debugging
    2169. 

  2169. * p_sys -> configuration if Atmo from there the function will get height and
    2170. 

  2170. *          width
    2171. 

  2171. * p_pixels -> should be the dword aligned BGR(A) image data
    2172. 

  2172. * psz_filename -> filename where to store
    2173. 

  2173. */
    2174. 

  2174. #if defined(__ATMO_DEBUG__)
    2175. 

  2175. void SaveBitmap(filter_sys_t *p_sys, uint8_t *p_pixels, char *psz_filename)
    2176. 

  2176. {
    2177. 

  2177.     /* for debug out only used*/
    2178. 

  2178.     BITMAPINFO bmp_info;
    2179. 

  2179.     BITMAPFILEHEADER  bmp_fileheader;
    2180. 

  2180.     FILE *fp_bitmap;
    2181. 

  2181. 

  2182.     memset(&bmp_info, 0, sizeof(BITMAPINFO));
    2183. 

  2183.     bmp_info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    2184. 

  2184.     bmp_info.bmiHeader.biSizeImage   = p_sys->i_atmo_height *
    2185. 

  2185.                                        p_sys->i_atmo_width * 4;
    2186. 

  2186.     bmp_info.bmiHeader.biCompression = BI_RGB;
    2187. 

  2187.     bmp_info.bmiHeader.biWidth        = p_sys->i_atmo_width;
    2188. 

  2188.     bmp_info.bmiHeader.biHeight       = -p_sys->i_atmo_height;
    2189. 

  2189.     bmp_info.bmiHeader.biBitCount     = 32;
    2190. 

  2190.     bmp_info.bmiHeader.biPlanes       = 1;
    2191. 

  2191. 

  2192.     bmp_fileheader.bfReserved1 = 0;
    2193. 

  2193.     bmp_fileheader.bfReserved2 = 0;
    2194. 

  2194.     bmp_fileheader.bfSize = sizeof(BITMAPFILEHEADER) +
    2195. 

  2195.                             sizeof(BITMAPINFOHEADER) +
    2196. 

  2196.                             bmp_info.bmiHeader.biSizeImage;
    2197. 

  2197.     bmp_fileheader.bfType = VLC_TWOCC('B','M');
    2198. 

  2198.     bmp_fileheader.bfOffBits = sizeof(BITMAPFILEHEADER) +
    2199. 

  2199.                                sizeof(BITMAPINFOHEADER);
    2200. 

  2200. 

  2201.     fp_bitmap = fopen(psz_filename,"wb");
    2202. 

  2202.     if( fp_bitmap != NULL)
    2203. 

  2203.     {
    2204. 

  2204.         fwrite(&bmp_fileheader, sizeof(BITMAPFILEHEADER), 1, fp_bitmap);
    2205. 

  2205.         fwrite(&bmp_info.bmiHeader, sizeof(BITMAPINFOHEADER), 1, fp_bitmap);
    2206. 

  2206.         fwrite(p_pixels, bmp_info.bmiHeader.biSizeImage, 1, fp_bitmap);
    2207. 

  2207.         fclose(fp_bitmap);
    2208. 

  2208.     }
    2209. 

  2209. }
    2210. 

  2210. #endif
    2211. 

  2211. 

  2212. 

  2213. /****************************************************************************
    2214. 

  2214. * CreateMiniImage: extracts a 64x48 pixel image from the frame
    2215. 

  2215. * (there is a small border arround thats why the loops starts with one
    2216. 

  2216. * instead zero) without any interpolation
    2217. 

  2217. *****************************************************************************/
    2218. 

  2218. static void CreateMiniImage( filter_t *p_filter, picture_t *p_inpic)
    2219. 

  2219. {
    2220. 

  2220.     filter_sys_t *p_sys = p_filter->p_sys;
    2221. 

  2221.     /*
    2222. 

  2222.     pointer to RGB Buffer created in external libary as safe array which
    2223. 

  2223.     is locked inside AtmoLockTransferBuffer
    2224. 

  2224.     */
    2225. 

  2225.     uint8_t *p_transfer;
    2226. 

  2226. #if defined( __ATMO_DEBUG__ )
    2227. 

  2227.     /* for debug out only used*/
    2228. 

  2228.     char sz_filename[MAX_PATH];
    2229. 

  2229. #endif
    2230. 

  2230. 

  2231.     /*
    2232. 

  2232.     Lock the before created VarArray (AtmoCreateTransferBuffers)
    2233. 

  2233.     inside my wrapper library and give me a pointer to the buffer!
    2234. 

  2234.     below linux a global buffer may be used and protected with a mutex?
    2235. 

  2235.     */
    2236. 

  2236.     p_transfer = AtmoLockTransferBuffer(p_filter);
    2237. 

  2237.     if(p_transfer == NULL)
    2238. 

  2238.     {
    2239. 

  2239.         msg_Err( p_filter, "AtmoLight no transferbuffer available. "\
    2240. 

  2240.                            "AtmoLight will be disabled!");
    2241. 

  2241.         p_sys->b_enabled = false;
    2242. 

  2242.         return;
    2243. 

  2243.     }
    2244. 

  2244. 

  2245.     /*
    2246. 

  2246.     do the call via pointer to function instead of having a
    2247. 

  2247.     case structure here
    2248. 

  2248.     */
    2249. 

  2249.     p_sys->pf_extract_mini_image(p_sys, p_inpic, p_transfer);
    2250. 

  2250. 

  2251. 

  2252. #if defined( __ATMO_DEBUG__ )
    2253. 

  2253.     /*
    2254. 

  2254.     if debugging enabled save every 128th image to disk
    2255. 

  2255.     */
    2256. 

  2256.     if((p_sys->b_saveframes == true) && (p_sys->sz_framepath[0] != 0 ))
    2257. 

  2257.     {
    2258. 

  2258. 

  2259.         if((p_sys->ui_frame_counter & 127) == 0)
    2260. 

  2260.         {
    2261. 

  2261.             sprintf(sz_filename,"%satmo_dbg_%06u.bmp",p_sys->sz_framepath,
    2262. 

  2262.                 p_sys->ui_frame_counter);
    2263. 

  2263.             msg_Dbg(p_filter, "SaveFrame %s",sz_filename);
    2264. 

  2264. 

  2265.             SaveBitmap(p_sys, p_transfer, sz_filename);
    2266. 

  2266.         }
    2267. 

  2267.     }
    2268. 

  2268. 

  2269.     msg_Dbg( p_filter, "AtmoFrame %u Time: %d ms", p_sys->ui_frame_counter,
    2270. 

  2270.                 mdate() / 1000);
    2271. 

  2271.     p_sys->ui_frame_counter++;
    2272. 

  2272. #endif
    2273. 

  2273. 

  2274.     p_sys->i_frames_processed++;
    2275. 

  2275. 

  2276. 

  2277.     /* show the colors on the wall */
    2278. 

  2278.     AtmoSendPixelData( p_filter );
    2279. 

  2279. }
    2280. 

  2280. 

  2281. 

  2282. 

  2283. 

  2284. /*****************************************************************************
    2285. 

  2285. * Filter: calls the extract method and forwards the incomming picture 1:1
    2286. 

  2286. *****************************************************************************
    2287. 

  2287. *
    2288. 

  2288. *****************************************************************************/
    2289. 

  2289. 

  2290. static picture_t * Filter( filter_t *p_filter, picture_t *p_pic )
    2291. 

  2291. {
    2292. 

  2292.     filter_sys_t *p_sys = p_filter->p_sys;
    2293. 

  2293.     if( !p_pic ) return NULL;
    2294. 

  2294.     
    2295. 

  2295.     picture_t *p_outpic = filter_NewPicture( p_filter );
    2296. 

  2296.     if( !p_outpic )
    2297. 

  2297.     {
    2298. 

  2298.         picture_Release( p_pic );
    2299. 

  2299.         return NULL;
    2300. 

  2300.     }
    2301. 

  2301.     picture_CopyPixels( p_outpic, p_pic );
    2302. 

  2302.     
    2303. 

  2303.     vlc_mutex_lock( &p_sys->filter_lock );
    2304. 

  2304. 

  2305.     if((p_sys->b_enabled == true) &&
    2306. 

  2306.         (p_sys->pf_extract_mini_image != NULL) &&
    2307. 

  2307.         (p_sys->b_pause_live == false))
    2308. 

  2308.     {
    2309. 

  2309.         p_sys->i_crop_x_offset  = p_filter->fmt_in.video.i_x_offset;
    2310. 

  2310.         p_sys->i_crop_y_offset  = p_filter->fmt_in.video.i_y_offset;
    2311. 

  2311.         p_sys->i_crop_width     = p_filter->fmt_in.video.i_visible_width;
    2312. 

  2312.         p_sys->i_crop_height    = p_filter->fmt_in.video.i_visible_height;
    2313. 

  2313. 

  2314.         CreateMiniImage(p_filter, p_outpic);
    2315. 

  2315.     }
    2316. 

  2316. 

  2317.     vlc_mutex_unlock( &p_sys->filter_lock );
    2318. 

  2318. 

  2319. 

  2320.     return CopyInfoAndRelease( p_outpic, p_pic );
    2321. 

  2321. }
    2322. 

  2322. 

  2323. 

  2324. /*****************************************************************************
    2325. 

  2325. * FadeToColorThread: Threadmethod which changes slowly the color
    2326. 

  2326. * to a target color defined in p_fadethread struct
    2327. 

  2327. * use for: Fade to Pause Color,  and Fade to End Color
    2328. 

  2328. *****************************************************************************/
    2329. 

  2329. static void *FadeToColorThread(vlc_object_t *obj)
    2330. 

  2330. {
    2331. 

  2331.     fadethread_t *p_fadethread = (fadethread_t *)obj;
    2332. 

  2332.     filter_sys_t *p_sys = (filter_sys_t *)p_fadethread->p_filter->p_sys;
    2333. 

  2333.     int i_steps_done = 0;
    2334. 

  2334.     int i_index;
    2335. 

  2335.     int i_pause_red;
    2336. 

  2336.     int i_pause_green;
    2337. 

  2337.     int i_pause_blue;
    2338. 

  2338. 

  2339.     int i_src_red;
    2340. 

  2340.     int i_src_green;
    2341. 

  2341.     int i_src_blue;
    2342. 

  2342. 

  2343.     uint8_t *p_source = NULL;
    2344. 

  2344. 

  2345.     int canc = vlc_savecancel ();
    2346. 

  2346.     /* initialize AtmoWin for this thread! */
    2347. 

  2347.     AtmoInitialize(p_fadethread->p_filter , true);
    2348. 

  2348. 

  2349.     uint8_t *p_transfer = AtmoLockTransferBuffer( p_fadethread->p_filter );
    2350. 

  2350.     if(p_transfer != NULL) {
    2351. 

  2351.         /* safe colors as "32bit" Integers to avoid overflows*/
    2352. 

  2352.         i_pause_red   = p_fadethread->ui_red;
    2353. 

  2353.         i_pause_blue  = p_fadethread->ui_blue;
    2354. 

  2354.         i_pause_green = p_fadethread->ui_green;
    2355. 

  2355. 

  2356.         /*
    2357. 

  2357.         allocate a temporary buffer for the last send
    2358. 

  2358.         image size less then 15kb
    2359. 

  2359.         */
    2360. 

  2360.         int i_size = 4 * p_sys->i_atmo_width * p_sys->i_atmo_height;
    2361. 

  2361.         p_source = (uint8_t *)malloc( i_size );
    2362. 

  2362.         if(p_source != NULL)
    2363. 

  2363.         {
    2364. 

  2364.             /*
    2365. 

  2365.             get a copy of the last transfered image as orign for the
    2366. 

  2366.             fading steps...
    2367. 

  2367.             */
    2368. 

  2368.             memcpy(p_source, p_transfer, i_size);
    2369. 

  2369.             /* send the same pixel data again... to unlock the buffer! */
    2370. 

  2370.             AtmoSendPixelData( p_fadethread->p_filter );
    2371. 

  2371. 

  2372.             while( (vlc_object_alive (p_fadethread)) &&
    2373. 

  2373.                 (i_steps_done < p_fadethread->i_steps))
    2374. 

  2374.             {
    2375. 

  2375.                 p_transfer = AtmoLockTransferBuffer( p_fadethread->p_filter );
    2376. 

  2376.                 if(!p_transfer) break; /* should not happen if it worked
    2377. 

  2377.                                        one time in the code above! */
    2378. 

  2378.                 i_steps_done++;
    2379. 

  2379.                 /*
    2380. 

  2380.                 move all pixels in the mini image (64x48) one step closer to
    2381. 

  2381.                 the desired color these loop takes the most time of this
    2382. 

  2382.                 thread improvements wellcome!
    2383. 

  2383.                 */
    2384. 

  2384.                 for(i_index = 0;
    2385. 

  2385.                     (i_index < i_size) && (vlc_object_alive (p_fadethread));
    2386. 

  2386.                     i_index+=4)
    2387. 

  2387.                 {
    2388. 

  2388.                     i_src_blue  = p_source[i_index+0];
    2389. 

  2389.                     i_src_green = p_source[i_index+1];
    2390. 

  2390.                     i_src_red   = p_source[i_index+2];
    2391. 

  2391.                     p_transfer[i_index+0] = (uint8_t) (((
    2392. 

  2392.                         (i_pause_blue  - i_src_blue)
    2393. 

  2393.                         * i_steps_done)/p_fadethread->i_steps)
    2394. 

  2394.                         + i_src_blue);
    2395. 

  2395. 

  2396.                     p_transfer[i_index+1] = (uint8_t) (((
    2397. 

  2397.                         (i_pause_green - i_src_green)
    2398. 

  2398.                         * i_steps_done)/p_fadethread->i_steps)
    2399. 

  2399.                         + i_src_green);
    2400. 

  2400. 

  2401.                     p_transfer[i_index+2] = (uint8_t) (((
    2402. 

  2402.                         (i_pause_red   - i_src_red)
    2403. 

  2403.                         * i_steps_done)/p_fadethread->i_steps)
    2404. 

  2404.                         + i_src_red);
    2405. 

  2405.                 }
    2406. 

  2406. 

  2407.                 /* send image to lightcontroller */
    2408. 

  2408.                 AtmoSendPixelData( p_fadethread->p_filter );
    2409. 

  2409.                 /* is there something like and interruptable sleep inside
    2410. 

  2410.                 the VLC libaries? inside native win32 I would use an Event
    2411. 

  2411.                 (CreateEvent) and here an WaitForSingleObject?
    2412. 

  2412.                 */
    2413. 

  2413.                 msleep(40000);
    2414. 

  2414.             }
    2415. 

  2415.             free(p_source);
    2416. 

  2416.         } else {
    2417. 

  2417.             /* in failure of malloc also unlock buffer  */
    2418. 

  2418.             AtmoSendPixelData(p_fadethread->p_filter);
    2419. 

  2419.         }
    2420. 

  2420.     }
    2421. 

  2421.     /* call indirect to OleUnitialize() for this thread */
    2422. 

  2422.     AtmoFinalize(p_fadethread->p_filter, 0);
    2423. 

  2423.     vlc_restorecancel (canc);
    2424. 

  2424.     return NULL;
    2425. 

  2425. }
    2426. 

  2426. 

  2427. /*****************************************************************************
    2428. 

  2428. * CheckAndStopFadeThread: if there is a fadethread structure left, or running.
    2429. 

  2429. ******************************************************************************
    2430. 

  2430. * this function will stop the thread ... and waits for its termination
    2431. 

  2431. * before removeing the objects from vout_sys_t ...
    2432. 

  2432. ******************************************************************************/
    2433. 

  2433. static void CheckAndStopFadeThread(filter_t *p_filter)
    2434. 

  2434. {
    2435. 

  2435.     filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys;
    2436. 

  2436.     vlc_mutex_lock( &p_sys->filter_lock );
    2437. 

  2437.     if(p_sys->p_fadethread != NULL)
    2438. 

  2438.     {
    2439. 

  2439.         msg_Dbg(p_filter, "kill still running fadeing thread...");
    2440. 

  2440. 

  2441.         p_sys->p_fadethread->b_die = true;
    2442. 

  2442. 

  2443.         vlc_thread_join(p_sys->p_fadethread);
    2444. 

  2444. 

  2445.         vlc_object_release(p_sys->p_fadethread);
    2446. 

  2446.         p_sys->p_fadethread = NULL;
    2447. 

  2447.     }
    2448. 

  2448.     vlc_mutex_unlock( &p_sys->filter_lock );
    2449. 

  2449. }
    2450. 

  2450. 

  2451. /*****************************************************************************
    2452. 

  2452. * StateCallback: Callback for the inputs variable "State" to get notified
    2453. 

  2453. * about Pause and Continue Playback events.
    2454. 

  2454. *****************************************************************************/
    2455. 

  2455. static int StateCallback( vlc_object_t *p_this, char const *psz_cmd,
    2456. 

  2456.                          vlc_value_t oldval, vlc_value_t newval,
    2457. 

  2457.                          void *p_data )
    2458. 

  2458. {
    2459. 

  2459.     filter_t *p_filter = (filter_t *)p_data;
    2460. 

  2460.     filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys;
    2461. 

  2461. 

  2462.     if((p_sys->b_usepausecolor == true) && (p_sys->b_enabled == true))
    2463. 

  2463.     {
    2464. 

  2464.         msg_Dbg(p_filter, "state change from: %"PRId64" to %"PRId64, oldval.i_int,
    2465. 

  2465.             newval.i_int);
    2466. 

  2466. 

  2467.         if((newval.i_int == PAUSE_S) && (oldval.i_int == PLAYING_S))
    2468. 

  2468.         {
    2469. 

  2469.             /* tell the other thread to stop sending images to light
    2470. 

  2470.                controller */
    2471. 

  2471.             p_sys->b_pause_live = true;
    2472. 

  2472. 

  2473.             // clean up old thread - should not happen....
    2474. 

  2474.             CheckAndStopFadeThread( p_filter );
    2475. 

  2475. 

  2476.             // perpare spawn fadeing thread
    2477. 

  2477.             vlc_mutex_lock( &p_sys->filter_lock );
    2478. 

  2478.             /*
    2479. 

  2479.             launch only a new thread if there is none active!
    2480. 

  2480.             or waiting for cleanup
    2481. 

  2481.             */
    2482. 

  2482.             if(p_sys->p_fadethread == NULL)
    2483. 

  2483.             {
    2484. 

  2484.                 p_sys->p_fadethread = (fadethread_t *)vlc_object_create(
    2485. 

  2485.                      p_filter,
    2486. 

  2486.                      sizeof(fadethread_t) );
    2487. 

  2487. 

  2488.                 p_sys->p_fadethread->p_filter = p_filter;
    2489. 

  2489.                 p_sys->p_fadethread->ui_red   = p_sys->ui_pausecolor_red;
    2490. 

  2490.                 p_sys->p_fadethread->ui_green = p_sys->ui_pausecolor_green;
    2491. 

  2491.                 p_sys->p_fadethread->ui_blue  = p_sys->ui_pausecolor_blue;
    2492. 

  2492.                 p_sys->p_fadethread->i_steps  = p_sys->i_fadesteps;
    2493. 

  2493. 

  2494.                 if( vlc_thread_create( p_sys->p_fadethread,
    2495. 

  2495.                     "AtmoLight fadeing",
    2496. 

  2496.                     FadeToColorThread,
    2497. 

  2497.                     VLC_THREAD_PRIORITY_LOW ) )
    2498. 

  2498.                 {
    2499. 

  2499.                     msg_Err( p_filter, "cannot create FadeToColorThread" );
    2500. 

  2500.                     vlc_object_release( p_sys->p_fadethread );
    2501. 

  2501.                     p_sys->p_fadethread = NULL;
    2502. 

  2502.                 }
    2503. 

  2503.             }
    2504. 

  2504.             vlc_mutex_unlock( &p_sys->filter_lock );
    2505. 

  2505.         }
    2506. 

  2506. 

  2507.         if((newval.i_int == PLAYING_S) && (oldval.i_int == PAUSE_S))
    2508. 

  2508.         {
    2509. 

  2509.             /* playback continues check thread state */
    2510. 

  2510.             CheckAndStopFadeThread( p_filter );
    2511. 

  2511.             /* reactivate the Render function... to do its normal work */
    2512. 

  2512.             p_sys->b_pause_live = false;
    2513. 

  2513.         }
    2514. 

  2514.     }
    2515. 

  2515. 

  2516.     return VLC_SUCCESS;
    2517. 

  2517. }
    2518. 

  2518. 

  2519. /*****************************************************************************
    2520. 

  2520. * AddPlaylistInputThreadStateCallback: Setup call back on "State" Variable
    2521. 

  2521. *****************************************************************************
    2522. 

  2522. * Add Callback function to the "state" variable of the input thread..
    2523. 

  2523. * first find the PlayList and get the input thread from there to attach
    2524. 

  2524. * my callback?
    2525. 

  2525. *****************************************************************************/
    2526. 

  2526. static void AddStateVariableCallback(filter_t *p_filter)
    2527. 

  2527. {
    2528. 

  2528.     input_thread_t *p_input = playlist_CurrentInput( pl_Get( p_filter ) );
    2529. 

  2529.     if(p_input)
    2530. 

  2530.     {
    2531. 

  2531.         var_AddCallback( p_input, "state", StateCallback, p_filter );
    2532. 

  2532.         vlc_object_release( p_input );
    2533. 

  2533.     }
    2534. 

  2534. }
    2535. 

  2535. 

  2536. /*****************************************************************************
    2537. 

  2537. * DelPlaylistInputThreadStateCallback: Remove call back on "State" Variable
    2538. 

  2538. *****************************************************************************
    2539. 

  2539. * Delete the callback function to the "state" variable of the input thread...
    2540. 

  2540. * first find the PlayList and get the input thread from there to attach
    2541. 

  2541. * my callback? is vlc_object_find the right way for this??
    2542. 

  2542. *****************************************************************************/
    2543. 

  2543. static void DelStateVariableCallback( filter_t *p_filter )
    2544. 

  2544. {
    2545. 

  2545.     input_thread_t *p_input = playlist_CurrentInput( pl_Get ( p_filter ) );
    2546. 

  2546.     if(p_input)
    2547. 

  2547.     {
    2548. 

  2548.         var_DelCallback( p_input, "state", StateCallback, p_filter );
    2549. 

  2549.         vlc_object_release( p_input );
    2550. 

  2550.     }
    2551. 

  2551. }
    2552. 

  2552. 

  2553. /****************************************************************************
    2554. 

  2554. * StateCallback: Callback for the inputs variable "State" to get notified
    2555. 

  2555. * about Pause and Continue Playback events.
    2556. 

  2556. *****************************************************************************/
    2557. 

  2557. static int AtmoSettingsCallback( vlc_object_t *p_this, char const *psz_var,
    2558. 

  2558.                                  vlc_value_t oldval, vlc_value_t newval,
    2559. 

  2559.                                  void *p_data )
    2560. 

  2560. {
    2561. 

  2561.     filter_t *p_filter = (filter_t *)p_data;
    2562. 

  2562.     filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys;
    2563. 

  2563. 

  2564.     vlc_mutex_lock( &p_sys->filter_lock );
    2565. 

  2565. 

  2566.     if( !strcmp( psz_var, CFG_PREFIX "showdots" ))
    2567. 

  2567.     {
    2568. 

  2568.         p_sys->b_show_dots = newval.b_bool;
    2569. 

  2569.     }
    2570. 

  2570. 

  2571.     CAtmoConfig *p_atmo_config = p_sys->p_atmo_config;
    2572. 

  2572.     if(p_atmo_config)
    2573. 

  2573.     {
    2574. 

  2574. 

  2575.        msg_Dbg(p_filter, "apply AtmoSettingsCallback %s (int: %"PRId64" -> %"PRId64")",
    2576. 

  2576.              psz_var,
    2577. 

  2577.              oldval.i_int,
    2578. 

  2578.              newval.i_int
    2579. 

  2579.        );
    2580. 

  2580. 

  2581.         if( !strcmp( psz_var, CFG_PREFIX "filtermode" ))
    2582. 

  2582.             p_atmo_config->setLiveViewFilterMode( (AtmoFilterMode)newval.i_int);
    2583. 

  2583. 

  2584.         else if( !strcmp( psz_var, CFG_PREFIX "percentnew" ))
    2585. 

  2585.                  p_atmo_config->setLiveViewFilter_PercentNew( newval.i_int );
    2586. 

  2586. 

  2587.         else if( !strcmp( psz_var, CFG_PREFIX "meanlength" ))
    2588. 

  2588.                  p_atmo_config->setLiveViewFilter_MeanLength( newval.i_int );
    2589. 

  2589. 

  2590.         else if( !strcmp( psz_var, CFG_PREFIX "meanthreshold" ))
    2591. 

  2591.                  p_atmo_config->setLiveViewFilter_MeanThreshold( newval.i_int );
    2592. 

  2592. 

  2593.         else if( !strcmp( psz_var, CFG_PREFIX "edgeweightning" ))
    2594. 

  2594.                  p_atmo_config->setLiveView_EdgeWeighting( newval.i_int );
    2595. 

  2595. 

  2596.         else if( !strcmp( psz_var, CFG_PREFIX "brightness" ))
    2597. 

  2597.                  p_atmo_config->setLiveView_BrightCorrect( newval.i_int );
    2598. 

  2598. 

  2599.         else if( !strcmp( psz_var, CFG_PREFIX "darknesslimit" ))
    2600. 

  2600.                  p_atmo_config->setLiveView_DarknessLimit( newval.i_int );
    2601. 

  2601. 

  2602.         else if( !strcmp( psz_var, CFG_PREFIX "huewinsize" ))
    2603. 

  2603.                  p_atmo_config->setLiveView_HueWinSize( newval.i_int );
    2604. 

  2604. 

  2605.         else if( !strcmp( psz_var, CFG_PREFIX "satwinsize" ))
    2606. 

  2606.                  p_atmo_config->setLiveView_SatWinSize( newval.i_int );
    2607. 

  2607. 

  2608.         else if( !strcmp( psz_var, CFG_PREFIX "framedelay" ))
    2609. 

  2609.                  p_atmo_config->setLiveView_FrameDelay( newval.i_int );
    2610. 

  2610. 

  2611.         else if( !strcmp( psz_var, CFG_PREFIX "whiteadj" ))
    2612. 

  2612.                  p_atmo_config->setUseSoftwareWhiteAdj( newval.b_bool );
    2613. 

  2613. 

  2614.         else if( !strcmp( psz_var, CFG_PREFIX "white-red" ))
    2615. 

  2615.                  p_atmo_config->setWhiteAdjustment_Red( newval.i_int );
    2616. 

  2616. 

  2617.         else if( !strcmp( psz_var, CFG_PREFIX "white-green" ))
    2618. 

  2618.                  p_atmo_config->setWhiteAdjustment_Green( newval.i_int );
    2619. 

  2619. 

  2620.         else if( !strcmp( psz_var, CFG_PREFIX "white-blue" ))
    2621. 

  2621.                  p_atmo_config->setWhiteAdjustment_Blue( newval.i_int );
    2622. 

  2622. 

  2623.     }
    2624. 

  2624. 

  2625.     vlc_mutex_unlock( &p_sys->filter_lock );
    2626. 

  2626. 

  2627.     return VLC_SUCCESS;
    2628. 

  2628. }
    2629. 

  2629. 

  2630. static void AddAtmoSettingsVariablesCallbacks(filter_t *p_filter)
    2631. 

  2631. {
    2632. 

  2632.    var_AddCallback( p_filter, CFG_PREFIX "filtermode",
    2633. 

  2633.                     AtmoSettingsCallback, p_filter );
    2634. 

  2634.    var_AddCallback( p_filter, CFG_PREFIX "percentnew",
    2635. 

  2635.                     AtmoSettingsCallback, p_filter );
    2636. 

  2636. 

  2637. 

  2638.    var_AddCallback( p_filter, CFG_PREFIX "meanlength",
    2639. 

  2639.                     AtmoSettingsCallback, p_filter );
    2640. 

  2640.    var_AddCallback( p_filter, CFG_PREFIX "meanthreshold",
    2641. 

  2641.                     AtmoSettingsCallback, p_filter );
    2642. 

  2642. 

  2643.    var_AddCallback( p_filter, CFG_PREFIX "edgeweightning",
    2644. 

  2644.                     AtmoSettingsCallback, p_filter );
    2645. 

  2645.    var_AddCallback( p_filter, CFG_PREFIX "brightness",
    2646. 

  2646.                     AtmoSettingsCallback, p_filter );
    2647. 

  2647.    var_AddCallback( p_filter, CFG_PREFIX "darknesslimit",
    2648. 

  2648.                     AtmoSettingsCallback, p_filter );
    2649. 

  2649. 

  2650.    var_AddCallback( p_filter, CFG_PREFIX "huewinsize",
    2651. 

  2651.                     AtmoSettingsCallback, p_filter );
    2652. 

  2652.    var_AddCallback( p_filter, CFG_PREFIX "satwinsize",
    2653. 

  2653.                     AtmoSettingsCallback, p_filter );
    2654. 

  2654.    var_AddCallback( p_filter, CFG_PREFIX "framedelay",
    2655. 

  2655.                     AtmoSettingsCallback, p_filter );
    2656. 

  2656. 

  2657. 

  2658.    var_AddCallback( p_filter, CFG_PREFIX "whiteadj",
    2659. 

  2659.                     AtmoSettingsCallback, p_filter );
    2660. 

  2660.    var_AddCallback( p_filter, CFG_PREFIX "white-red",
    2661. 

  2661.                     AtmoSettingsCallback, p_filter );
    2662. 

  2662.    var_AddCallback( p_filter, CFG_PREFIX "white-green",
    2663. 

  2663.                     AtmoSettingsCallback, p_filter );
    2664. 

  2664.    var_AddCallback( p_filter, CFG_PREFIX "white-blue",
    2665. 

  2665.                     AtmoSettingsCallback, p_filter );
    2666. 

  2666. 

  2667.    var_AddCallback( p_filter, CFG_PREFIX "showdots",
    2668. 

  2668.                     AtmoSettingsCallback, p_filter );
    2669. 

  2669. 

  2670. }
    2671. 

  2671. 

  2672. static void DelAtmoSettingsVariablesCallbacks( filter_t *p_filter )
    2673. 

  2673. {
    2674. 

  2674. 

  2675.    var_DelCallback( p_filter, CFG_PREFIX "filtermode",
    2676. 

  2676.                     AtmoSettingsCallback, p_filter );
    2677. 

  2677. 

  2678.    var_DelCallback( p_filter, CFG_PREFIX "percentnew",
    2679. 

  2679.                     AtmoSettingsCallback, p_filter );
    2680. 

  2680.    var_DelCallback( p_filter, CFG_PREFIX "meanlength",
    2681. 

  2681.                     AtmoSettingsCallback, p_filter );
    2682. 

  2682.    var_DelCallback( p_filter, CFG_PREFIX "meanthreshold",
    2683. 

  2683.                     AtmoSettingsCallback, p_filter );
    2684. 

  2684. 

  2685.    var_DelCallback( p_filter, CFG_PREFIX "edgeweightning",
    2686. 

  2686.                     AtmoSettingsCallback, p_filter );
    2687. 

  2687.    var_DelCallback( p_filter, CFG_PREFIX "brightness",
    2688. 

  2688.                     AtmoSettingsCallback, p_filter );
    2689. 

  2689.    var_DelCallback( p_filter, CFG_PREFIX "darknesslimit",
    2690. 

  2690.                     AtmoSettingsCallback, p_filter );
    2691. 

  2691. 

  2692.    var_DelCallback( p_filter, CFG_PREFIX "huewinsize",
    2693. 

  2693.                     AtmoSettingsCallback, p_filter );
    2694. 

  2694.    var_DelCallback( p_filter, CFG_PREFIX "satwinsize",
    2695. 

  2695.                     AtmoSettingsCallback, p_filter );
    2696. 

  2696.    var_DelCallback( p_filter, CFG_PREFIX "framedelay",
    2697. 

  2697.                     AtmoSettingsCallback, p_filter );
    2698. 

  2698. 

  2699. 

  2700.    var_DelCallback( p_filter, CFG_PREFIX "whiteadj",
    2701. 

  2701.                     AtmoSettingsCallback, p_filter );
    2702. 

  2702.    var_DelCallback( p_filter, CFG_PREFIX "white-red",
    2703. 

  2703.                     AtmoSettingsCallback, p_filter );
    2704. 

  2704.    var_DelCallback( p_filter, CFG_PREFIX "white-green",
    2705. 

  2705.                     AtmoSettingsCallback, p_filter );
    2706. 

  2706.    var_DelCallback( p_filter, CFG_PREFIX "white-blue",
    2707. 

  2707.                     AtmoSettingsCallback, p_filter );
    2708. 

  2708. 

  2709.    var_DelCallback( p_filter, CFG_PREFIX "showdots",
    2710. 

  2710.                     AtmoSettingsCallback, p_filter );
    2711. 

  2711. 

  2712. }
    2713. 

  2713. 

  2714. 

  2715. #if defined(__ATMO_DEBUG__)
    2716. 

  2716. static void atmo_parse_crop(char *psz_cropconfig,
    2717. 

  2717.                             video_format_t fmt_in,
    2718. 

  2718.                             video_format_t fmt_render,
    2719. 

  2719.                             int &i_visible_width, int &i_visible_height,
    2720. 

  2720.                             int &i_x_offset, int &i_y_offset )
    2721. 

  2721. {
    2722. 

  2722.     int64_t i_aspect_num, i_aspect_den;
    2723. 

  2723.     unsigned int i_width, i_height;
    2724. 

  2724. 

  2725.     i_visible_width  = fmt_in.i_visible_width;
    2726. 

  2726.     i_visible_height = fmt_in.i_visible_height;
    2727. 

  2727.     i_x_offset       = fmt_in.i_x_offset;
    2728. 

  2728.     i_y_offset       = fmt_in.i_y_offset;
    2729. 

  2729. 

  2730.     char *psz_end = NULL, *psz_parser = strchr( psz_cropconfig, ':' );
    2731. 

  2731.     if( psz_parser )
    2732. 

  2732.     {
    2733. 

  2733.         /* We're using the 3:4 syntax */
    2734. 

  2734.         i_aspect_num = strtol( psz_cropconfig, &psz_end, 10 );
    2735. 

  2735.         if( psz_end == psz_cropconfig || !i_aspect_num ) return;
    2736. 

  2736. 

  2737.         i_aspect_den = strtol( ++psz_parser, &psz_end, 10 );
    2738. 

  2738.         if( psz_end == psz_parser || !i_aspect_den ) return;
    2739. 

  2739. 

  2740.         i_width = fmt_in.i_sar_den * fmt_render.i_visible_height *
    2741. 

  2741.             i_aspect_num / i_aspect_den / fmt_in.i_sar_num;
    2742. 

  2742. 

  2743.         i_height = fmt_render.i_visible_width*fmt_in.i_sar_num *
    2744. 

  2744.             i_aspect_den / i_aspect_num / fmt_in.i_sar_den;
    2745. 

  2745. 

  2746.         if( i_width < fmt_render.i_visible_width )
    2747. 

  2747.         {
    2748. 

  2748.             i_x_offset = fmt_render.i_x_offset +
    2749. 

  2749.                 (fmt_render.i_visible_width - i_width) / 2;
    2750. 

  2750.             i_visible_width = i_width;
    2751. 

  2751.         }
    2752. 

  2752.         else
    2753. 

  2753.         {
    2754. 

  2754.             i_y_offset = fmt_render.i_y_offset +
    2755. 

  2755.                 (fmt_render.i_visible_height - i_height) / 2;
    2756. 

  2756.             i_visible_height = i_height;
    2757. 

  2757.         }
    2758. 

  2758.     }
    2759. 

  2759.     else
    2760. 

  2760.     {
    2761. 

  2761.         psz_parser = strchr( psz_cropconfig, 'x' );
    2762. 

  2762.         if( psz_parser )
    2763. 

  2763.         {
    2764. 

  2764.             /* Maybe we're using the <width>x<height>+<left>+<top> syntax */
    2765. 

  2765.             unsigned int i_crop_width, i_crop_height, i_crop_top, i_crop_left;
    2766. 

  2766. 

  2767.             i_crop_width = strtol( psz_cropconfig, &psz_end, 10 );
    2768. 

  2768.             if( psz_end != psz_parser ) return;
    2769. 

  2769. 

  2770.             psz_parser = strchr( ++psz_end, '+' );
    2771. 

  2771.             i_crop_height = strtol( psz_end, &psz_end, 10 );
    2772. 

  2772.             if( psz_end != psz_parser ) return;
    2773. 

  2773. 

  2774.             psz_parser = strchr( ++psz_end, '+' );
    2775. 

  2775.             i_crop_left = strtol( psz_end, &psz_end, 10 );
    2776. 

  2776.             if( psz_end != psz_parser ) return;
    2777. 

  2777. 

  2778.             psz_end++;
    2779. 

  2779.             i_crop_top = strtol( psz_end, &psz_end, 10 );
    2780. 

  2780.             if( *psz_end != '\0' ) return;
    2781. 

  2781. 

  2782.             i_width = i_crop_width;
    2783. 

  2783.             i_visible_width = i_width;
    2784. 

  2784. 

  2785.             i_height = i_crop_height;
    2786. 

  2786.             i_visible_height = i_height;
    2787. 

  2787. 

  2788.             i_x_offset = i_crop_left;
    2789. 

  2789.             i_y_offset = i_crop_top;
    2790. 

  2790.         }
    2791. 

  2791.         else
    2792. 

  2792.         {
    2793. 

  2793.             /* Maybe we're using the <left>+<top>+<right>+<bottom> syntax */
    2794. 

  2794.             unsigned int i_crop_top, i_crop_left, i_crop_bottom, i_crop_right;
    2795. 

  2795. 

  2796.             psz_parser = strchr( psz_cropconfig, '+' );
    2797. 

  2797.             i_crop_left = strtol( psz_cropconfig, &psz_end, 10 );
    2798. 

  2798.             if( psz_end != psz_parser ) return;
    2799. 

  2799. 

  2800.             psz_parser = strchr( ++psz_end, '+' );
    2801. 

  2801.             i_crop_top = strtol( psz_end, &psz_end, 10 );
    2802. 

  2802.             if( psz_end != psz_parser ) return;
    2803. 

  2803. 

  2804.             psz_parser = strchr( ++psz_end, '+' );
    2805. 

  2805.             i_crop_right = strtol( psz_end, &psz_end, 10 );
    2806. 

  2806.             if( psz_end != psz_parser ) return;
    2807. 

  2807. 

  2808.             psz_end++;
    2809. 

  2809.             i_crop_bottom = strtol( psz_end, &psz_end, 10 );
    2810. 

  2810.             if( *psz_end != '\0' ) return;
    2811. 

  2811. 

  2812.             i_width = fmt_render.i_visible_width -
    2813. 

  2813.                         i_crop_left -
    2814. 

  2814.                         i_crop_right;
    2815. 

  2815.             i_visible_width = i_width;
    2816. 

  2816. 

  2817.             i_height = fmt_render.i_visible_height -
    2818. 

  2818.                         i_crop_top -
    2819. 

  2819.                         i_crop_bottom;
    2820. 

  2820.             i_visible_height = i_height;
    2821. 

  2821. 

  2822.             i_x_offset = i_crop_left;
    2823. 

  2823.             i_y_offset = i_crop_top;
    2824. 

  2824.         }
    2825. 

  2825.     }
    2826. 

  2826. }
    2827. 

  2827. #endif
    2828. 

  2828.