init vars for coverity (mame/video/a-m)

src/mame/video/abc1600.h

@@ -110,31 +110,31 @@ private:
 	required_region_ptr<uint8_t> m_shinf_rom;
 	required_region_ptr<uint16_t> m_drmsk_rom;
 
-	int m_endisp;               // enable display
+	int m_endisp = 0;               // enable display
-	int m_clocks_disabled;      // clocks disabled
+	int m_clocks_disabled = 0;      // clocks disabled
-	uint16_t m_gmdi;              // video RAM data latch
+	uint16_t m_gmdi = 0;              // video RAM data latch
-	uint16_t m_wrm;               // write mask latch
+	uint16_t m_wrm = 0;               // write mask latch
-	uint8_t m_ms[16];             // mover sequence control
+	uint8_t m_ms[16]{};             // mover sequence control
-	uint8_t m_ds[16];             // display sequence control
+	uint8_t m_ds[16]{};             // display sequence control
-	uint8_t m_flag;               // flags
+	uint8_t m_flag = 0;               // flags
-	uint16_t m_xsize;             // X size
+	uint16_t m_xsize = 0;             // X size
-	uint16_t m_ysize;             // Y size
+	uint16_t m_ysize = 0;             // Y size
-	int m_udx;                  // up/down X
+	int m_udx = 0;                  // up/down X
-	int m_udy;                  // up/down Y
+	int m_udy = 0;                  // up/down Y
-	uint16_t m_xfrom;             // X from
+	uint16_t m_xfrom = 0;             // X from
-	uint16_t m_xto;               // X to
+	uint16_t m_xto = 0;               // X to
-	uint16_t m_yto;               // Y to
+	uint16_t m_yto = 0;               // Y to
-	uint16_t m_ty;                // to Y
+	uint16_t m_ty = 0;                // to Y
-	uint32_t m_mfa;               // mover from address
+	uint32_t m_mfa = 0;               // mover from address
-	uint32_t m_mta;               // mover to address
+	uint32_t m_mta = 0;               // mover to address
-	uint8_t m_sh;                 //
+	uint8_t m_sh = 0;                 //
-	uint16_t m_mdor;              //
+	uint16_t m_mdor = 0;              //
-	int m_hold_1w_cyk;          //
+	int m_hold_1w_cyk = 0;          //
-	int m_wrms0;                //
+	int m_wrms0 = 0;                //
-	int m_wrms1;                //
+	int m_wrms1 = 0;                //
-	int m_rmc;                  // row match count
+	int m_rmc = 0;                  // row match count
-	int m_cmc;                  // column match count
+	int m_cmc = 0;                  // column match count
-	int m_amm;                  // active mover mask
+	int m_amm = 0;                  // active mover mask
 };
 
 

src/mame/video/agat9.h

@@ -38,10 +38,10 @@ public:
 	uint8_t apple_read(offs_t offset);
 	void apple_write(offs_t offset, uint8_t data);
 
-	bool m_page2;
+	bool m_page2 = false;
-	bool m_flash;
+	bool m_flash = false;
-	bool m_mix;
+	bool m_mix = false;
-	bool m_graphics;
+	bool m_graphics = false;
 	std::unique_ptr<uint16_t[]> m_hires_artifact_map;
 
 protected:
@@ -86,8 +86,8 @@ private:
 		GRAPHICS_MONO_HIRES,
 		APPLE
 	} m_video_mode;
-	int m_mode;
+	int m_mode = 0;
-	int palette_index;
+	int palette_index = 0;
 };
 
 // device type definition

src/mame/video/airraid_dev.h

@@ -49,9 +49,9 @@ private:
 	required_shared_ptr<uint8_t> m_vregs;
 
 	// tilemaps
-	tilemap_t *m_bg_tilemap;
+	tilemap_t *m_bg_tilemap = nullptr;
-	tilemap_t *m_fg_tilemap;
+	tilemap_t *m_fg_tilemap = nullptr;
-	tilemap_t *m_tx_tilemap;
+	tilemap_t *m_tx_tilemap = nullptr;
 
 	TILEMAP_MAPPER_MEMBER(bg_scan);
 	TILEMAP_MAPPER_MEMBER(fg_scan);

src/mame/video/alpha68k_palette.h

@@ -48,7 +48,7 @@ protected:
 	virtual uint32_t palette_entries() const override { return m_entries; }
 private:
 	std::vector<uint16_t> m_paletteram;
-	u32 m_entries;
+	u32 m_entries = 0;
 	void create_rgb_lookups();
 	uint8_t      m_palette_lookup[32][4];
 	inline void set_color_entry(u16 offset, u16 pal_data, int shift);

src/mame/video/apple2.h

@@ -21,27 +21,27 @@ public:
 	// construction/destruction
 	a2_video_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
 
