mirrors/libstb-hal
1
0
Fork 0
mirror of https://github.com/tuxbox-neutrino/libstb-hal.git synced 2025-08-26 23:13:16 +02:00
Code Issues Packages Projects Releases Wiki Activity

- libeplayer3: fix __inline is not at beginning of declaration [-Wold-style-declaration]

Browse Source
This commit is contained in:
max_10
2019-11-11 23:15:48 +01:00
committed by Thilo Graf
parent 69a371a709
commit 0f85aa4f60
5 changed files with 45 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
libeplayer3-arm/external/flv2mpeg4/src/bitreader.h vendored
View File

@@ -139,7 +139,7 @@ static void align_bits(BR *p)
} }
} }
static int __inline get_br_pos(BR *p) static inline int get_br_pos(BR *p)
{ {
return (p->read << 3) + p->bitoffset; return (p->read << 3) + p->bitoffset;
} }
@@ -150,7 +150,7 @@ typedef struct _VLCtab
int n; int n;
} VLCtab; } VLCtab;
static int __inline get_vlc(BR *br, const VLCtab *table, int bits, int max_depth) static inline int get_vlc(BR *br, const VLCtab *table, int bits, int max_depth)
{ {
int n, index, nb_bits, code; int n, index, nb_bits, code;
index = show_bits(br, bits); index = show_bits(br, bits);
@@ -171,7 +171,7 @@ static int __inline get_vlc(BR *br, const VLCtab *table, int bits, int max_depth
return code; return code;
} }
static int __inline get_vlcdec(BR *p, const VLCtab *table, int bits, int max_depth, VLCDEC *vlcdec) static inline int get_vlcdec(BR *p, const VLCtab *table, int bits, int max_depth, VLCDEC *vlcdec)
{ {
int pos = get_br_pos(p); int pos = get_br_pos(p);
uint32 show = show_bits(p, 24); uint32 show = show_bits(p, 24);

19
libeplayer3-arm/external/flv2mpeg4/src/bitwriter.h vendored
View File

@@ -40,21 +40,21 @@ typedef struct _BW
} BW; } BW;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static void __inline clear_bw(BW *p) static inline void clear_bw(BW *p)
{ {
p->pos = 0; p->pos = 0;
p->bitoffset = 0; p->bitoffset = 0;
p->tmp = 0; p->tmp = 0;
} }
static void __inline init_bw(BW *p, uint8 *buf, uint32 size) static inline void init_bw(BW *p, uint8 *buf, uint32 size)
{ {
p->buf = buf; p->buf = buf;
p->size = size; p->size = size;
clear_bw(p); clear_bw(p);
} }
static void __inline forword_bits(BW *p, uint32 bits) static inline void forword_bits(BW *p, uint32 bits)
{ {
p->bitoffset += bits; p->bitoffset += bits;
@@ -70,7 +70,7 @@ static void __inline forword_bits(BW *p, uint32 bits)
} }
} }
static void __inline put_bits(BW *p, uint32 bits, uint32 value) static inline void put_bits(BW *p, uint32 bits, uint32 value)
{ {
uint32 shift = 32 - p->bitoffset - bits; uint32 shift = 32 - p->bitoffset - bits;
@@ -90,7 +90,7 @@ static void __inline put_bits(BW *p, uint32 bits, uint32 value)
} }
} }
static void __inline pad_to_boundary(BW *p) static inline void pad_to_boundary(BW *p)
{ {
uint32 bits = 8 - (p->bitoffset % 8); uint32 bits = 8 - (p->bitoffset % 8);
if (bits < 8) if (bits < 8)
@@ -99,7 +99,7 @@ static void __inline pad_to_boundary(BW *p)
} }
} }
static void __inline flash_bw(BW *p) static inline void flash_bw(BW *p)
{ {
pad_to_boundary(p); pad_to_boundary(p);
@@ -120,7 +120,6 @@ static void __inline flash_bw(BW *p)
p->buf[p->pos++] = (p->tmp >> 8) & 0xff; p->buf[p->pos++] = (p->tmp >> 8) & 0xff;
break; break;
default: default:
// fprintf(stderr, "flash_bw error!(%d)\n", p->bitoffset);
break; break;
} }
@@ -128,18 +127,18 @@ static void __inline flash_bw(BW *p)
p->bitoffset = 0; p->bitoffset = 0;
} }
static uint32 __inline get_bw_pos(BW *p) static inline uint32 get_bw_pos(BW *p)
{ {
return p->pos * 8 + p->bitoffset; return p->pos * 8 + p->bitoffset;
} }
static void __inline put_vlcdec(BW *bw, VLCDEC *vlcdec) static inline void put_vlcdec(BW *bw, VLCDEC *vlcdec)
{ {
put_bits(bw, vlcdec->bits, vlcdec->value); put_bits(bw, vlcdec->bits, vlcdec->value);
} }
// M4V ADDED // M4V ADDED
static void __inline m4v_stuffing(BW *p) static inline void m4v_stuffing(BW *p)
{ {
int length; int length;

6
libeplayer3-arm/external/flv2mpeg4/src/dcprediction.c vendored
View File

@@ -40,7 +40,7 @@ static const uint8 mpeg4_c_dc_scale_table[32] =
0, 8, 8, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 20, 21, 22, 23, 24, 25 0, 8, 8, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 20, 21, 22, 23, 24, 25
}; };
static int __inline get_pred(int *dc_cur, int stride, int scale) static inline int get_pred(int *dc_cur, int stride, int scale)
{ {
/* B C /* B C
A X */ A X */
@@ -62,7 +62,7 @@ static int __inline get_pred(int *dc_cur, int stride, int scale)
return (pred + (scale >> 1)) / scale; return (pred + (scale >> 1)) / scale;
} }
static void __inline set_dc_to_dc_cur(int *dc_cur, int level, int scale) static inline void set_dc_to_dc_cur(int *dc_cur, int level, int scale)
{ {
level *= scale; level *= scale;
if (level & (~2047)) if (level & (~2047))
@@ -88,7 +88,7 @@ static int *get_dc_cur(M4V_DCPRED *pred, int mb_x, int mb_y, int n)
} }
} }
static int __inline get_scale(M4V_DCPRED *pred, int n) static inline int get_scale(M4V_DCPRED *pred, int n)
{ {
if (n < 4) if (n < 4)
{ {

25
libeplayer3-arm/external/flv2mpeg4/src/flvdecoder.c vendored
View File

@@ -174,7 +174,7 @@ static const VLCtab vlc_table_mv[] = //mv_vlc: table_size=538 table_allocated=10
////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static int __inline decode_DC(BR *p) static inline int decode_DC(BR *p)
{ {
int level = get_bits(p, 8); int level = get_bits(p, 8);
if ((level & 0x7f) == 0) if ((level & 0x7f) == 0)
@@ -188,7 +188,7 @@ static int __inline decode_DC(BR *p)
return level; return level;
} }
static int __inline decode_AC(BR *p, BLOCK *block, int escape_type, int i) static inline int decode_AC(BR *p, BLOCK *block, int escape_type, int i)
{ {
int code, run, level, last, sign; int code, run, level, last, sign;
@@ -253,7 +253,7 @@ static int __inline decode_AC(BR *p, BLOCK *block, int escape_type, int i)
return 0; return 0;
} }
static int __inline decode_intra_block(BR *p, BLOCK *block, int escape_type, int coded) static inline int decode_intra_block(BR *p, BLOCK *block, int escape_type, int coded)
{ {
int level = decode_DC(p); int level = decode_DC(p);
if (level < 0) if (level < 0)
@@ -274,7 +274,7 @@ static int __inline decode_intra_block(BR *p, BLOCK *block, int escape_type, int
return 0; return 0;
} }
static int __inline decode_inter_block(BR *p, BLOCK *block, int escape_type, int coded) static inline int decode_inter_block(BR *p, BLOCK *block, int escape_type, int coded)
{ {
block->last_index = -1; block->last_index = -1;
@@ -287,7 +287,7 @@ static int __inline decode_inter_block(BR *p, BLOCK *block, int escape_type, int
return 0; return 0;
} }
static int __inline get_intra_MCBPC(BR *br) static inline int get_intra_MCBPC(BR *br)
{ {
int cbpc; int cbpc;
do do
@@ -299,7 +299,7 @@ static int __inline get_intra_MCBPC(BR *br)
return cbpc; return cbpc;
} }
static int __inline get_inter_MCBPC(BR *br) static inline int get_inter_MCBPC(BR *br)
{ {
int cbpc; int cbpc;
do do
@@ -316,18 +316,18 @@ static int __inline get_inter_MCBPC(BR *br)
return cbpc; return cbpc;
} }
static int __inline get_cbpy(BR *br) static inline int get_cbpy(BR *br)
{ {
return get_vlc(br, vlc_table_cbpy, 6, 1); return get_vlc(br, vlc_table_cbpy, 6, 1);
} }
static int __inline decode_dquant(BR *p) static inline int decode_dquant(BR *p)
{ {
static const int table[4] = { -1, -2, 1, 2 }; static const int table[4] = { -1, -2, 1, 2 };
return table[get_bits(p, 2)]; return table[get_bits(p, 2)];
} }
static int __inline decode_motion(BR *br, VLCDEC *vlcdec) static inline int decode_motion(BR *br, VLCDEC *vlcdec)
{ {
int tmp; int tmp;
int code = get_vlcdec(br, vlc_table_mv, 9, 2, vlcdec); int code = get_vlcdec(br, vlc_table_mv, 9, 2, vlcdec);
@@ -353,7 +353,7 @@ static int __inline decode_motion(BR *br, VLCDEC *vlcdec)
return 0; return 0;
} }
static int __inline decode_intra_mb_internal(BR *p, MICROBLOCK *mb, int escape_type, int qscale, int cbpc, int dquant) static inline int decode_intra_mb_internal(BR *p, MICROBLOCK *mb, int escape_type, int qscale, int cbpc, int dquant)
{ {
int cbpy, cbp; int cbpy, cbp;
int i; int i;
@@ -382,7 +382,7 @@ static int __inline decode_intra_mb_internal(BR *p, MICROBLOCK *mb, int escape_t
return 0; return 0;
} }
static int __inline decode_inter_mb_internal(BR *p, MICROBLOCK *mb, int escape_type, int qscale, int cbpc, int dquant) static inline int decode_inter_mb_internal(BR *p, MICROBLOCK *mb, int escape_type, int qscale, int cbpc, int dquant)
{ {
int cbpy, cbp; int cbpy, cbp;
int i; int i;
@@ -510,9 +510,6 @@ int decode_picture_header(BR *p, PICTURE *picture)
picture->escape_type = tmp; picture->escape_type = tmp;
picture->frame_number = get_bits(p, 8); picture->frame_number = get_bits(p, 8);
// printf("picture_format: %d\n", tmp);
// printf("picture_number: %d\n", get_bits(p, 8));
tmp = get_bits(p, 3); tmp = get_bits(p, 3);
switch (tmp) switch (tmp)
{ {

38
libeplayer3-arm/external/flv2mpeg4/src/m4vencode.c vendored
View File

@@ -60,7 +60,7 @@ static const uint32 vlce_inter_MCBPC_bits[28] =
}; };
////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static void __inline encode_DC(BW *p, int level, int n) static inline void encode_DC(BW *p, int level, int n)
{ {
if (level < -255 || level > 255) printf("dc overflow\n"); if (level < -255 || level > 255) printf("dc overflow\n");
@@ -111,7 +111,7 @@ static void __inline encode_DC(BW *p, int level, int n)
} }
static void __inline encode_escape_3(BW *p, int last, int run, int level) static inline void encode_escape_3(BW *p, int last, int run, int level)
{ {
#if 0 #if 0
put_bits(p, put_bits(p,
@@ -130,7 +130,7 @@ static void __inline encode_escape_3(BW *p, int last, int run, int level)
#define UNI_MPEG4_ENC_INDEX(last, run, level) ((last)*128*64 + (run)*128 + (level)) #define UNI_MPEG4_ENC_INDEX(last, run, level) ((last)*128*64 + (run)*128 + (level))
static void __inline encode_AC(BW *p, M4V_BLOCK *block, int intra) static inline void encode_AC(BW *p, M4V_BLOCK *block, int intra)
{ {
int i = intra; int i = intra;
int last_index = block->last_index; int last_index = block->last_index;
@@ -277,50 +277,50 @@ esc3:
} }
static void __inline encode_intra_block(BW *bw, M4V_BLOCK *block, int n) static inline void encode_intra_block(BW *bw, M4V_BLOCK *block, int n)
{ {
encode_DC(bw, block->block[0], n); encode_DC(bw, block->block[0], n);
encode_AC(bw, block, 1); encode_AC(bw, block, 1);
} }
static void __inline encode_inter_block(BW *bw, M4V_BLOCK *block) static inline void encode_inter_block(BW *bw, M4V_BLOCK *block)
{ {
encode_AC(bw, block, 0); encode_AC(bw, block, 0);
} }
// same as H.263 // same as H.263
static void __inline encode_intra_I_MCBPC(BW *bw, int cbpc) static inline void encode_intra_I_MCBPC(BW *bw, int cbpc)
{ {
put_bits(bw, vlce_intra_MCBPC_bits[cbpc], vlce_intra_MCBPC_code[cbpc]); put_bits(bw, vlce_intra_MCBPC_bits[cbpc], vlce_intra_MCBPC_code[cbpc]);
} }
// same as H.263 // same as H.263
static void __inline encode_intra_P_MCBPC(BW *bw, int cbpc) static inline void encode_intra_P_MCBPC(BW *bw, int cbpc)
{ {
put_bits(bw, vlce_inter_MCBPC_bits[cbpc + 4], vlce_inter_MCBPC_code[cbpc + 4]); put_bits(bw, vlce_inter_MCBPC_bits[cbpc + 4], vlce_inter_MCBPC_code[cbpc + 4]);
} }
// same as H.263 // same as H.263
static void __inline encode_inter_16x16_MCBPC(BW *bw, int cbpc) static inline void encode_inter_16x16_MCBPC(BW *bw, int cbpc)
{ {
put_bits(bw, vlce_inter_MCBPC_bits[cbpc], vlce_inter_MCBPC_code[cbpc]); put_bits(bw, vlce_inter_MCBPC_bits[cbpc], vlce_inter_MCBPC_code[cbpc]);
} }
// same as H.263 // same as H.263
static void __inline encode_inter_8x8_MCBPC(BW *bw, int cbpc) static inline void encode_inter_8x8_MCBPC(BW *bw, int cbpc)
{ {
put_bits(bw, vlce_inter_MCBPC_bits[cbpc + 16], vlce_inter_MCBPC_code[cbpc + 16]); put_bits(bw, vlce_inter_MCBPC_bits[cbpc + 16], vlce_inter_MCBPC_code[cbpc + 16]);
} }
// same as H.263 // same as H.263
static void __inline encode_cbpy(BW *bw, int cbpy) static inline void encode_cbpy(BW *bw, int cbpy)
{ {
put_bits(bw, vlce_cbpy_bits[cbpy], vlce_cbpy_code[cbpy]); put_bits(bw, vlce_cbpy_bits[cbpy], vlce_cbpy_code[cbpy]);
} }
// same as H.263 // same as H.263
static void __inline encode_dquant(BW *bw, int dquant) static inline void encode_dquant(BW *bw, int dquant)
{ {
const uint32 dquant_code[5] = {1, 0, -1, 2, 3}; const uint32 dquant_code[5] = {1, 0, -1, 2, 3};
if (dquant) if (dquant)
@@ -330,7 +330,7 @@ static void __inline encode_dquant(BW *bw, int dquant)
} }
// same as FLV // same as FLV
static void __inline encode_motion(BW *bw, VLCDEC *mv_x, VLCDEC *mv_y) static inline void encode_motion(BW *bw, VLCDEC *mv_x, VLCDEC *mv_y)
{ {
put_vlcdec(bw, mv_x); put_vlcdec(bw, mv_x);
if (mv_x->bits_ex) if (mv_x->bits_ex)
@@ -354,7 +354,7 @@ static void __inline encode_motion(BW *bw, VLCDEC *mv_x, VLCDEC *mv_y)
} }
// same as FLV // same as FLV
static void __inline encode_mb_inter_internal(BW *bw, M4V_MICROBLOCK *mb) static inline void encode_mb_inter_internal(BW *bw, M4V_MICROBLOCK *mb)
{ {
int cbp = 0, cbpc, cbpy; int cbp = 0, cbpc, cbpy;
int i; int i;
@@ -398,7 +398,7 @@ static void __inline encode_mb_inter_internal(BW *bw, M4V_MICROBLOCK *mb)
} }
} }
static void __inline encode_mb_intra_internal(BW *bw, M4V_MICROBLOCK *mb, int iframe) static inline void encode_mb_intra_internal(BW *bw, M4V_MICROBLOCK *mb, int iframe)
{ {
int cbp = 0, cbpc, cbpy; int cbp = 0, cbpc, cbpy;
int i; int i;
@@ -438,7 +438,7 @@ static void __inline encode_mb_intra_internal(BW *bw, M4V_MICROBLOCK *mb, int if
} }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static int __inline encode_vo_header(BW *p) static inline int encode_vo_header(BW *p)
{ {
put_bits(p, 16, 0); put_bits(p, 16, 0);
put_bits(p, 16, VOS_STARTCODE); put_bits(p, 16, VOS_STARTCODE);
@@ -459,7 +459,7 @@ static int __inline encode_vo_header(BW *p)
return 0; return 0;
} }
static int __inline encode_vol_header(BW *p, M4V_VOL *vol) static inline int encode_vol_header(BW *p, M4V_VOL *vol)
{ {
const int vo_number = 0; const int vo_number = 0;
const int vol_number = 0; const int vol_number = 0;
@@ -507,7 +507,7 @@ static int __inline encode_vol_header(BW *p, M4V_VOL *vol)
return 0; return 0;
} }
static int __inline encode_vop_header(BW *p, M4V_VOP *vop, int time_bits, int vop_not_coded) static inline int encode_vop_header(BW *p, M4V_VOP *vop, int time_bits, int vop_not_coded)
{ {
// static int time_old = 0; // static int time_old = 0;
@@ -572,7 +572,7 @@ static int __inline encode_vop_header(BW *p, M4V_VOP *vop, int time_bits, int vo
return 0; return 0;
} }
static __inline int encode_gop_header(BW *bw, uint32 time_ms) static inline int encode_gop_header(BW *bw, uint32 time_ms)
{ {
int sec, min, hour; int sec, min, hour;
@@ -600,7 +600,7 @@ static __inline int encode_gop_header(BW *bw, uint32 time_ms)
return 0; return 0;
} }
static int __inline encode_user_header(BW *p) static inline int encode_user_header(BW *p)
{ {
put_bits(p, 16, 0); put_bits(p, 16, 0);
put_bits(p, 16, USERDATA_STARTCODE); put_bits(p, 16, USERDATA_STARTCODE);