len0rd/rockbox
1
0
Fork 1
mirror of https://github.com/Rockbox/rockbox.git synced 2025-10-13 18:17:39 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Convert a number of places in core and plugins to use the BIT_N() macro instead of 1<<n. Speeds up things on SH1, and also reduces core binsize. Most notable speedups: 1 bit lcd driver: drawpixel +20%, drawline + 27%, hline +5%; jpeg viewer: +8% for 1/8 scaling. Other targets are unaffected.

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@21205 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Jens Arnold 2009-06-07 21:27:05 +00:00
parent c3182ec333
commit 1d6df54df2
24 changed files with 88 additions and 70 deletions
Download patch file Download diff file Expand all files Collapse all files

5
apps/gui/viewport.h
View file

@ -22,6 +22,7 @@
#include "config.h" #include "config.h"
#include "lcd.h" #include "lcd.h"
#include "system.h"
#include "screen_access.h" #include "screen_access.h"
/* return the number of text lines in the vp viewport */ /* return the number of text lines in the vp viewport */
@ -58,8 +59,8 @@ void viewport_set_defaults(struct viewport *vp, enum screen_type screen);
* SB "displaying rules". * SB "displaying rules".
*/ */
#define VP_SB_HIDE_ALL 0 #define VP_SB_HIDE_ALL 0
#define VP_SB_ONSCREEN(screen) (1u<<screen) #define VP_SB_ONSCREEN(screen) BIT_N(screen)
#define VP_SB_IGNORE_SETTING(screen) (1u<<(4+screen)) #define VP_SB_IGNORE_SETTING(screen) BIT_N(4+screen)
#define VP_SB_ALLSCREENS (VP_SB_ONSCREEN(0)|VP_SB_ONSCREEN(1)) #define VP_SB_ALLSCREENS (VP_SB_ONSCREEN(0)|VP_SB_ONSCREEN(1))
int viewportmanager_set_statusbar(int enabled); int viewportmanager_set_statusbar(int enabled);

2
apps/misc.c
View file

@ -1045,7 +1045,7 @@ const char* parse_list(const char *fmt, uint32_t *set_vals,
break; break;
} }
if (set_vals && set) if (set_vals && set)
*set_vals |= (1<<i); *set_vals |= BIT_N(i);
i++; i++;
} }

3
apps/misc.h
View file

@ -24,6 +24,7 @@
#include <stdbool.h> #include <stdbool.h>
#include <inttypes.h> #include <inttypes.h>
#include "config.h" #include "config.h"
#include "system.h"
/* Format a large-range value for output, using the appropriate unit so that /* Format a large-range value for output, using the appropriate unit so that
* the displayed value is in the range 1 <= display < 1000 (1024 for "binary" * the displayed value is in the range 1 <= display < 1000 (1024 for "binary"
@ -103,7 +104,7 @@ char *strip_extension(char* buffer, int buffer_size, const char *filename);
* - position: 0-based number of the value * - position: 0-based number of the value
* - valid_vals: value after the call to 'parse_list' * - valid_vals: value after the call to 'parse_list'
*/ */
#define LIST_VALUE_PARSED(setvals, position) ((setvals)&(1<<(position))) #define LIST_VALUE_PARSED(setvals, position) ((setvals) & BIT_N(position))
const char* parse_list(const char *fmt, uint32_t *set_vals, const char* parse_list(const char *fmt, uint32_t *set_vals,
const char sep, const char* str, ...); const char sep, const char* str, ...);

6
apps/plugins/alpine_cdc.c
View file

@ -669,16 +669,16 @@ void dump_packet(char* dest, int dst_size, char* src, int n)
bool bit_test(unsigned char* buf, unsigned bit) bool bit_test(unsigned char* buf, unsigned bit)
{ {
return (buf[bit/4] & (0x01 << bit%4)) != 0; return (buf[bit>>2] & BIT_N(bit&3)) != 0;
} }
void bit_set(unsigned char* buf, unsigned bit, bool val) void bit_set(unsigned char* buf, unsigned bit, bool val)
{ {
if (val) if (val)
buf[bit/4] |= (0x01 << bit%4); buf[bit>>2] |= BIT_N(bit&3);
else else
buf[bit/4] &= ~(0x01 << bit%4); buf[bit>>2] &= ~BIT_N(bit&3);
} }

4
apps/plugins/jpeg/jpeg_decoder.c
View file

@ -1067,12 +1067,12 @@ INLINE void check_bit_buffer(struct bitstream* pb, int nbits)
INLINE int get_bits(struct bitstream* pb, int nbits) INLINE int get_bits(struct bitstream* pb, int nbits)
{ {
return ((int) (pb->get_buffer >> (pb->bits_left -= nbits))) & ((1<<nbits)-1); return ((int) (pb->get_buffer >> (pb->bits_left -= nbits))) & (BIT_N(nbits)-1);
} }
INLINE int peek_bits(struct bitstream* pb, int nbits) INLINE int peek_bits(struct bitstream* pb, int nbits)
{ {
return ((int) (pb->get_buffer >> (pb->bits_left - nbits))) & ((1<<nbits)-1); return ((int) (pb->get_buffer >> (pb->bits_left - nbits))) & (BIT_N(nbits)-1);
} }
INLINE void drop_bits(struct bitstream* pb, int nbits) INLINE void drop_bits(struct bitstream* pb, int nbits)