-	bool m_page2;
+	bool m_page2 = false;
-	bool m_flash;
+	bool m_flash = false;
-	bool m_mix;
+	bool m_mix = false;
-	bool m_graphics;
+	bool m_graphics = false;
-	bool m_hires;
+	bool m_hires = false;
-	bool m_dhires;
+	bool m_dhires = false;
-	bool m_80col;
+	bool m_80col = false;
-	bool m_altcharset;
+	bool m_altcharset = false;
-	bool m_an2;
+	bool m_an2 = false;
-	bool m_80store;
+	bool m_80store = false;
-	bool m_monohgr;
+	bool m_monohgr = false;
-	u8 m_GSfg, m_GSbg, m_GSborder, m_newvideo, m_monochrome, m_rgbmode;
+	u8 m_GSfg = 0, m_GSbg = 0, m_GSborder = 0, m_newvideo = 0, m_monochrome = 0, m_rgbmode = 0;
-	u32 m_GSborder_colors[16], m_shr_palette[256];
+	u32 m_GSborder_colors[16]{}, m_shr_palette[256]{};
 	std::unique_ptr<bitmap_ind16> m_8bit_graphics;
 	std::unique_ptr<uint16_t[]> m_hires_artifact_map;
 	std::unique_ptr<uint16_t[]> m_dhires_artifact_map;
 
-	uint8_t *m_ram_ptr, *m_aux_ptr, *m_char_ptr;
+	uint8_t *m_ram_ptr = nullptr, *m_aux_ptr = nullptr, *m_char_ptr = nullptr;
-	int m_char_size;
+	int m_char_size = 0;
 
-	int m_sysconfig;
+	int m_sysconfig = 0;
 
 	DECLARE_WRITE_LINE_MEMBER(txt_w);
 	DECLARE_WRITE_LINE_MEMBER(mix_w);

src/mame/video/atarimo.h

@@ -201,7 +201,7 @@ private:
 	int                     m_slipramsize;        // total size of SLIP RAM, in entries
 
 	// live state
-	emu_timer *             m_force_update_timer;   // timer for forced updating
+	emu_timer *             m_force_update_timer = nullptr;   // timer for forced updating
 	uint32_t                m_bank;               // current bank number
 	uint32_t                m_xscroll;            // xscroll offset
 	uint32_t                m_yscroll;            // yscroll offset

src/mame/video/atarirle.h

@@ -139,10 +139,10 @@ private:
 	void hilite_object(bitmap_ind16 &bitmap, int hilite);
 
 	// derived state
-	int             m_bitmapwidth;        // width of the full playfield bitmap
+	int             m_bitmapwidth = 0;        // width of the full playfield bitmap
-	int             m_bitmapheight;       // height of the full playfield bitmap
+	int             m_bitmapheight = 0;       // height of the full playfield bitmap
-	int             m_bitmapxmask;        // x coordinate mask for the playfield bitmap
+	int             m_bitmapxmask = 0;        // x coordinate mask for the playfield bitmap
-	int             m_bitmapymask;        // y coordinate mask for the playfield bitmap
+	int             m_bitmapymask = 0;        // y coordinate mask for the playfield bitmap
 	rectangle       m_cliprect;           // clipping rectangle
 
 	// masks
@@ -158,22 +158,22 @@ private:
 
 	// ROM information
 	required_region_ptr<u16> m_rombase;    // pointer to the base of the GFX ROM
-	int                 m_objectcount;        // number of objects in the ROM
+	int                 m_objectcount = 0;        // number of objects in the ROM
 	std::vector<object_info> m_info;               // list of info records
 
 	// rendering state
 	bitmap_ind16     m_vram[2][2];         // pointers to VRAM bitmaps and backbuffers
-	int              m_partial_scanline;   // partial update scanline
+	int              m_partial_scanline = 0;   // partial update scanline
 
 	// control state
-	u8               m_control_bits;       // current control bits
+	u8               m_control_bits = 0;       // current control bits
-	u8               m_command;            // current command
+	u8               m_command = 0;            // current command
 	u16              m_checksums[256];     // checksums for each 0x40000 bytes
 	memory_array     m_ram;
 
 	// tables
 	u8               m_rle_bpp[8];
-	u16 *            m_rle_table[8];
+	u16 *            m_rle_table[8]{};
 	u16              m_rle_table_data[0x500];
 };
 

src/mame/video/avgdvg.h

@@ -168,17 +168,17 @@ protected:
 	int avg_common_strobe2();
 	int avg_common_strobe3();
 
-	int m_xmax, m_ymax;
+	int m_xmax = 0, m_ymax = 0;
 
-	u8 m_dvy12;
+	u8 m_dvy12 = 0;
-	u16 m_timer;
+	u16 m_timer = 0;
 
-	u8 m_int_latch;
+	u8 m_int_latch = 0;
-	u8 m_bin_scale;
+	u8 m_bin_scale = 0;
-	u8 m_color;
+	u8 m_color = 0;
 
-	u16 m_xdac_xor;
+	u16 m_xdac_xor = 0;
-	u16 m_ydac_xor;
+	u16 m_ydac_xor = 0;
 };
 
 
@@ -215,11 +215,11 @@ private:
 	required_shared_ptr<u8> m_colorram;
 	required_region_ptr<u8> m_bank_region;
 
-	u8 m_enspkl;
+	u8 m_enspkl = 0;
-	u8 m_spkl_shift;
+	u8 m_spkl_shift = 0;
-	u8 m_map;
+	u8 m_map = 0;
 
