int nb_all_channels;
int lfe_channel;
int bit_rate;
- int sample_rate;
- int bsid;
- int frame_size_min; /* minimum frame size in case rounding is necessary */
- int frame_size; /* current frame size in words */
+ unsigned int sample_rate;
+ unsigned int bsid;
+ unsigned int frame_size_min; /* minimum frame size in case rounding is necessary */
+ unsigned int frame_size; /* current frame size in words */
int halfratecod;
- int frmsizecod;
- int fscod; /* frequency */
- int acmod;
+ unsigned int frmsizecod;
+ unsigned int fscod; /* frequency */
+ unsigned int acmod;
int lfe;
- int bsmod;
+ unsigned int bsmod;
short last_samples[AC3_MAX_CHANNELS][256];
- int chbwcod[AC3_MAX_CHANNELS];
+ unsigned int chbwcod[AC3_MAX_CHANNELS];
int nb_coefs[AC3_MAX_CHANNELS];
/* bitrate allocation control */
}
/* return the size in bits taken by the mantissa */
-int compute_mantissa_size(AC3EncodeContext *s, UINT8 *m, int nb_coefs)
+static int compute_mantissa_size(AC3EncodeContext *s, UINT8 *m, int nb_coefs)
{
int bits, mant, i;
#define GET_DATA(v, table, i, wrap, size) \
{\
- const UINT8 *ptr = (UINT8 *)table + i * wrap;\
+ const UINT8 *ptr = (const UINT8 *)table + i * wrap;\
switch(size) {\
case 1:\
- v = *(UINT8 *)ptr;\
+ v = *(const UINT8 *)ptr;\
break;\
case 2:\
- v = *(UINT16 *)ptr;\
+ v = *(const UINT16 *)ptr;\
break;\
default:\
- v = *(UINT32 *)ptr;\
+ v = *(const UINT32 *)ptr;\
break;\
}\
}
* see http://joe.hotchkiss.com/programming/eval/eval.html
*/
+#include "avcodec.h"
+#include "mpegvideo.h"
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int stack_index;
char *s;
double *const_value;
- char **const_name; // NULL terminated
+ const char **const_name; // NULL terminated
double (**func1)(void *, double a); // NULL terminated
- char **func1_name; // NULL terminated
+ const char **func1_name; // NULL terminated
double (**func2)(void *, double a, double b); // NULL terminated
char **func2_name; // NULL terminated
void *opaque;
return p->stack[ --p->stack_index ];
}
-static int strmatch(char *s, char *prefix){
+static int strmatch(const char *s, const char *prefix){
int i;
for(i=0; prefix[i]; i++){
if(prefix[i] != s[i]) return 0;
else if( strmatch(next, "log" ) ) d= log(d);
else if( strmatch(next, "squish") ) d= 1/(1+exp(4*d));
else if( strmatch(next, "gauss" ) ) d= exp(-d*d/2)/sqrt(2*M_PI);
- else if( strmatch(next, "abs" ) ) d= abs(d);
+ else if( strmatch(next, "abs" ) ) d= fabs(d);
else if( strmatch(next, "max" ) ) d= d > d2 ? d : d2;
else if( strmatch(next, "min" ) ) d= d < d2 ? d : d2;
else if( strmatch(next, "gt" ) ) d= d > d2 ? 1.0 : 0.0;
}
}
-double ff_eval(char *s, double *const_value, char **const_name,
- double (**func1)(void *, double), char **func1_name,
+double ff_eval(char *s, double *const_value, const char **const_name,
+ double (**func1)(void *, double), const char **func1_name,
double (**func2)(void *, double, double), char **func2_name,
void *opaque){
Parser p;
DCTELEM block[6][64],
int motion_x, int motion_y)
{
- int cbpc, cbpy, i, pred_x, pred_y;
+ int cbpc, cbpy, pred_x, pred_y;
int bits;
PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
// printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
if (!s->mb_intra) {
/* compute cbp */
- int cbp = 0;
+ int i, cbp = 0;
for (i = 0; i < 6; i++) {
if (s->block_last_index[i] >= 0)
cbp |= 1 << (5 - i);
int dc_diff[6]; //dc values with the dc prediction subtracted
int dir[6]; //prediction direction
int zigzag_last_index[6];
- UINT8 *scan_table[6];
+ UINT8 *scan_table[6];
+ int i;
for(i=0; i<6; i++){
const int level= block[i][0];
}
-void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
+static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
{
int x, y, wrap, a, c, pred_dc, scale, i;
INT16 *dc_val, *ac_val, *ac_val1;
// FIXME a bunch of grayscale shape things
if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
- int i, j, v;
+ int i, v;
/* load default matrixes */
for(i=0; i<64; i++){
/* load custom intra matrix */
if(get_bits1(gb)){
int last=0;
- for(i=0; i<64; i++){
+ for(i=0; i<64; i++){
+ int j;
v= get_bits(gb, 8);
if(v==0) break;
/* replicate last value */
for(; i<64; i++){
- j= s->idct_permutation[ ff_zigzag_direct[i] ];
+ int j= s->idct_permutation[ ff_zigzag_direct[i] ];
s->intra_matrix[j]= v;
s->chroma_intra_matrix[j]= v;
}
/* load custom non intra matrix */
if(get_bits1(gb)){
int last=0;
- for(i=0; i<64; i++){
+ for(i=0; i<64; i++){
+ int j;
v= get_bits(gb, 8);
if(v==0) break;
/* replicate last value */
for(; i<64; i++){
- j= s->idct_permutation[ ff_zigzag_direct[i] ];
+ int j= s->idct_permutation[ ff_zigzag_direct[i] ];
s->inter_matrix[j]= last;
s->chroma_inter_matrix[j]= last;
}
int mm_flags; /* multimedia extension flags */
/* FIXME use them in static form */
-int pix_abs16x16_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_x2_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_y2_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_xy2_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-
-int pix_abs16x16_mmx2(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_x2_mmx2(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_y2_mmx2(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_xy2_mmx2(UINT8 *blk1, UINT8 *blk2, int lx);
-
-int pix_abs8x8_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs8x8_x2_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs8x8_y2_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs8x8_xy2_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-
-int pix_abs8x8_mmx2(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs8x8_x2_mmx2(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs8x8_y2_mmx2(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs8x8_xy2_mmx2(UINT8 *blk1, UINT8 *blk2, int lx);
-
-int sad16x16_mmx(void *s, UINT8 *blk1, UINT8 *blk2, int lx);
-int sad8x8_mmx(void *s, UINT8 *blk1, UINT8 *blk2, int lx);
-int sad16x16_mmx2(void *s, UINT8 *blk1, UINT8 *blk2, int lx);
-int sad8x8_mmx2(void *s, UINT8 *blk1, UINT8 *blk2, int lx);
+void dsputil_init_pix_mmx(DSPContext* c, unsigned mask);
/* pixel operations */
static const uint64_t mm_bone __attribute__ ((aligned(8))) = 0x0101010101010101ULL;
OP(%%mm5, out, %%mm7, d)
#define QPEL_BASE(OPNAME, ROUNDER, RND, OP_MMX2, OP_3DNOW)\
-void OPNAME ## mpeg4_qpel16_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
+static void OPNAME ## mpeg4_qpel16_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
uint64_t temp;\
\
asm volatile(\
}\
}\
\
-void OPNAME ## mpeg4_qpel8_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
+static void OPNAME ## mpeg4_qpel8_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
uint64_t temp;\
\
asm volatile(\
);\
}\
\
-void OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
uint64_t temp[9*4];\
uint64_t *temp_ptr= temp;\
int count= 9;\
c->clear_blocks = clear_blocks_mmx;
c->pix_sum = pix_sum16_mmx;
- c->pix_abs16x16 = pix_abs16x16_mmx;
- c->pix_abs16x16_x2 = pix_abs16x16_x2_mmx;
- c->pix_abs16x16_y2 = pix_abs16x16_y2_mmx;
- c->pix_abs16x16_xy2 = pix_abs16x16_xy2_mmx;
- c->pix_abs8x8 = pix_abs8x8_mmx;
- c->pix_abs8x8_x2 = pix_abs8x8_x2_mmx;
- c->pix_abs8x8_y2 = pix_abs8x8_y2_mmx;
- c->pix_abs8x8_xy2 = pix_abs8x8_xy2_mmx;
-
c->put_pixels_tab[0][0] = put_pixels16_mmx;
c->put_pixels_tab[0][1] = put_pixels16_x2_mmx;
c->put_pixels_tab[0][2] = put_pixels16_y2_mmx;
c->hadamard8_diff[0]= hadamard8_diff16_mmx;
c->hadamard8_diff[1]= hadamard8_diff_mmx;
- c->sad[0]= sad16x16_mmx;
- c->sad[1]= sad8x8_mmx;
-
c->pix_norm1 = pix_norm1_mmx;
c->sse[0] = sse16_mmx;
if (mm_flags & MM_MMXEXT) {
- c->pix_abs16x16 = pix_abs16x16_mmx2;
- c->pix_abs16x16_x2 = pix_abs16x16_x2_mmx2;
- c->pix_abs16x16_y2 = pix_abs16x16_y2_mmx2;
- c->pix_abs16x16_xy2 = pix_abs16x16_xy2_mmx2;
-
- c->pix_abs8x8 = pix_abs8x8_mmx2;
- c->pix_abs8x8_x2 = pix_abs8x8_x2_mmx2;
- c->pix_abs8x8_y2 = pix_abs8x8_y2_mmx2;
- c->pix_abs8x8_xy2 = pix_abs8x8_xy2_mmx2;
-
- c->sad[0]= sad16x16_mmx2;
- c->sad[1]= sad8x8_mmx2;
-
c->put_pixels_tab[0][1] = put_pixels16_x2_mmx2;
c->put_pixels_tab[0][2] = put_pixels16_y2_mmx2;
c->put_no_rnd_pixels_tab[0][1] = put_no_rnd_pixels16_x2_mmx2;
SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_3dnow)
}
}
-
+ dsputil_init_pix_mmx(c, mask);
#if 0
// for speed testing
get_pixels = just_return;
c->put_no_rnd_pixels_tab[1][1] = put_no_rnd_pixels8_x2_mmx;
c->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_mmx;
c->avg_pixels_tab[1][3] = avg_pixels8_xy2_mmx;
-
- if (mm_flags & MM_MMXEXT) {
- c->pix_abs16x16_x2 = pix_abs16x16_x2_mmx;
- c->pix_abs16x16_y2 = pix_abs16x16_y2_mmx;
- c->pix_abs16x16_xy2 = pix_abs16x16_xy2_mmx;
- c->pix_abs8x8_x2 = pix_abs8x8_x2_mmx;
- c->pix_abs8x8_y2 = pix_abs8x8_y2_mmx;
- c->pix_abs8x8_xy2= pix_abs8x8_xy2_mmx;
- }
}
+ dsputil_set_bit_exact_pix_mmx(c, mask);
}
*/
#include "../dsputil.h"
+void dsputil_init_pix_mmx(DSPContext* c, unsigned mask);
+void dsputil_set_bit_exact_pix_mmx(DSPContext* c, unsigned mask);
+
static const __attribute__ ((aligned(8))) UINT64 round_tab[3]={
0x0000000000000000,
0x0001000100010001,
asm volatile(
".balign 16 \n\t"
"movq "MANGLE(bone)", %%mm5 \n\t"
- "1: \n\t"
+ "1: \n\t"
"movq (%1, %%eax), %%mm0 \n\t"
"movq (%2, %%eax), %%mm2 \n\t"
"movq 1(%1, %%eax), %%mm1 \n\t"
"punpckhbw %%mm7, %%mm3 \n\t"
"paddw %%mm0, %%mm1 \n\t"
"paddw %%mm2, %%mm3 \n\t"
- "movq (%3, %%eax), %%mm4 \n\t"
+ "movq (%3, %%eax), %%mm4 \n\t"
"movq (%3, %%eax), %%mm2 \n\t"
"paddw %%mm5, %%mm1 \n\t"
"paddw %%mm5, %%mm3 \n\t"
"punpckhbw %%mm7, %%mm4 \n\t"
"paddw %%mm3, %%mm2 \n\t"
"paddw %%mm4, %%mm1 \n\t"
- "movq (%3, %%eax), %%mm3 \n\t"
- "movq (%3, %%eax), %%mm4 \n\t"
+ "movq (%3, %%eax), %%mm3 \n\t"
+ "movq (%3, %%eax), %%mm4 \n\t"
"paddw %%mm5, %%mm2 \n\t"
"paddw %%mm5, %%mm1 \n\t"
"psrlw $2, %%mm2 \n\t"
);
}
-static inline int sum_mmx()
+static inline int sum_mmx(void)
{
int ret;
asm volatile(
return ret&0xFFFF;
}
-static inline int sum_mmx2()
+static inline int sum_mmx2(void)
{
int ret;
asm volatile(
#define PIX_SAD(suf)\
-int pix_abs8x8_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs8x8_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t":);\
\
return sum_ ## suf();\
}\
-int sad8x8_ ## suf(void *s, UINT8 *blk2, UINT8 *blk1, int stride)\
+static int sad8x8_ ## suf(void *s, UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t":);\
return sum_ ## suf();\
}\
\
-int pix_abs8x8_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs8x8_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t"\
return sum_ ## suf();\
}\
\
-int pix_abs8x8_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs8x8_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t"\
return sum_ ## suf();\
}\
\
-int pix_abs8x8_xy2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs8x8_xy2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t"\
return sum_ ## suf();\
}\
\
-int pix_abs16x16_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs16x16_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t":);\
\
return sum_ ## suf();\
}\
-int sad16x16_ ## suf(void *s, UINT8 *blk2, UINT8 *blk1, int stride)\
+static int sad16x16_ ## suf(void *s, UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t":);\
\
return sum_ ## suf();\
}\
-int pix_abs16x16_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs16x16_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t"\
\
return sum_ ## suf();\
}\
-int pix_abs16x16_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs16x16_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t"\
\
return sum_ ## suf();\
}\
-int pix_abs16x16_xy2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs16x16_xy2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
{\
asm volatile("pxor %%mm7, %%mm7 \n\t"\
"pxor %%mm6, %%mm6 \n\t"\
PIX_SAD(mmx)
PIX_SAD(mmx2)
+
+void dsputil_init_pix_mmx(DSPContext* c, unsigned mask)
+{
+ if (mm_flags & MM_MMX) {
+ c->pix_abs16x16 = pix_abs16x16_mmx;
+ c->pix_abs16x16_x2 = pix_abs16x16_x2_mmx;
+ c->pix_abs16x16_y2 = pix_abs16x16_y2_mmx;
+ c->pix_abs16x16_xy2 = pix_abs16x16_xy2_mmx;
+ c->pix_abs8x8 = pix_abs8x8_mmx;
+ c->pix_abs8x8_x2 = pix_abs8x8_x2_mmx;
+ c->pix_abs8x8_y2 = pix_abs8x8_y2_mmx;
+ c->pix_abs8x8_xy2 = pix_abs8x8_xy2_mmx;
+
+ c->sad[0]= sad16x16_mmx;
+ c->sad[1]= sad8x8_mmx;
+ }
+ if (mm_flags & MM_MMXEXT) {
+ c->pix_abs16x16 = pix_abs16x16_mmx2;
+ c->pix_abs16x16_x2 = pix_abs16x16_x2_mmx2;
+ c->pix_abs16x16_y2 = pix_abs16x16_y2_mmx2;
+ c->pix_abs16x16_xy2 = pix_abs16x16_xy2_mmx2;
+ c->pix_abs8x8 = pix_abs8x8_mmx2;
+ c->pix_abs8x8_x2 = pix_abs8x8_x2_mmx2;
+ c->pix_abs8x8_y2 = pix_abs8x8_y2_mmx2;
+ c->pix_abs8x8_xy2 = pix_abs8x8_xy2_mmx2;
+
+ c->sad[0]= sad16x16_mmx2;
+ c->sad[1]= sad8x8_mmx2;
+ }
+}
+
+void dsputil_set_bit_exact_pix_mmx(DSPContext* c, unsigned mask)
+{
+ if (mm_flags & MM_MMXEXT) {
+ c->pix_abs16x16_x2 = pix_abs16x16_x2_mmx;
+ c->pix_abs16x16_y2 = pix_abs16x16_y2_mmx;
+ c->pix_abs16x16_xy2 = pix_abs16x16_xy2_mmx;
+ c->pix_abs8x8_x2 = pix_abs8x8_x2_mmx;
+ c->pix_abs8x8_y2 = pix_abs8x8_y2_mmx;
+ c->pix_abs8x8_xy2 = pix_abs8x8_xy2_mmx;
+ }
+}
#define RGB_IN(r, g, b, s)\
{\
- unsigned int v = ((UINT16 *)(s))[0];\
+ unsigned int v = ((const UINT16 *)(s))[0];\
r = bitcopy_n(v >> (10 - 3), 3);\
g = bitcopy_n(v >> (5 - 3), 3);\
b = bitcopy_n(v << 3, 3);\
#define RGB_IN(r, g, b, s)\
{\
- unsigned int v = ((UINT16 *)(s))[0];\
+ unsigned int v = ((const UINT16 *)(s))[0];\
r = bitcopy_n(v >> (11 - 3), 3);\
g = bitcopy_n(v >> (5 - 2), 2);\
b = bitcopy_n(v << 3, 3);\
#define RGB_IN(r, g, b, s)\
{\
- unsigned int v = ((UINT32 *)(s))[0];\
+ unsigned int v = ((const UINT32 *)(s))[0];\
r = (v >> 16) & 0xff;\
g = (v >> 8) & 0xff;\
b = v & 0xff;\
static int avpicture_alloc(AVPicture *picture,
int pix_fmt, int width, int height)
{
- int size;
+ unsigned int size;
void *ptr;
size = avpicture_get_size(pix_fmt, width, height);
#ifdef USE_FASTMEMCPY
#include "fastmemcpy.h"
#endif
-extern int mm_flags;
#define NB_COMPONENTS 3
static int mjpeg_decode_com(MJpegDecodeContext *s)
{
- int len, i;
+ int i;
UINT8 *cbuf;
/* XXX: verify len field validity */
- len = get_bits(&s->gb, 16)-2;
+ unsigned int len = get_bits(&s->gb, 16)-2;
cbuf = av_malloc(len+1);
for (i = 0; i < len; i++)
}Minima;
static int minima_cmp(const void *a, const void *b){
- Minima *da = (Minima *) a;
- Minima *db = (Minima *) b;
+ const Minima *da = (const Minima *) a;
+ const Minima *db = (const Minima *) b;
return da->height - db->height;
}
return dmin;
}
-int ff_estimate_motion_b(MpegEncContext * s,
+static int ff_estimate_motion_b(MpegEncContext * s,
int mb_x, int mb_y, int16_t (*mv_table)[2], Picture *picture, int f_code)
{
int mx, my, range, dmin;
#include "mpegaudiotab.h"
-int MPA_encode_init(AVCodecContext *avctx)
+static int MPA_encode_init(AVCodecContext *avctx)
{
MpegAudioContext *s = avctx->priv_data;
int freq = avctx->sample_rate;
flush_put_bits(p);
}
-int MPA_encode_frame(AVCodecContext *avctx,
- unsigned char *frame, int buf_size, void *data)
+static int MPA_encode_frame(AVCodecContext *avctx,
+ unsigned char *frame, int buf_size, void *data)
{
MpegAudioContext *s = avctx->priv_data;
short *samples = data;
huff_code_table[0] = NULL;
for(i=1;i<16;i++) {
const HuffTable *h = &mpa_huff_tables[i];
- int xsize, n, x, y;
+ int xsize, x, y;
+ unsigned int n;
UINT8 *code_table;
xsize = h->xsize;
/*
* Seek back in the stream for backstep bytes (at most 511 bytes)
*/
-static void seek_to_maindata(MPADecodeContext *s, long backstep)
+static void seek_to_maindata(MPADecodeContext *s, unsigned int backstep)
{
UINT8 *ptr;
#ifndef AVCODEC_MPEGVIDEO_H
#define AVCODEC_MPEGVIDEO_H
+#include "dsputil.h"
+
#define FRAME_SKIPED 100 // return value for header parsers if frame is not coded
enum OutputFormat {
float ff_rate_estimate_qscale(MpegEncContext *s);
void ff_write_pass1_stats(MpegEncContext *s);
void ff_rate_control_uninit(MpegEncContext *s);
-double ff_eval(char *s, double *const_value, char **const_name,
- double (**func1)(void *, double), char **func1_name,
+double ff_eval(char *s, double *const_value, const char **const_name,
+ double (**func1)(void *, double), const char **func1_name,
double (**func2)(void *, double, double), char **func2_name,
void *opaque);
}
/* old ffmpeg msmpeg4v3 mode */
-void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
+static void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
{
if (s->qscale < 5){
s->y_dc_scale = 8;
(rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
0
};
- char *const_names[]={
+ static const char *const_names[]={
"PI",
"E",
"iTex",
(void *)qp2bits,
NULL
};
- char *func1_names[]={
+ static const char *func1_names[]={
"bits2qp",
"qp2bits",
NULL
static void init_mono_resample(ReSampleChannelContext *s, float ratio)
{
ratio = 1.0 / ratio;
- s->iratio = (int)floor(ratio);
+ s->iratio = (int)floorf(ratio);
if (s->iratio == 0)
s->iratio = 1;
s->incr = (int)((ratio / s->iratio) * FRAC);
/**
* realloc which does nothing if the block is large enough
*/
-void *av_fast_realloc(void *ptr, int *size, int min_size)
+void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size)
{
if(min_size < *size)
return ptr;
static const unsigned int grow_static = 64; // ^2
void *__av_mallocz_static(void** location, unsigned int size)
{
- int l = (last_static + grow_static) & ~(grow_static - 1);
+ unsigned int l = (last_static + grow_static) & ~(grow_static - 1);
void *ptr = av_mallocz(size);
if (!ptr)
return NULL;
return 0;
}
-void ff_wmv2_decode_init(MpegEncContext *s){
+static void ff_wmv2_decode_init(MpegEncContext *s){
}
static inline int wmv2_decode_motion(Wmv2Context *w, int *mx_ptr, int *my_ptr){
/* this structure contains the data a format has to probe a file */
typedef struct AVProbeData {
- char *filename;
+ const char *filename;
unsigned char *buf;
int buf_size;
} AVProbeData;
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "avformat.h"
+#include "avio.h"
#include <stdarg.h>
#define IO_BUFFER_SIZE 32768
/* link with avio functions */
-void url_write_packet(void *opaque, UINT8 *buf, int buf_size)
+static void url_write_packet(void *opaque, UINT8 *buf, int buf_size)
{
URLContext *h = opaque;
url_write(h, buf, buf_size);
}
-int url_read_packet(void *opaque, UINT8 *buf, int buf_size)
+static int url_read_packet(void *opaque, UINT8 *buf, int buf_size)
{
URLContext *h = opaque;
return url_read(h, buf, buf_size);
}
-int url_seek_packet(void *opaque, INT64 offset, int whence)
+static int url_seek_packet(void *opaque, INT64 offset, int whence)
{
URLContext *h = opaque;
url_seek(h, offset, whence);
p = str;
q = val;
while (*q != '\0') {
- if (toupper(*(unsigned char *)p) != toupper(*(unsigned char *)q))
+ if (toupper(*(const unsigned char *)p) != toupper(*(const unsigned char *)q))
return 0;
p++;
q++;
}
}
-void frame_hook_release()
+void frame_hook_release(void)
{
FrameHookEntry *fhe;
FrameHookEntry *fhenext;
char filename[1024];
int ret;
ByteIOContext f1, *f;
- static INT64 first_frame;
+ static INT64 first_frame; // BUG -> to context FIXME
if (emulate_frame_rate) {
if (!first_frame) {
#include "avformat.h"
/* simple formats */
-int raw_write_header(struct AVFormatContext *s)
+static int raw_write_header(struct AVFormatContext *s)
{
return 0;
}
-int raw_write_packet(struct AVFormatContext *s,
- int stream_index,
- unsigned char *buf, int size, int force_pts)
+static int raw_write_packet(struct AVFormatContext *s, int stream_index,
+ unsigned char *buf, int size, int force_pts)
{
put_buffer(&s->pb, buf, size);
put_flush_packet(&s->pb);
return 0;
}
-int raw_write_trailer(struct AVFormatContext *s)
+static int raw_write_trailer(struct AVFormatContext *s)
{
return 0;
}
/* raw input */
-static int raw_read_header(AVFormatContext *s,
- AVFormatParameters *ap)
+static static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
{
AVStream *st;
int id;
#define RAW_PACKET_SIZE 1024
-int raw_read_packet(AVFormatContext *s,
- AVPacket *pkt)
+static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
{
int ret, size;
// AVStream *st = s->streams[0];
return ret;
}
-int raw_read_close(AVFormatContext *s)
+static int raw_read_close(AVFormatContext *s)
{
return 0;
}
PCMDEF(alaw, "pcm A law format",
"al", CODEC_ID_PCM_ALAW)
-int rawvideo_read_packet(AVFormatContext *s,
- AVPacket *pkt)
+static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
{
int packet_size, ret, width, height;
AVStream *st = s->streams[0];
/* add option to url of the form:
"http://host:port/path?option1=val1&option2=val2... */
-void url_add_option(char *buf, int buf_size, const char *fmt, ...)
+static void url_add_option(char *buf, int buf_size, const char *fmt, ...)
{
char buf1[1024];
va_list ap;
va_end(ap);
}
-void build_udp_url(char *buf, int buf_size,
- const char *hostname, int port,
- int local_port, int multicast, int ttl)
+static void build_udp_url(char *buf, int buf_size,
+ const char *hostname, int port,
+ int local_port, int multicast, int ttl)
{
snprintf(buf, buf_size, "udp://%s:%d", hostname, port);
if (local_port >= 0)
}
}
-int sdp_parse(AVFormatContext *s, const char *content)
+static int sdp_parse(AVFormatContext *s, const char *content)
{
const char *p;
int letter;
int ret;
if (!fmt) {
- pd->filename = (char *)filename;
+ pd->filename = filename;
pd->buf = buf;
pos = url_ftell(pb);
pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
projects / frescor / ffmpeg.git / commitdiff