3
apps/plugins/lib/fixedpoint.c
View file

@ -22,6 +22,7 @@
****************************************************************************/ ****************************************************************************/
#include <inttypes.h> #include <inttypes.h>
#include "plugin.h"
#include "fixedpoint.h" #include "fixedpoint.h"
/* Inverse gain of circular cordic rotation in s0.31 format. */ /* Inverse gain of circular cordic rotation in s0.31 format. */
@ -144,7 +145,7 @@ long fsincos(unsigned long phase, long *cos)
*/ */
long fsqrt(long a, unsigned int fracbits) long fsqrt(long a, unsigned int fracbits)
{ {
long b = a/2 + (1 << fracbits); /* initial approximation */ long b = a/2 + BIT_N(fracbits); /* initial approximation */
unsigned n; unsigned n;
const unsigned iterations = 4; const unsigned iterations = 4;

2
apps/plugins/lib/grey_core.c
View file

@ -860,7 +860,7 @@ static void grey_screendump_hook(int fd)
+ _GREY_MULUQ(_grey_info.width, gy & ~_GREY_BMASK); + _GREY_MULUQ(_grey_info.width, gy & ~_GREY_BMASK);
#if LCD_DEPTH == 1 #if LCD_DEPTH == 1
mask = 1 << (y & 7); mask = BIT_N(y & 7);
src = rb->lcd_framebuffer + _GREY_MULUQ(LCD_WIDTH, y >> 3); src = rb->lcd_framebuffer + _GREY_MULUQ(LCD_WIDTH, y >> 3);
do do

14
apps/plugins/lib/helper.c
View file

@ -22,6 +22,20 @@
#include "plugin.h" #include "plugin.h"
#include "helper.h" #include "helper.h"
#ifdef CPU_SH
/* Lookup table for using the BIT_N() macro in plugins */
const unsigned bit_n_table[32] = {
1LU<< 0, 1LU<< 1, 1LU<< 2, 1LU<< 3,
1LU<< 4, 1LU<< 5, 1LU<< 6, 1LU<< 7,
1LU<< 8, 1LU<< 9, 1LU<<10, 1LU<<11,
1LU<<12, 1LU<<13, 1LU<<14, 1LU<<15,
1LU<<16, 1LU<<17, 1LU<<18, 1LU<<19,
1LU<<20, 1LU<<21, 1LU<<22, 1LU<<23,
1LU<<24, 1LU<<25, 1LU<<26, 1LU<<27,
1LU<<28, 1LU<<29, 1LU<<30, 1LU<<31
};
#endif
/* Force the backlight on */ /* Force the backlight on */
void backlight_force_on(void) void backlight_force_on(void)
{ {

10
apps/plugins/rockboy/cpu.c
View file

@ -147,9 +147,9 @@ F = (F & (FN)) | ZFLAG(A) | daa_carry_table[LB(acc)>>2]; }
(r) = swap_table[(r)]; \ (r) = swap_table[(r)]; \
F = ZFLAG((r)); } F = ZFLAG((r)); }
#define BIT(n,r) { F = (F & FC) | ZFLAG(((r) & (1 << (n)))) | FH; } #define BIT(n,r) { F = (F & FC) | ZFLAG(((r) & BIT_N(n))) | FH; }
#define RES(n,r) { (r) &= ~(1 << (n)); } #define RES(n,r) { (r) &= ~BIT_N(n); }
#define SET(n,r) { (r) |= (1 << (n)); } #define SET(n,r) { (r) |= BIT_N(n); }
#define CB_REG_CASES(r, n) \ #define CB_REG_CASES(r, n) \
case 0x00|(n): RLC(r); break; \ case 0x00|(n): RLC(r); break; \
@ -225,7 +225,7 @@ label: op(b); break;
#define PRE_INT ( DI, PUSH(PC) ) #define PRE_INT ( DI, PUSH(PC) )
#define THROW_INT(n) ( (IF &= ~(1<<(n))), (PC = 0x40+((n)<<3)) ) #define THROW_INT(n) ( (IF &= ~BIT_N(n)), (PC = 0x40+((n)<<3)) )
#ifdef DYNAREC #ifdef DYNAREC
un32 reg_backup[16]; un32 reg_backup[16];
@ -355,7 +355,7 @@ static int cpu_idle(int max)
/* Figure out when the next timer interrupt will happen */ /* Figure out when the next timer interrupt will happen */
unit = ((-R_TAC) & 3) << 1; unit = ((-R_TAC) & 3) << 1;
cnt = (511 - cpu.tim + (1<<unit)) >> unit; cnt = (511 - cpu.tim + BIT_N(unit)) >> unit;
cnt += (255 - R_TIMA) << (9 - unit); cnt += (255 - R_TIMA) << (9 - unit);
if (max < cnt) if (max < cnt)

4
apps/plugins/rockboy/lcd.c
View file

@ -216,8 +216,8 @@ static void updatepatpix(void)
a = ((i<<4) | (j<<1)); a = ((i<<4) | (j<<1));
for (k = 0; k < 8; k++) for (k = 0; k < 8; k++)
{ {
c = vram[a] & (1<<k) ? 1 : 0; c = vram[a] & BIT_N(k) ? 1 : 0;
c |= vram[a+1] & (1<<k) ? 2 : 0; c |= vram[a+1] & BIT_N(k) ? 2 : 0;
patpix[i+1024][j][k] = c; patpix[i+1024][j][k] = c;
} }
for (k = 0; k < 8; k++) for (k = 0; k < 8; k++)

2
apps/plugins/rockboy/sound.c
View file

@ -182,7 +182,7 @@ static void gbSoundChannel1(int *r, int *l)
int newfreq = 0; int newfreq = 0;
if(S1.swsteps) if(S1.swsteps)
{ {
newfreq = freq + updown * freq / (1 << S1.swsteps); newfreq = freq + updown * freq / BIT_N(S1.swsteps);
if(newfreq == freq) if(newfreq == freq)
newfreq = 0; newfreq = 0;
} }

4
apps/plugins/sudoku/generator.c
View file

@ -54,7 +54,7 @@
#define STATE_MASK 0x0000ff80 #define STATE_MASK 0x0000ff80
#define STATE_SHIFT (7-1) /* digits 1..9 */ #define STATE_SHIFT (7-1) /* digits 1..9 */
#define DIGIT_STATE(digit) (1<<(STATE_SHIFT+(digit))) #define DIGIT_STATE(digit) BIT_N(STATE_SHIFT+(digit))
#define DIGIT_MASK 0x000f0000 #define DIGIT_MASK 0x000f0000
#define DIGIT_SHIFT 16 #define DIGIT_SHIFT 16
@ -266,7 +266,7 @@ numset( int mask )
{ {
int i, n = 0; int i, n = 0;
for( i = STATE_SHIFT + 1 ; i <= STATE_SHIFT + 9 ; ++i ) for( i = STATE_SHIFT + 1 ; i <= STATE_SHIFT + 9 ; ++i )
if( mask & (1<<i) ) if( mask & BIT_N(i) )
++n; ++n;
else else
++counts[ i - STATE_SHIFT - 1 ]; ++counts[ i - STATE_SHIFT - 1 ];

12
apps/plugins/sudoku/sudoku.c
View file

@ -337,7 +337,7 @@ void sudoku_init(Sudoku* sud);
void sudoku_set(Sudoku* sud, int x, int y, int num, bool original); void sudoku_set(Sudoku* sud, int x, int y, int num, bool original);
int sudoku_get(Sudoku* sud, int x, int y, bool* original); int sudoku_get(Sudoku* sud, int x, int y, bool* original);
#define BIT(n) ((Bitset)(1<<(n))) #define BIT(n) ((Bitset)BIT_N(n))
#define BIT_TEST(v,n) ((((Bitset)v) & BIT(n)) != 0) #define BIT_TEST(v,n) ((((Bitset)v) & BIT(n)) != 0)
#define BIT_CLEAR(v,n) (v) &= ~BIT(n) #define BIT_CLEAR(v,n) (v) &= ~BIT(n)
#define MARK_BIT BIT(0) #define MARK_BIT BIT(0)
@ -965,7 +965,7 @@ void display_board(struct sudoku_state_t* state)
rb->lcd_vline(XOFS+cellxpos[r]-2,YOFSSCRATCHPAD, rb->lcd_vline(XOFS+cellxpos[r]-2,YOFSSCRATCHPAD,
YOFSSCRATCHPAD+CELL_HEIGHT+1); YOFSSCRATCHPAD+CELL_HEIGHT+1);
#endif #endif
if ((r>0) && state->possiblevals[state->y][state->x]&(1<<(r))) if ((r>0) && state->possiblevals[state->y][state->x]&BIT_N(r))
rb->lcd_bitmap_part(sudoku_normal,NUMBER_TYPE,BITMAP_HEIGHT*r, rb->lcd_bitmap_part(sudoku_normal,NUMBER_TYPE,BITMAP_HEIGHT*r,
BITMAP_STRIDE,XOFS+cellxpos[r-1], BITMAP_STRIDE,XOFS+cellxpos[r-1],
YOFSSCRATCHPAD+1,CELL_WIDTH,CELL_HEIGHT); YOFSSCRATCHPAD+1,CELL_WIDTH,CELL_HEIGHT);
@ -976,7 +976,7 @@ void display_board(struct sudoku_state_t* state)
rb->lcd_vline(XOFS+cellxpos[8]+CELL_WIDTH+1,YOFSSCRATCHPAD, rb->lcd_vline(XOFS+cellxpos[8]+CELL_WIDTH+1,YOFSSCRATCHPAD,
YOFSSCRATCHPAD+CELL_HEIGHT+1); YOFSSCRATCHPAD+CELL_HEIGHT+1);
#endif #endif
if (state->possiblevals[state->y][state->x]&(1<<(r))) if (state->possiblevals[state->y][state->x]&BIT_N(r))
rb->lcd_bitmap_part(sudoku_normal,NUMBER_TYPE,BITMAP_HEIGHT*r, rb->lcd_bitmap_part(sudoku_normal,NUMBER_TYPE,BITMAP_HEIGHT*r,
BITMAP_STRIDE,XOFS+cellxpos[8],YOFSSCRATCHPAD+1, BITMAP_STRIDE,XOFS+cellxpos[8],YOFSSCRATCHPAD+1,
CELL_WIDTH,CELL_HEIGHT); CELL_WIDTH,CELL_HEIGHT);
@ -1004,7 +1004,7 @@ void display_board(struct sudoku_state_t* state)
rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1, rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
YOFS+cellypos[r]-2); YOFS+cellypos[r]-2);
#endif #endif
if ((r>0) && state->possiblevals[state->y][state->x]&(1<<(r))) if ((r>0) && state->possiblevals[state->y][state->x]&BIT_N(r))
rb->lcd_bitmap_part(sudoku_normal,NUMBER_TYPE,BITMAP_HEIGHT*r, rb->lcd_bitmap_part(sudoku_normal,NUMBER_TYPE,BITMAP_HEIGHT*r,
BITMAP_STRIDE,XOFSSCRATCHPAD+1, BITMAP_STRIDE,XOFSSCRATCHPAD+1,
YOFS+cellypos[r-1],CELL_WIDTH,CELL_HEIGHT); YOFS+cellypos[r-1],CELL_WIDTH,CELL_HEIGHT);
@ -1015,7 +1015,7 @@ void display_board(struct sudoku_state_t* state)
rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1, rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
YOFS+cellypos[8]+CELL_HEIGHT+1); YOFS+cellypos[8]+CELL_HEIGHT+1);
#endif #endif
if (state->possiblevals[state->y][state->x]&(1<<(r))) if (state->possiblevals[state->y][state->x]&BIT_N(r))
rb->lcd_bitmap_part(sudoku_normal,NUMBER_TYPE,BITMAP_HEIGHT*r, rb->lcd_bitmap_part(sudoku_normal,NUMBER_TYPE,BITMAP_HEIGHT*r,
BITMAP_STRIDE,XOFSSCRATCHPAD+1,YOFS+cellypos[8], BITMAP_STRIDE,XOFSSCRATCHPAD+1,YOFS+cellypos[8],
CELL_WIDTH,CELL_HEIGHT); CELL_WIDTH,CELL_HEIGHT);
@ -1552,7 +1552,7 @@ enum plugin_status plugin_start(const void* parameter)
/* Toggle current number in the possiblevals structure */ /* Toggle current number in the possiblevals structure */
if (state.currentboard[state.y][state.x]!='0') { if (state.currentboard[state.y][state.x]!='0') {
state.possiblevals[state.y][state.x]^= state.possiblevals[state.y][state.x]^=
(1 << (state.currentboard[state.y][state.x] - '0')); BIT_N(state.currentboard[state.y][state.x] - '0');
} }
break; break;
#endif #endif