-	u16 m_lst;
+	u16 m_lst = 0;
 };
 
 
@@ -270,14 +270,14 @@ protected:
 	virtual int handler_7() override;
 
 private:
-	u16 m_hst;
+	u16 m_hst = 0;
-	u16 m_lst;
+	u16 m_lst = 0;
-	u16 m_izblank;
+	u16 m_izblank = 0;
 
-	s32 m_clipx_min;
+	s32 m_clipx_min = 0;
-	s32 m_clipy_min;
+	s32 m_clipy_min = 0;
-	s32 m_clipx_max;
+	s32 m_clipx_max = 0;
-	s32 m_clipy_max;
+	s32 m_clipy_max = 0;
 };
 
 

src/mame/video/bfm_adr2.h

@@ -47,23 +47,23 @@ protected:
 	virtual void device_add_mconfig(machine_config &config) override;
 
 private:
-	int m_screen_page_reg;              // access/display select
+	int m_screen_page_reg = 0;              // access/display select
-	int m_c101;
+	int m_c101 = 0;
-	int m_rx;
+	int m_rx = 0;
-	bool m_vbl_triggered;               // flag, VBL IRQ triggered
+	bool m_vbl_triggered = 0;               // flag, VBL IRQ triggered
-	bool m_acia_triggered;              // flag, ACIA receive IRQ
+	bool m_acia_triggered = 0;              // flag, ACIA receive IRQ
 
-	uint8_t m_adder_ram[0xE80];         // normal RAM
+	uint8_t m_adder_ram[0xE80]{};         // normal RAM
-	uint8_t m_screen_ram[2][0x1180];    // paged  display RAM
+	uint8_t m_screen_ram[2][0x1180]{};    // paged  display RAM
 
-	tilemap_t *m_tilemap0;  // tilemap screen0
+	tilemap_t *m_tilemap0 = nullptr;  // tilemap screen0
-	tilemap_t *m_tilemap1;  // tilemap screen1
+	tilemap_t *m_tilemap1 = nullptr;  // tilemap screen1
 
-	bool m_data_from_sc2;
+	bool m_data_from_sc2 = false;
-	bool m_data_to_sc2;
+	bool m_data_to_sc2 = false;
 
-	uint8_t m_adder2_data;
+	uint8_t m_adder2_data = 0;
-	uint8_t m_sc2data;
+	uint8_t m_sc2data = 0;
 
 	optional_device<cpu_device> m_cpu;
 

src/mame/video/bl_handhelds_lcdc.h

@@ -25,12 +25,12 @@ protected:
 	virtual void device_reset() override;
 
 private:
-	u8 m_displaybuffer[256 * 256 * 2];
+	u8 m_displaybuffer[256 * 256 * 2]{};
-	u16 m_posx, m_posy;
+	u16 m_posx = 0, m_posy = 0;
-	u16 m_posminx, m_posmaxx;
+	u16 m_posminx = 0, m_posmaxx = 0;
-	u16 m_posminy, m_posmaxy;
+	u16 m_posminy = 0, m_posmaxy = 0;
-	u8 m_command;
+	u8 m_command = 0;
-	u8 m_commandstep;
+	u8 m_commandstep = 0;
 
 };
 

src/mame/video/decbac06.h

@@ -95,8 +95,8 @@ public:
 	std::unique_ptr<u16[]> m_pf_rowscroll;
 	std::unique_ptr<u16[]> m_pf_colscroll;
 
-	tilemap_t* m_pf8x8_tilemap[3];
+	tilemap_t* m_pf8x8_tilemap[3]{};
-	tilemap_t* m_pf16x16_tilemap[3];
+	tilemap_t* m_pf16x16_tilemap[3]{};
 	int    m_tile_region_8;
 	int    m_tile_region_16;
 
@@ -110,7 +110,7 @@ public:
 	u16 m_pf_control_1[8];
 
 	int m_rambank; // external connection?
-	bool m_flip_screen;
+	bool m_flip_screen = false;
 
 protected:
 	virtual void device_start() override;

src/mame/video/deckarn.h

@@ -24,7 +24,7 @@ protected:
 
 private:
 	colpri_cb_delegate m_colpri_cb;
-	bool m_flip_screen;
+	bool m_flip_screen = false;
 };
 
 DECLARE_DEVICE_TYPE(DECO_KARNOVSPRITES, deco_karnovsprites_device)

src/mame/video/decmxc06.h

@@ -35,7 +35,7 @@ private:
 		u32 pri_mask = 0;
 	};
 	colpri_cb_delegate m_colpri_cb;
-	bool m_flip_screen;
+	bool m_flip_screen = false;
 	std::unique_ptr<struct sprite_t[]> m_spritelist;
 };
 

src/mame/video/deco16ic.h

@@ -134,8 +134,8 @@ private:
 
 	const u16 *m_pf1_rowscroll_ptr, *m_pf2_rowscroll_ptr;
 
-	tilemap_t *m_pf1_tilemap_16x16, *m_pf2_tilemap_16x16;
+	tilemap_t *m_pf1_tilemap_16x16 = nullptr, *m_pf2_tilemap_16x16 = nullptr;
-	tilemap_t *m_pf1_tilemap_8x8, *m_pf2_tilemap_8x8;
+	tilemap_t *m_pf1_tilemap_8x8 = nullptr, *m_pf2_tilemap_8x8 = nullptr;
 
 	deco16_tile_cb_delegate m_tile_cb;
 

src/mame/video/decospr.h

@@ -54,10 +54,10 @@ protected:
 	decospr_pri_cb_delegate m_pri_cb;
 	decospr_col_cb_delegate m_col_cb;
 	bitmap_ind16 m_sprite_bitmap;// optional sprite bitmap (should be INDEXED16)
-	bool m_alt_format;
+	bool m_alt_format = false;
-	uint16_t m_pixmask;
+	uint16_t m_pixmask = 0;
-	uint16_t m_raw_shift;
+	uint16_t m_raw_shift = 0;
-	bool m_flip_screen;
+	bool m_flip_screen = false;
 
 	// used by various bootleg / clone chips.
 	bool m_is_bootleg; // used by various bootlegs (disables masking of sprite tile number when multi-sprite is used)

src/mame/video/dgn_beta.cpp

@@ -96,7 +96,7 @@ the access to the video memory is unclear to me at the moment.
 #define IsTextMode  (m_GCtrl & GCtrlChrGfx) ? 1 : 0                  // Is this text mode ?
 #define IsGfx16     ((~m_GCtrl & GCtrlChrGfx) && (~m_GCtrl & GCtrlControl)) ? 1 : 0   // is this 320x256x16bpp mode
 #define IsGfx2      ((m_GCtrl & GCtrlHiLo) && (~m_GCtrl & GCtrlFS)) ? 1 : 0       // Is this a 2 colour mode
-#define SWChar      (m_GCtrl & GCtrlSWChar)>>1                   // Swchar bit
+#define SWChar      BIT(m_GCtrl, GCtrlSWChar)                   // Swchar bit
 
 MC6845_UPDATE_ROW( dgn_beta_state::crtc_update_row )
 {
@@ -120,7 +120,7 @@ MC6845_UPDATE_ROW( dgn_beta_state::crtc_update_row )
 			int FlashChar=(attr & 0x80) >> 7; // Flashing char
 
 			// underline is active for character set 0, on character row 9
-			int ULActive=(UnderLine && (ra==9) && ~SWChar);
+			int ULActive=(UnderLine && (ra==9) && !SWChar);
 
 			/* Invert foreground and background if flashing char and flash active */
 			int Invert=(FlashChar & m_FlashBit);

src/mame/video/dynax_blitter_rev2.h

@@ -61,12 +61,12 @@ protected:
 	devcb_write_line m_ready_cb;
 
 	// internal registers
-	u8 m_blit_pen;
+	u8 m_blit_pen = 0;
-	u8 m_blit_wrap_enable;
+	u8 m_blit_wrap_enable = 0;
-	u8 m_blit_x;
+	u8 m_blit_x = 0;
-	u8 m_blit_y;
+	u8 m_blit_y = 0;
-	u8 m_blit_flags;
+	u8 m_blit_flags = 0;
-	u32 m_blit_src;
+	u32 m_blit_src = 0;
 };
 
 // ======================> cdracula_blitter_device

src/mame/video/edevices.h

@@ -48,10 +48,10 @@ protected:
 private:
 
 	/* video-related */
-	tilemap_t *m_bg_tilemap;
+	tilemap_t *m_bg_tilemap = nullptr;
-	tilemap_t *m_mlow_tilemap;
+	tilemap_t *m_mlow_tilemap = nullptr;
-	tilemap_t *m_mhigh_tilemap;
+	tilemap_t *m_mhigh_tilemap = nullptr;
-	tilemap_t *m_tx_tilemap;
+	tilemap_t *m_tx_tilemap = nullptr;
 
 	TILE_GET_INFO_MEMBER(get_bg_tile_info);
 	TILE_GET_INFO_MEMBER(get_mlow_tile_info);
@@ -75,7 +75,7 @@ private:
 	required_device<palette_device> m_palette;
 
 	/* misc */
-	int m_which;
+	int m_which = 0;
 	int m_spritexoffs;
 };
 

src/mame/video/elan_eu3a05vid.h

@@ -38,17 +38,17 @@ private:
 	required_device<address_map_bank_device> m_bank;
 	const address_space_config      m_space_config;
 
-	uint8_t m_vidctrl;
+	uint8_t m_vidctrl = 0;
 
-	uint8_t m_tile_gfxbase_lo_data;
+	uint8_t m_tile_gfxbase_lo_data = 0;
-	uint8_t m_tile_gfxbase_hi_data;
+	uint8_t m_tile_gfxbase_hi_data = 0;
 
-	uint8_t m_sprite_gfxbase_lo_data;
+	uint8_t m_sprite_gfxbase_lo_data = 0;
-	uint8_t m_sprite_gfxbase_hi_data;
+	uint8_t m_sprite_gfxbase_hi_data = 0;
 
-	uint8_t m_tile_scroll[4*2];
+	uint8_t m_tile_scroll[4*2]{};
 