4
apps/plugins/zxbox/sp_def.h
View file

@ -1,4 +1,4 @@
/* /*
* Copyright (C) 1996-1998 Szeredi Miklos * Copyright (C) 1996-1998 Szeredi Miklos
* Email: mszeredi@inf.bme.hu * Email: mszeredi@inf.bme.hu
* *
@ -20,7 +20,7 @@
#include "spperif.h" #include "spperif.h"
#define MARK_SCR(addr) SPNM(scr_mark)[(addr) >> 5] |= 1 << ((addr) & 0x1F) #define MARK_SCR(addr) SPNM(scr_mark)[(addr) >> 5] |= BIT_N((addr) & 0x1F)
#define PUTMEM(addr, ptr, val) \ #define PUTMEM(addr, ptr, val) \
{ \ { \

4
apps/plugins/zxbox/spkey.c
View file

@ -85,7 +85,7 @@ int spkb_state_changed;
#define SKE {0, 0, 0, 0, 0, 0, 0, 0} #define SKE {0, 0, 0, 0, 0, 0, 0, 0}
#define SKP(x) (1 << x) #define SKP(x) BIT_N(x)
#define SKN0(x) {SKP(x), 0, 0, 0, 0, 0, 0, 0} #define SKN0(x) {SKP(x), 0, 0, 0, 0, 0, 0, 0}
#define SKN1(x) {0, SKP(x), 0, 0, 0, 0, 0, 0} #define SKN1(x) {0, SKP(x), 0, 0, 0, 0, 0, 0}
@ -617,7 +617,7 @@ static void copy_basekeys(struct spbasekey *addk)
static unsigned transform_shift(int modif) static unsigned transform_shift(int modif)
{ {
if(!modif) return 0; if(!modif) return 0;
else return (1 << (modif - 1)); else return BIT_N(modif - 1);
} }

4
apps/plugins/zxbox/spscr.c
View file

@ -1,4 +1,4 @@
/* /*
* Copyright (C) 1996-1998 Szeredi Miklos * Copyright (C) 1996-1998 Szeredi Miklos
* Email: mszeredi@inf.bme.hu * Email: mszeredi@inf.bme.hu
* *
@ -82,7 +82,7 @@ byte *update_screen_line(byte *scrp, int coli, int scri, int border,
SPNM(imag_mark)[coli] |= mark; SPNM(imag_mark)[coli] |= mark;
SPNM(imag_horiz) |= mark; SPNM(imag_horiz) |= mark;
coli >>= 3; coli >>= 3;
SPNM(imag_vert) |= (1 << coli); SPNM(imag_vert) |= BIT_N(coli);
spmp = PRNM(proc).mem + (scri << 5); spmp = PRNM(proc).mem + (scri << 5);
spcp = PRNM(proc).mem + 0x5800 + (coli << 5); spcp = PRNM(proc).mem + 0x5800 + (coli << 5);

4
apps/recorder/bmp.c
View file

@ -617,7 +617,7 @@ int read_bmp_fd(int fd,
if (depth <= 8) { if (depth <= 8) {
numcolors = letoh32(bmph.clr_used); numcolors = letoh32(bmph.clr_used);
if (numcolors == 0) if (numcolors == 0)
numcolors = 1 << depth; numcolors = BIT_N(depth);
} else } else
numcolors = (compression == 3) ? 3 : 0; numcolors = (compression == 3) ? 3 : 0;
@ -795,7 +795,7 @@ int read_bmp_fd(int fd,
#ifndef PLUGIN #ifndef PLUGIN
{ {
unsigned char *p = bitmap + bm->width * (row >> 3); unsigned char *p = bitmap + bm->width * (row >> 3);
unsigned char mask = 1 << (row & 7); unsigned char mask = BIT_N(row & 7);
int col; int col;
for (col = 0; col < bm->width; col++, p++) for (col = 0; col < bm->width; col++, p++)
#if !defined(HAVE_LCD_COLOR) && \ #if !defined(HAVE_LCD_COLOR) && \

43
apps/recorder/jpeg_load.c
View file

@ -1506,7 +1506,8 @@ INLINE void fix_huff_tables(struct jpeg *p_jpeg)
*/ */
INLINE void fix_quant_tables(struct jpeg *p_jpeg) INLINE void fix_quant_tables(struct jpeg *p_jpeg)
{ {
int shift, i, x, y, a; int shift, i, a;
unsigned x, y;
for (i = 0; i < 2; i++) for (i = 0; i < 2; i++)
{ {
shift = idct_tbl[p_jpeg->v_scale[i]].v_scale + shift = idct_tbl[p_jpeg->v_scale[i]].v_scale +
@ -1514,9 +1515,9 @@ INLINE void fix_quant_tables(struct jpeg *p_jpeg)
if (shift) if (shift)
{ {
a = 0; a = 0;
for (y = 0; y < 1 << p_jpeg->h_scale[i]; y++) for (y = 0; y < BIT_N(p_jpeg->h_scale[i]); y++)
{ {
for (x = 0; x < 1 << p_jpeg->v_scale[i]; x++) for (x = 0; x < BIT_N(p_jpeg->v_scale[i]); x++)
p_jpeg->quanttable[i][zig[a+x]] <<= shift; p_jpeg->quanttable[i][zig[a+x]] <<= shift;
a += 8; a += 8;
} }
@ -1586,7 +1587,7 @@ INLINE int get_bits(struct jpeg *p_jpeg, int nbits)
#ifdef JPEG_BS_DEBUG #ifdef JPEG_BS_DEBUG
if (nbits > p_jpeg->bitbuf_bits) if (nbits > p_jpeg->bitbuf_bits)
DEBUGF("bitbuffer underrun\n"); DEBUGF("bitbuffer underrun\n");
int mask = 1 << (p_jpeg->bitbuf_bits - 1); int mask = BIT_N(p_jpeg->bitbuf_bits - 1);
int i; int i;
DEBUGF("get %d bits: ", nbits); DEBUGF("get %d bits: ", nbits);
for (i = 0; i < nbits; i++) for (i = 0; i < nbits; i++)
@ -1594,13 +1595,13 @@ INLINE int get_bits(struct jpeg *p_jpeg, int nbits)
DEBUGF("\n"); DEBUGF("\n");
#endif #endif
return ((int) (p_jpeg->bitbuf >> (p_jpeg->bitbuf_bits -= nbits))) & return ((int) (p_jpeg->bitbuf >> (p_jpeg->bitbuf_bits -= nbits))) &
((1<<nbits)-1); (BIT_N(nbits)-1);
} }
INLINE int peek_bits(struct jpeg *p_jpeg, int nbits) INLINE int peek_bits(struct jpeg *p_jpeg, int nbits)
{ {
#ifdef JPEG_BS_DEBUG #ifdef JPEG_BS_DEBUG
int mask = 1 << (p_jpeg->bitbuf_bits - 1); int mask = BIT_N(p_jpeg->bitbuf_bits - 1);
int i; int i;
DEBUGF("peek %d bits: ", nbits); DEBUGF("peek %d bits: ", nbits);
for (i = 0; i < nbits; i++) for (i = 0; i < nbits; i++)
@ -1608,13 +1609,13 @@ INLINE int peek_bits(struct jpeg *p_jpeg, int nbits)
DEBUGF("\n"); DEBUGF("\n");
#endif #endif
return ((int) (p_jpeg->bitbuf >> (p_jpeg->bitbuf_bits - nbits))) & return ((int) (p_jpeg->bitbuf >> (p_jpeg->bitbuf_bits - nbits))) &
((1<<nbits)-1); (BIT_N(nbits)-1);
} }
INLINE void drop_bits(struct jpeg *p_jpeg, int nbits) INLINE void drop_bits(struct jpeg *p_jpeg, int nbits)
{ {
#ifdef JPEG_BS_DEBUG #ifdef JPEG_BS_DEBUG
int mask = 1 << (p_jpeg->bitbuf_bits - 1); int mask = BIT_N(p_jpeg->bitbuf_bits - 1);
int i; int i;
DEBUGF("drop %d bits: ", nbits); DEBUGF("drop %d bits: ", nbits);
for (i = 0; i < nbits; i++) for (i = 0; i < nbits; i++)
@ -1675,7 +1676,7 @@ static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
({ \ ({ \
int x__ = x; \ int x__ = x; \
int s__ = s; \ int s__ = s; \
x__ & (1 << (s__- 1)) ? x__ : x__ + (-1 << s__) + 1; \ x__ & BIT_N(s__- 1) ? x__ : x__ + (-1 << s__) + 1; \
}) })
#endif #endif
@ -1764,14 +1765,14 @@ static struct img_part *store_row_jpeg(void *jpeg_args)
#endif #endif
unsigned int width = p_jpeg->x_mbl << mcu_hscale; unsigned int width = p_jpeg->x_mbl << mcu_hscale;
unsigned int b_width = width * JPEG_PIX_SZ; unsigned int b_width = width * JPEG_PIX_SZ;
int height = 1U << mcu_vscale; int height = BIT_N(mcu_vscale);
int x; int x;
if (!p_jpeg->mcu_row) /* Need to decode a new row of MCUs */ if (!p_jpeg->mcu_row) /* Need to decode a new row of MCUs */
{ {
p_jpeg->out_ptr = (unsigned char *)p_jpeg->img_buf; p_jpeg->out_ptr = (unsigned char *)p_jpeg->img_buf;
int store_offs[4]; int store_offs[4];
#ifdef HAVE_LCD_COLOR #ifdef HAVE_LCD_COLOR
unsigned mcu_width = 1U << mcu_hscale; unsigned mcu_width = BIT_N(mcu_hscale);
#endif #endif
int mcu_offset = JPEG_PIX_SZ << mcu_hscale; int mcu_offset = JPEG_PIX_SZ << mcu_hscale;
unsigned char *out = p_jpeg->out_ptr; unsigned char *out = p_jpeg->out_ptr;
@ -1868,8 +1869,8 @@ static struct img_part *store_row_jpeg(void *jpeg_args)
if (!ci) if (!ci)
#endif #endif
{ {
int idct_cols = 1 << MIN(p_jpeg->h_scale[!!ci], 3); int idct_cols = BIT_N(MIN(p_jpeg->h_scale[!!ci], 3));
int idct_rows = 1 << p_jpeg->v_scale[!!ci]; int idct_rows = BIT_N(p_jpeg->v_scale[!!ci]);
unsigned char *b_out = out + (ci ? ci : store_offs[blkn]); unsigned char *b_out = out + (ci ? ci : store_offs[blkn]);
if (idct_tbl[p_jpeg->v_scale[!!ci]].v_idct) if (idct_tbl[p_jpeg->v_scale[!!ci]].v_idct)
idct_tbl[p_jpeg->v_scale[!!ci]].v_idct(block, idct_tbl[p_jpeg->v_scale[!!ci]].v_idct(block,
@ -2043,8 +2044,8 @@ int read_jpeg_fd(int fd,
} }
p_jpeg->h_scale[0] = calc_scale(p_jpeg->x_size, bm->width); p_jpeg->h_scale[0] = calc_scale(p_jpeg->x_size, bm->width);
p_jpeg->v_scale[0] = calc_scale(p_jpeg->y_size, bm->height); p_jpeg->v_scale[0] = calc_scale(p_jpeg->y_size, bm->height);
JDEBUGF("luma IDCT size: %dx%d\n", 1 << p_jpeg->h_scale[0], JDEBUGF("luma IDCT size: %dx%d\n", BIT_N(p_jpeg->h_scale[0]),
1 << p_jpeg->v_scale[0]); BIT_N(p_jpeg->v_scale[0]));
if ((p_jpeg->x_size << p_jpeg->h_scale[0]) >> 3 == bm->width && if ((p_jpeg->x_size << p_jpeg->h_scale[0]) >> 3 == bm->width &&
(p_jpeg->y_size << p_jpeg->v_scale[0]) >> 3 == bm->height) (p_jpeg->y_size << p_jpeg->v_scale[0]) >> 3 == bm->height)
resize = false; resize = false;
@ -2053,24 +2054,24 @@ int read_jpeg_fd(int fd,
p_jpeg->frameheader[0].horizontal_sampling - 1; p_jpeg->frameheader[0].horizontal_sampling - 1;
p_jpeg->v_scale[1] = p_jpeg->v_scale[0] + p_jpeg->v_scale[1] = p_jpeg->v_scale[0] +
p_jpeg->frameheader[0].vertical_sampling - 1; p_jpeg->frameheader[0].vertical_sampling - 1;
JDEBUGF("chroma IDCT size: %dx%d\n", 1 << p_jpeg->h_scale[1], JDEBUGF("chroma IDCT size: %dx%d\n", BIT_N(p_jpeg->h_scale[1]),
1 << p_jpeg->v_scale[1]); BIT_N(p_jpeg->v_scale[1]));
#endif #endif
JDEBUGF("scaling from %dx%d -> %dx%d\n", JDEBUGF("scaling from %dx%d -> %dx%d\n",
(p_jpeg->x_size << p_jpeg->h_scale[0]) >> 3, (p_jpeg->x_size << p_jpeg->h_scale[0]) >> 3,
(p_jpeg->y_size << p_jpeg->v_scale[0]) >> 3, (p_jpeg->y_size << p_jpeg->v_scale[0]) >> 3,
bm->width, bm->height); bm->width, bm->height);
fix_quant_tables(p_jpeg); fix_quant_tables(p_jpeg);
int decode_w = (1 << p_jpeg->h_scale[0]) - 1; int decode_w = BIT_N(p_jpeg->h_scale[0]) - 1;
int decode_h = (1 << p_jpeg->v_scale[0]) - 1; int decode_h = BIT_N(p_jpeg->v_scale[0]) - 1;
src_dim.width = (p_jpeg->x_size << p_jpeg->h_scale[0]) >> 3; src_dim.width = (p_jpeg->x_size << p_jpeg->h_scale[0]) >> 3;
src_dim.height = (p_jpeg->y_size << p_jpeg->v_scale[0]) >> 3; src_dim.height = (p_jpeg->y_size << p_jpeg->v_scale[0]) >> 3;
p_jpeg->zero_need[0] = (decode_h << 3) + decode_w; p_jpeg->zero_need[0] = (decode_h << 3) + decode_w;
p_jpeg->k_need[0] = zig[p_jpeg->zero_need[0]]; p_jpeg->k_need[0] = zig[p_jpeg->zero_need[0]];
JDEBUGF("need luma components to %d\n", p_jpeg->k_need[0]); JDEBUGF("need luma components to %d\n", p_jpeg->k_need[0]);
#ifdef HAVE_LCD_COLOR #ifdef HAVE_LCD_COLOR
decode_w = (1 << MIN(p_jpeg->h_scale[1],3)) - 1; decode_w = BIT_N(MIN(p_jpeg->h_scale[1],3)) - 1;
decode_h = (1 << MIN(p_jpeg->v_scale[1],3)) - 1; decode_h = BIT_N(MIN(p_jpeg->v_scale[1],3)) - 1;
p_jpeg->zero_need[1] = (decode_h << 3) + decode_w; p_jpeg->zero_need[1] = (decode_h << 3) + decode_w;
p_jpeg->k_need[1] = zig[p_jpeg->zero_need[1]]; p_jpeg->k_need[1] = zig[p_jpeg->zero_need[1]];
JDEBUGF("need chroma components to %d\n", p_jpeg->k_need[1]); JDEBUGF("need chroma components to %d\n", p_jpeg->k_need[1]);

6
apps/replaygain.c
View file

@ -134,12 +134,12 @@ static long fp_div(long x, long y)
y = -y; y = -y;
} }
while ((x & (1 << (30 - msb))) == 0) while ((x & BIT_N(30 - msb)) == 0)
{ {
msb++; msb++;
} }
while ((y & (1 << lsb)) == 0) while ((y & BIT_N(lsb)) == 0)
{ {
lsb++; lsb++;
} }
@ -216,7 +216,7 @@ static long fp_exp10(long x)
static long fp_atof(const char* s, int precision) static long fp_atof(const char* s, int precision)
{ {
long int_part = 0; long int_part = 0;
long int_one = 1 << precision; long int_one = BIT_N(precision);
long frac_part = 0; long frac_part = 0;
long frac_count = 0; long frac_count = 0;
long frac_max = ((precision * 4) + 12) / 13; long frac_max = ((precision * 4) + 12) / 13;

2
apps/screens.c
View file

@ -339,7 +339,7 @@ static void charging_display_info(bool animate)
bitpos = (phase + i/8) % 15; /* "bounce" effect */ bitpos = (phase + i/8) % 15; /* "bounce" effect */
if (bitpos > 7) if (bitpos > 7)
bitpos = 14 - bitpos; bitpos = 14 - bitpos;
charging_logo[i] = 0x01 << bitpos; charging_logo[i] = BIT_N(bitpos);
} }
} }
lcd_mono_bitmap(charging_logo, pox_x, pox_y + 8, lcd_mono_bitmap(charging_logo, pox_x, pox_y + 8,

6
firmware/drivers/ata.c
View file

@ -1268,7 +1268,7 @@ static int set_multiple_mode(int sectors)
#ifdef HAVE_ATA_DMA #ifdef HAVE_ATA_DMA
static int get_best_mode(unsigned short identword, int max, int modetype) static int get_best_mode(unsigned short identword, int max, int modetype)
{ {
unsigned short testbit = 1u << max; unsigned short testbit = BIT_N(max);
while (1) { while (1) {
if (identword & testbit) if (identword & testbit)
@ -1335,7 +1335,7 @@ static int set_features(void)
} }
for (i=0; i < (int)(sizeof(features)/sizeof(features[0])); i++) { for (i=0; i < (int)(sizeof(features)/sizeof(features[0])); i++) {
if (identify_info[features[i].id_word] & (1u << features[i].id_bit)) { if (identify_info[features[i].id_word] & BIT_N(features[i].id_bit)) {
SET_REG(ATA_FEATURE, features[i].subcommand); SET_REG(ATA_FEATURE, features[i].subcommand);
SET_REG(ATA_NSECTOR, features[i].parameter); SET_REG(ATA_NSECTOR, features[i].parameter);
SET_REG(ATA_COMMAND, CMD_SET_FEATURES); SET_REG(ATA_COMMAND, CMD_SET_FEATURES);
@ -1461,7 +1461,7 @@ int ata_init(void)
#ifdef MAX_PHYS_SECTOR_SIZE #ifdef MAX_PHYS_SECTOR_SIZE
/* Find out the physical sector size */ /* Find out the physical sector size */
if((identify_info[106] & 0xe000) == 0x6000) if((identify_info[106] & 0xe000) == 0x6000)
phys_sector_mult = 1 << (identify_info[106] & 0x000f); phys_sector_mult = BIT_N(identify_info[106] & 0x000f);
else else
phys_sector_mult = 1; phys_sector_mult = 1;

2
firmware/drivers/ata_mmc.c
View file

@ -450,7 +450,7 @@ static int initialize_card(int card_no)
card->tsac = card->tsac * exponent[taac_exp] / 10; card->tsac = card->tsac * exponent[taac_exp] / 10;
/* r2w_factor, write timeout */ /* r2w_factor, write timeout */
card->r2w_factor = 1 << card_extract_bits(card->csd, 99, 3); card->r2w_factor = BIT_N(card_extract_bits(card->csd, 99, 3));
card->write_timeout = card->read_timeout * card->r2w_factor; card->write_timeout = card->read_timeout * card->r2w_factor;
if (card->r2w_factor > 32) /* Such cards often need extra read delay */ if (card->r2w_factor > 32) /* Such cards often need extra read delay */

8
firmware/drivers/lcd-1bit-vert.c
View file

@ -155,17 +155,17 @@ int LCDFN(getstringsize)(const unsigned char *str, int *w, int *h)
static void setpixel(int x, int y) static void setpixel(int x, int y)
{ {
LCDFN(framebuffer)[y>>3][x] |= 1 << (y & 7); LCDFN(framebuffer)[y>>3][x] |= BIT_N(y & 7);
} }
static void clearpixel(int x, int y) static void clearpixel(int x, int y)
{ {
LCDFN(framebuffer)[y>>3][x] &= ~(1 << (y & 7)); LCDFN(framebuffer)[y>>3][x] &= ~BIT_N(y & 7);
} }
static void flippixel(int x, int y) static void flippixel(int x, int y)
{ {
LCDFN(framebuffer)[y>>3][x] ^= 1 << (y & 7); LCDFN(framebuffer)[y>>3][x] ^= BIT_N(y & 7);
} }
static void nopixel(int x, int y) static void nopixel(int x, int y)
@ -401,7 +401,7 @@ void LCDFN(hline)(int x1, int x2, int y)
bfunc = LCDFN(blockfuncs)[current_vp->drawmode]; bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
dst = &LCDFN(framebuffer)[y>>3][x1]; dst = &LCDFN(framebuffer)[y>>3][x1];
mask = 1 << (y & 7); mask = BIT_N(y & 7);
dst_end = dst + width; dst_end = dst + width;
do do

4
firmware/screendump.c
View file

@ -169,7 +169,7 @@ void screen_dump(void)
#if LCD_DEPTH == 1 #if LCD_DEPTH == 1
dst_end = dst + LCD_WIDTH/2; dst_end = dst + LCD_WIDTH/2;
src = lcd_framebuffer[y >> 3]; src = lcd_framebuffer[y >> 3];
mask = 1 << (y & 7); mask = BIT_N(y & 7);
do do
{ {
@ -333,7 +333,7 @@ void remote_screen_dump(void)
#if LCD_REMOTE_DEPTH == 1 #if LCD_REMOTE_DEPTH == 1
dst_end = dst + LCD_REMOTE_WIDTH/2; dst_end = dst + LCD_REMOTE_WIDTH/2;
src = lcd_remote_framebuffer[y >> 3]; src = lcd_remote_framebuffer[y >> 3];
mask = 1 << (y & 7); mask = BIT_N(y & 7);
do do
{ {