-	uint8_t m_splitpos[2];
+	uint8_t m_splitpos[2]{};
 
 	uint16_t get_scroll(int which);
 

src/mame/video/elan_eu3a14vid.h

@@ -84,15 +84,15 @@ private:
 	uint8_t m_rowscrollsplit[5];
 	uint8_t m_rowscrollcfg[2];
 	uint8_t m_ramtilecfg[6];
-	uint8_t m_spriteaddr;
+	uint8_t m_spriteaddr = 0;
 	uint8_t m_spritebase[2];
 
-	uint8_t m_5107;
+	uint8_t m_5107 = 0;
-	uint8_t m_5108;
+	uint8_t m_5108 = 0;
-	uint8_t m_5109;
+	uint8_t m_5109 = 0;
 
-	int m_tilerambase;
+	int m_tilerambase = 0;
-	int m_spriterambase;
+	int m_spriterambase = 0;
 
 	bitmap_ind8 m_prioritybitmap;
 };

src/mame/video/gamate.h

@@ -35,7 +35,7 @@ protected:
 
 	virtual space_config_vector memory_space_config() const override;
 
-	address_space *m_vramspace;
+	address_space *m_vramspace = nullptr;
 
 private:
 	uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);

src/mame/video/gamecom.cpp

@@ -24,7 +24,7 @@ TIMER_CALLBACK_MEMBER(gamecom_state::gamecom_scanline)
 	else
 	{
 		uint8_t const *const line = &m_p_videoram[ m_base_address + 40 * m_scanline ];
-		int pal[4];
+		int pal[4]{};
 
 		switch( m_p_ram[SM8521_LCDC] & 0x30 )
 		{

src/mame/video/gic.h

@@ -85,8 +85,8 @@ protected:
 	bitmap_ind16 m_bitmap;
 	required_region_ptr<uint8_t> m_cgrom;          // internal chargen ROM
 
-	emu_timer    *m_vblank_timer;
+	emu_timer    *m_vblank_timer = nullptr;
-	sound_stream *m_stream;
+	sound_stream *m_stream = nullptr;
 
 	int m_audiocnt;
 	int m_audioval;

src/mame/video/igs017_igs031.h

@@ -82,17 +82,17 @@ private:
 	// the gfx roms were often hooked up with the bits backwards, allow us to handle it here to save doing it in every driver.
 	bool m_revbits;
 
-	u8 m_toggle;
+	u8 m_toggle = 0;
-	int m_debug_addr;
+	int m_debug_addr = 0;
-	int m_debug_width;
+	int m_debug_width = 0;
-	bool m_video_disable;
+	bool m_video_disable = false;
-	tilemap_t *m_fg_tilemap;
+	tilemap_t *m_fg_tilemap = nullptr;
-	tilemap_t *m_bg_tilemap;
+	tilemap_t *m_bg_tilemap = nullptr;
 	std::unique_ptr<u8[]> m_sprites_gfx;
-	u32 m_sprites_gfx_size;
+	u32 m_sprites_gfx_size = 0;
 
-	bool m_nmi_enable;
+	bool m_nmi_enable = false;
-	bool m_irq_enable;
+	bool m_irq_enable = false;
 };
 
 DECLARE_DEVICE_TYPE(IGS017_IGS031, igs017_igs031_device)

src/mame/video/jag_blitter.h

@@ -60,7 +60,7 @@ private:
 	void count_inner_w(offs_t offset, u16 data, u16 mem_mask = ~0);
 
 	// timer setups
-	emu_timer *m_command_timer;
+	emu_timer *m_command_timer = nullptr;
 	inline void command_start();
 	inline void command_run();
 	inline void command_done();
@@ -81,8 +81,7 @@ private:
 	struct {
 		u32 base;
 		s16 xstep, ystep;
-
+		u32 ptr = 0; /**< Current pixel address */
-		u32 ptr; /**< Current pixel address */
 	} m_a1;
 };
 

src/mame/video/k001005.h

@@ -68,7 +68,7 @@ private:
 	int m_3dfifo_ptr;
 
 	vertex_t m_vertexb[4];
-	int m_vertexb_ptr;
+	int m_vertexb_ptr = 0;
 
 	uint32_t m_light_r;
 	uint32_t m_light_g;

src/mame/video/k001006.h

@@ -41,7 +41,7 @@ private:
 	std::unique_ptr<uint32_t[]>     m_palette;
 
 	required_region_ptr<uint8_t> m_gfxrom;
-	bool m_enable_bilinear;
+	bool m_enable_bilinear = false;
 };
 
 

src/mame/video/k007342.h

@@ -43,7 +43,7 @@ private:
 	uint8_t    *m_colorram_0;
 	uint8_t    *m_colorram_1;
 
-	tilemap_t  *m_tilemap[2];
+	tilemap_t  *m_tilemap[2]{};
 	int      m_flipscreen, m_int_enabled;
 	uint8_t    m_regs[8];
 	uint16_t   m_scrollx[2];

src/mame/video/k037122.h

@@ -33,11 +33,11 @@ protected:
 
 private:
 	// internal state
-	tilemap_t* m_tilemap_128;
+	tilemap_t* m_tilemap_128 = nullptr;
-	tilemap_t* m_tilemap_256;
+	tilemap_t* m_tilemap_256 = nullptr;
 
-	uint32_t m_palette_base;
+	uint32_t m_palette_base = 0;
-	uint32_t m_tilemap_base;
+	uint32_t m_tilemap_base = 0;
 
 	std::unique_ptr<uint32_t[]>       m_tile_ram;
 	std::unique_ptr<uint32_t[]>       m_char_ram;

src/mame/video/k051316.h

@@ -68,7 +68,7 @@ private:
 	// internal state
 	std::vector<uint8_t> m_ram;
 	uint8_t m_ctrlram[16];
-	tilemap_t *m_tmap;
+	tilemap_t *m_tmap = nullptr;
 
 	optional_region_ptr<uint8_t> m_zoom_rom;
 

src/mame/video/k053246_k053247_k055673.h

@@ -97,7 +97,7 @@ public:
 
 	u8    m_kx46_regs[8];
 	u16   m_kx47_regs[16];
-	int   m_dx, m_dy;
+	int   m_dx = 0, m_dy = 0;
 	u8    m_objcha_line;
 	int   m_z_rejection;
 
@@ -105,7 +105,7 @@ public:
 
 	required_region_ptr<u8> m_gfxrom;
 	int m_gfx_num;
-	int m_bpp;
+	int m_bpp = 0;
 
 	/* alt implementation - to be collapsed */
 	void zdrawgfxzoom32GP(

src/mame/video/k053250.h

@@ -46,16 +46,16 @@ protected:
 
 private:
 	// configuration
-	int m_offx, m_offy;
+	int m_offx = 0, m_offy = 0;
 
 	// internal state
 	required_region_ptr<uint8_t> m_rom;
 	std::vector<uint8_t> m_unpacked_rom;
 	std::vector<uint16_t> m_ram;
-	uint16_t *m_buffer[2];
+	uint16_t *m_buffer[2]{};
-	uint8_t m_regs[8];
+	uint8_t m_regs[8]{};
-	uint8_t m_page;
+	uint8_t m_page = 0;
-	int32_t m_frame;
+	int32_t m_frame = 0;
 
 	// internal helpers
 	void unpack_nibbles();

src/mame/video/k053250_ps.h

@@ -58,21 +58,21 @@ private:
 	};
 
 	devcb_write_line m_dmairq_cb;
-	int m_timer_lvcdma_state;
+	int m_timer_lvcdma_state = 0;
-	bool m_dmairq_on;
+	bool m_dmairq_on = false;
 
 	// configuration
 	int m_offx, m_offy;
 
-	emu_timer *m_timer_lvcdma;
+	emu_timer *m_timer_lvcdma = nullptr;
 
 	// internal state
 	required_region_ptr<uint8_t> m_rom;
 	std::vector<uint8_t> m_unpacked_rom;
 	std::vector<uint16_t> m_ram;
-	uint16_t *m_buffer[2];
+	uint16_t *m_buffer[2]{};
-	uint8_t m_regs[8];
+	uint8_t m_regs[8]{};
-	uint8_t m_page;
+	uint8_t m_page = 0;
 
 	// internal helpers
 	void unpack_nibbles();

src/mame/video/k054000.h

@@ -28,9 +28,9 @@ private:
 	int convert_raw_to_result(u8 *buf);
 	u8 status_r();
 
-	u8 m_raw_Acx[4], m_raw_Acy[4], m_raw_Bcx[4], m_raw_Bcy[4];
+	u8 m_raw_Acx[4]{}, m_raw_Acy[4]{}, m_raw_Bcx[4]{}, m_raw_Bcy[4]{};
-	int m_Acx, m_Acy, m_Bcx, m_Bcy;
+	int m_Acx = 0, m_Acy = 0, m_Bcx = 0, m_Bcy = 0;
-	int m_Aax, m_Aay, m_Bax, m_Bay;
+	int m_Aax = 0, m_Aay = 0, m_Bax = 0, m_Bay = 0;
 
 	std::string print_hitbox_state(bool result);
 };

src/mame/video/k054156_k054157_k056832.h

@@ -110,8 +110,8 @@ protected:
 
 private:
 	// internal state
-	tilemap_t   *m_tilemap[K056832_PAGE_COUNT];
+	tilemap_t   *m_tilemap[K056832_PAGE_COUNT]{};
-	bitmap_ind16  *m_pixmap[K056832_PAGE_COUNT];
+	bitmap_ind16  *m_pixmap[K056832_PAGE_COUNT]{};
 
 	std::vector<uint16_t> m_videoram;
 
@@ -133,7 +133,7 @@ private:
 	// ROM readback involves reading 2 halves of a word
 	// from the same location in a row.  Reading the
 	// RAM window resets this state so you get the first half.
-	int       m_rom_half;
+	int       m_rom_half = 0;
 
 	// locally cached values
 	int       m_layer_assoc_with_page[K056832_PAGE_COUNT];

src/mame/video/k1ge.h

@@ -47,10 +47,10 @@ protected:
 	devcb_write_line m_vblank_pin_w;
 	devcb_write_line m_hblank_pin_w;
 	std::unique_ptr<uint8_t[]> m_vram;
-	uint8_t m_wba_h, m_wba_v, m_wsi_h, m_wsi_v;
+	uint8_t m_wba_h = 0, m_wba_v = 0, m_wsi_h = 0, m_wsi_v = 0;
 
-	emu_timer *m_timer;
+	emu_timer *m_timer = nullptr;
-	emu_timer *m_hblank_on_timer;
+	emu_timer *m_hblank_on_timer = nullptr;
 	std::unique_ptr<bitmap_ind16> m_bitmap;
 
 	virtual void draw(int line);

src/mame/video/kan_pand.h

@@ -53,12 +53,12 @@ private:
 	// internal state
 	std::unique_ptr<uint8_t[]>        m_spriteram;
 	std::unique_ptr<bitmap_ind16> m_sprites_bitmap; /* bitmap to render sprites to, Pandora seems to be frame'buffered' */
-	int             m_clear_bitmap;
+	int             m_clear_bitmap = 0;
-	int             m_bg_pen; // might work some other way..
+	int             m_bg_pen = 0; // might work some other way..
 	uint8_t           m_gfx_region;
 	int             m_xoffset;
 	int             m_yoffset;
-	bool            m_flip_screen;
+	bool            m_flip_screen = false;
 	required_device<gfxdecode_device> m_gfxdecode;
 };
 

src/mame/video/kaneko_grap2.h

@@ -24,16 +24,16 @@ public:
 	void do_rle(uint32_t address);
 	void set_color_555(pen_t color, int rshift, int gshift, int bshift, uint16_t data);
 
-	uint16_t m_framebuffer_scrolly;
+	uint16_t m_framebuffer_scrolly = 0;
-	uint16_t m_framebuffer_scrollx;
+	uint16_t m_framebuffer_scrollx = 0;
-	uint16_t m_framebuffer_enable;
+	uint16_t m_framebuffer_enable = 0;
-	int m_regs1_i;
+	int m_regs1_i = 0;
 
-	uint16_t m_framebuffer_bright1;
+	uint16_t m_framebuffer_bright1 = 0;
-	uint16_t m_framebuffer_bright2;
+	uint16_t m_framebuffer_bright2 = 0;
 
-	uint16_t m_regs1_address_regs[0x2];
+	uint16_t m_regs1_address_regs[0x2]{};
-	uint16_t m_regs2;
+	uint16_t m_regs2 = 0;
 
 	void framebuffer1_enable_w(uint16_t data) { m_framebuffer_enable = data; }
 

src/mame/video/kaneko_tmap.h

@@ -87,7 +87,7 @@ private:
 
 	view2_cb_delegate   m_view2_cb;
 	std::unique_ptr<u16[]> m_regs;
-	tilemap_t* m_tmap[2];
+	tilemap_t* m_tmap[2]{};
 };
 
 

src/mame/video/ladybug.h

@@ -55,7 +55,7 @@ protected:
 private:
 	u8  m_enable;
 	u8  m_speed;
-	u32 m_state;
+	u32 m_state = 0;
 	u16 m_offset;
 	u8  m_count;
 };

src/mame/video/light.h

@@ -40,28 +40,28 @@ private:
 
 	struct lg1_t
 	{
-		uint32_t m_config_sel;
+		uint32_t m_config_sel = 0;
-		uint32_t m_write_addr;
+		uint32_t m_write_addr = 0;
-		uint32_t m_control;
+		uint32_t m_control = 0;
 
-		uint32_t m_command;
+		uint32_t m_command = 0;
-		uint32_t m_x_start_i;
+		uint32_t m_x_start_i = 0;
-		uint32_t m_y_start_i;
+		uint32_t m_y_start_i = 0;
-		uint32_t m_xy_move;
+		uint32_t m_xy_move = 0;
-		uint32_t m_color_red_i;
+		uint32_t m_color_red_i = 0;
-		uint32_t m_color_green_i;
+		uint32_t m_color_green_i = 0;
-		uint32_t m_color_blue_i;
+		uint32_t m_color_blue_i = 0;
-		uint32_t m_color_back;
+		uint32_t m_color_back = 0;
-		uint32_t m_z_pattern;
+		uint32_t m_z_pattern = 0;
-		uint32_t m_x_end_i;
+		uint32_t m_x_end_i = 0;
-		uint32_t m_y_end_i;
+		uint32_t m_y_end_i = 0;
-		uint32_t m_x_curr_i;
+		uint32_t m_x_curr_i = 0;
-		uint32_t m_y_curr_i;
+		uint32_t m_y_curr_i = 0;
 
-		uint8_t m_palette_idx;
+		uint8_t m_palette_idx = 0;
-		uint8_t m_palette_channel;
+		uint8_t m_palette_channel = 0;
-		uint8_t m_palette_entry[3];
+		uint8_t m_palette_entry[3]{};
-		uint8_t m_pix_read_mask[256];
+		uint8_t m_pix_read_mask[256]{};
 	};
 	lg1_t m_lg1;
 

src/mame/video/maria.h

@@ -32,25 +32,25 @@ protected:
 
 private:
 
-	int m_maria_palette[32];
+	int m_maria_palette[32]{};
-	int m_line_ram[2][160];
+	int m_line_ram[2][160]{};
-	int m_active_buffer;
+	int m_active_buffer = 0;
-	int m_write_mode;
+	int m_write_mode = 0;
-	unsigned int m_dll;
+	unsigned int m_dll = 0;
-	unsigned int m_dl;
+	unsigned int m_dl = 0;
-	int m_holey;
+	int m_holey = 0;
-	int m_offset;
+	int m_offset = 0;
-	int m_vblank;
+	int m_vblank = 0;
-	int m_dmaon;
+	int m_dmaon = 0;
-	int m_dpp;
+	int m_dpp = 0;
-	int m_wsync;
+	int m_wsync = 0;
-	int m_color_kill;
+	int m_color_kill = 0;
-	int m_cwidth;
+	int m_cwidth = 0;
-	int m_bcntl;
+	int m_bcntl = 0;
-	int m_kangaroo;
+	int m_kangaroo = 0;
-	int m_rm;
+	int m_rm = 0;
-	int m_nmi;
+	int m_nmi = 0;
-	unsigned int m_charbase;
+	unsigned int m_charbase = 0;
 	bitmap_ind16 m_bitmap;
 
 	void draw_scanline();

src/mame/video/mcd212.h

@@ -179,28 +179,28 @@ protected:
 		ICM_CLUT4            = 0xb
 	};
 
-	uint8_t m_csrr[2];
+	uint8_t m_csrr[2]{};
-	uint16_t m_csrw[2];
+	uint16_t m_csrw[2]{};
-	uint16_t m_dcr[2];
+	uint16_t m_dcr[2]{};
-	uint16_t m_vsr[2];
+	uint16_t m_vsr[2]{};
-	uint16_t m_ddr[2];
+	uint16_t m_ddr[2]{};
-	uint16_t m_dcp[2];
+	uint16_t m_dcp[2]{};
-	uint32_t m_dca[2];
+	uint32_t m_dca[2]{};
-	uint32_t m_clut[256];
+	uint32_t m_clut[256]{};
-	uint32_t m_image_coding_method;
+	uint32_t m_image_coding_method = 0;
-	uint32_t m_transparency_control;
+	uint32_t m_transparency_control = 0;
-	uint32_t m_plane_order;
+	uint32_t m_plane_order = 0;
-	uint32_t m_clut_bank[2];
+	uint32_t m_clut_bank[2]{};
-	uint32_t m_transparent_color[2];
+	uint32_t m_transparent_color[2]{};
-	uint32_t m_mask_color[2];
+	uint32_t m_mask_color[2]{};
-	uint32_t m_dyuv_abs_start[2];
+	uint32_t m_dyuv_abs_start[2]{};
-	uint32_t m_cursor_position;
+	uint32_t m_cursor_position = 0;
-	uint32_t m_cursor_control;
+	uint32_t m_cursor_control = 0;
-	uint32_t m_cursor_pattern[16];
+	uint32_t m_cursor_pattern[16]{};
-	uint32_t m_region_control[8];
+	uint32_t m_region_control[8]{};
-	uint32_t m_backdrop_color;
+	uint32_t m_backdrop_color = 0;
-	uint32_t m_mosaic_hold[2];
+	uint32_t m_mosaic_hold[2]{};
-	uint8_t m_weight_factor[2][768];
+	uint8_t m_weight_factor[2][768]{};
 
 	// DYUV color limit arrays.
 	uint32_t m_dyuv_limit_r_lut[3 * 0xff];
@@ -232,11 +232,11 @@ protected:
 	required_shared_ptr<uint16_t> m_planeb;
 
 	// internal state
-	bool m_region_flag[2][768];
+	bool m_region_flag[2][768]{};
-	int m_ica_height;
+	int m_ica_height = 0;
-	int m_total_height;
+	int m_total_height = 0;
-	emu_timer *m_ica_timer;
+	emu_timer *m_ica_timer = nullptr;
-	emu_timer *m_dca_timer;
+	emu_timer *m_dca_timer = nullptr;
 
 	static const uint32_t s_4bpp_color[16];
 

src/mame/video/ms1_tmap.h

@@ -73,12 +73,12 @@ private:
 	DECLARE_GFXDECODE_MEMBER(gfxinfo);
 
 	// internal state
-	uint16_t m_scrollx;
+	uint16_t m_scrollx = 0;
-	uint16_t m_scrolly;
+	uint16_t m_scrolly = 0;
-	uint16_t m_scroll_flag;
+	uint16_t m_scroll_flag = 0;
-	uint16_t m_tile_bank;
+	uint16_t m_tile_bank = 0;
-	tilemap_t *m_tmap;
+	tilemap_t *m_tmap = nullptr;
-	tilemap_t *m_tilemap[2][4];
+	tilemap_t *m_tilemap[2][4]{};
 
 	// helpers
 	TILEMAP_MAPPER_MEMBER(scan_8x8);