* UINTX -> uintx_t INTX -> intx_t

Originally committed as revision 1578 to svn://svn.ffmpeg.org/ffmpeg/trunk

ffmpeg.c

@@ -40,7 +40,7 @@
 #define INFINITY HUGE_VAL
 #endif
 
-#define MAXINT64 INT64_C(0x7fffffffffffffff)
+#define MAXINT64 int64_t_C(0x7fffffffffffffff)
 
 typedef struct {
     const char *name;
@@ -142,7 +142,7 @@ static int audio_disable = 0;
 static int audio_channels = 1;
 static int audio_codec_id = CODEC_ID_NONE;
 
-static INT64 recording_time = 0;
+static int64_t recording_time = 0;
 static int file_overwrite = 0;
 static char *str_title = NULL;
 static char *str_author = NULL;
@@ -178,7 +178,7 @@ typedef struct AVOutputStream {
        for A/V sync */
     double sync_ipts;
     double sync_ipts_offset;
-    INT64 sync_opts;
+    int64_t sync_opts;
     /* video only */
     int video_resample;      /* video_resample and video_crop are mutually exclusive */
     AVPicture pict_tmp;      /* temporary image for resampling */
@@ -201,7 +201,7 @@ typedef struct AVInputStream {
     AVStream *st;
     int discard;             /* true if stream data should be discarded */
     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
-    INT64 sample_index;      /* current sample */
+    int64_t sample_index;      /* current sample */
     int frame_decoded;       /* true if a video or audio frame has been decoded */
 } AVInputStream;
 
@@ -320,9 +320,9 @@ static void do_audio_out(AVFormatContext *s,
                          AVInputStream *ist,
                          unsigned char *buf, int size)
 {
-    UINT8 *buftmp;
-    UINT8 audio_buf[2*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */
-    UINT8 audio_out[4*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it - yep really WMA */
+    uint8_t *buftmp;
+    uint8_t audio_buf[2*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */
+    uint8_t audio_out[4*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it - yep really WMA */
     int size_out, frame_bytes, ret;
     AVCodecContext *enc;
 
@@ -376,7 +376,7 @@ static void do_audio_out(AVFormatContext *s,
 static void write_picture(AVFormatContext *s, int index, AVPicture *picture, 
                           int pix_fmt, int w, int h)
 {
-    UINT8 *buf, *src, *dest;
+    uint8_t *buf, *src, *dest;
     int size, j, i;
 
     /* XXX: not efficient, should add test if we can take
@@ -473,7 +473,7 @@ static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void
     AVCodecContext *dec;
     AVPicture *picture2;
     AVPicture picture_tmp;
-    UINT8 *buf = 0;
+    uint8_t *buf = 0;
 
     dec = &ist->st->codec;
 
@@ -520,8 +520,8 @@ static void do_video_out(AVFormatContext *s,
     int nb_frames, i, ret;
     AVPicture *final_picture, *formatted_picture;
     AVPicture picture_format_temp, picture_crop_temp;
-    static UINT8 *video_buffer;
-    UINT8 *buf = NULL, *buf1 = NULL;
+    static uint8_t *video_buffer;
+    uint8_t *buf = NULL, *buf1 = NULL;
     AVCodecContext *enc, *dec;
 
 #define VIDEO_BUFFER_SIZE (1024*1024)
@@ -675,7 +675,7 @@ static void do_video_out(AVFormatContext *s,
                    avoid any copies. We support temorarily the older
                    method. */
                 av_write_frame(s, ost->index, 
-                               (UINT8 *)final_picture, sizeof(AVPicture));
+                               (uint8_t *)final_picture, sizeof(AVPicture));
             } else {
                 write_picture(s, ost->index, final_picture, enc->pix_fmt, 
                               enc->width, enc->height);
@@ -697,13 +697,13 @@ static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
                            int frame_size)
 {
     static FILE *fvstats=NULL;
-    static INT64 total_size = 0;
+    static int64_t total_size = 0;
     char filename[40];
     time_t today2;
     struct tm *today;
     AVCodecContext *enc;
     int frame_number;
-    INT64 ti;
+    int64_t ti;
     double ti1, bitrate, avg_bitrate;
     
     if (!fvstats) {
@@ -749,14 +749,14 @@ static void print_report(AVFormatContext **output_files,
     char buf[1024];
     AVOutputStream *ost;
     AVFormatContext *oc, *os;
-    INT64 total_size;
+    int64_t total_size;
     AVCodecContext *enc;
     int frame_number, vid, i;
     double bitrate, ti1, pts;
-    static INT64 last_time = -1;
+    static int64_t last_time = -1;
     
     if (!is_last_report) {
-        INT64 cur_time;
+        int64_t cur_time;
         /* display the report every 0.5 seconds */
         cur_time = av_gettime();
         if (last_time == -1) {
@@ -1019,7 +1019,7 @@ static int av_encode(AVFormatContext **output_files,
                     ost->topBand = frame_topBand;
                     ost->leftBand = frame_leftBand;
                 } else {
-                    UINT8 *buf;
+                    uint8_t *buf;
                     ost->video_resample = 1;
                     ost->video_crop = 0; // cropping is handled as part of resample
                     buf = av_malloc((codec->width * codec->height * 3) / 2);
@@ -1179,9 +1179,9 @@ static int av_encode(AVFormatContext **output_files,
     for(;;) {
         int file_index, ist_index;
         AVPacket pkt;
-        UINT8 *ptr;
+        uint8_t *ptr;
         int len;
-        UINT8 *data_buf;
+        uint8_t *data_buf;
         int data_size, got_picture;
         AVPicture picture;
         short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
@@ -1252,7 +1252,7 @@ static int av_encode(AVFormatContext **output_files,
         ptr = pkt.data;
         pts_set = 0;
         while (len > 0) {
-            INT64 ipts;
+            int64_t ipts;
 
             ipts = AV_NOPTS_VALUE;
 
@@ -1288,7 +1288,7 @@ static int av_encode(AVFormatContext **output_files,
                         len -= ret;
                         continue;
                     }
-                    data_buf = (UINT8 *)samples;
+                    data_buf = (uint8_t *)samples;
                     break;
                 case CODEC_TYPE_VIDEO:
                     if (ist->st->codec.codec_id == CODEC_ID_RAWVIDEO) {
@@ -1348,7 +1348,7 @@ static int av_encode(AVFormatContext **output_files,
             /* XXX: add mpeg4 too ? */
             if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
                 if (ist->st->codec.pict_type != B_TYPE) {
-                    INT64 tmp;
+                    int64_t tmp;
                     tmp = ist->last_ip_pts;
                     ist->last_ip_pts  = ist->frac_pts.val;
                     ist->frac_pts.val = tmp;
@@ -2539,12 +2539,12 @@ static void opt_pass(const char *pass_str)
 }
 
 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
-static INT64 getutime(void)
+static int64_t getutime(void)
 {
   return av_gettime();
 }
 #else
-static INT64 getutime(void)
+static int64_t getutime(void)
 {
     struct rusage rusage;
 
@@ -2770,7 +2770,7 @@ int main(int argc, char **argv)
     int optindex, i;
     const char *opt, *arg;
     const OptionDef *po;
-    INT64 ti;
+    int64_t ti;
 
     av_register_all();
 

ffserver.c

@@ -90,7 +90,7 @@ const char *http_state[] = {
 #define SYNC_TIMEOUT (10 * 1000)
 
 typedef struct {
-    INT64 count1, count2;
+    int64_t count1, count2;
     long time1, time2;
 } DataRateData;
 
@@ -101,17 +101,17 @@ typedef struct HTTPContext {
     struct sockaddr_in from_addr; /* origin */
     struct pollfd *poll_entry; /* used when polling */
     long timeout;
-    UINT8 *buffer_ptr, *buffer_end;
+    uint8_t *buffer_ptr, *buffer_end;
     int http_error;
     struct HTTPContext *next;
     int got_key_frame; /* stream 0 => 1, stream 1 => 2, stream 2=> 4 */
-    INT64 data_count;
+    int64_t data_count;
     /* feed input */
     int feed_fd;
     /* input format handling */
     AVFormatContext *fmt_in;
     long start_time;            /* In milliseconds - this wraps fairly often */
-    INT64 first_pts;            /* initial pts value */
+    int64_t first_pts;            /* initial pts value */
     int pts_stream_index;       /* stream we choose as clock reference */
     /* output format handling */
     struct FFStream *stream;
@@ -128,12 +128,12 @@ typedef struct HTTPContext {
     char method[16];
     char url[128];
     int buffer_size;
-    UINT8 *buffer;
+    uint8_t *buffer;
     int is_packetized; /* if true, the stream is packetized */
     int packet_stream_index; /* current stream for output in state machine */
     
     /* RTSP state specific */
-    UINT8 *pb_buffer; /* XXX: use that in all the code */
+    uint8_t *pb_buffer; /* XXX: use that in all the code */
     ByteIOContext *pb;
     int seq; /* RTSP sequence number */
 
@@ -207,10 +207,10 @@ typedef struct FFStream {
     int feed_opened;     /* true if someone is writing to the feed */
     int is_feed;         /* true if it is a feed */
     int conns_served;
-    INT64 bytes_served;
-    INT64 feed_max_size;      /* maximum storage size */
-    INT64 feed_write_index;   /* current write position in feed (it wraps round) */
-    INT64 feed_size;          /* current size of feed */
+    int64_t bytes_served;
+    int64_t feed_max_size;      /* maximum storage size */
+    int64_t feed_write_index;   /* current write position in feed (it wraps round) */
+    int64_t feed_size;          /* current size of feed */
     struct FFStream *next_feed;
 } FFStream;
 
@@ -249,7 +249,7 @@ static void rtsp_cmd_pause(HTTPContext *c, const char *url, RTSPHeader *h);
 static void rtsp_cmd_teardown(HTTPContext *c, const char *url, RTSPHeader *h);
 
 /* SDP handling */
-static int prepare_sdp_description(FFStream *stream, UINT8 **pbuffer, 
+static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer, 
                                    struct in_addr my_ip);
 
 /* RTP handling */
@@ -323,7 +323,7 @@ static void log_connection(HTTPContext *c)
              c->protocol, (c->http_error ? c->http_error : 200), c->data_count);
 }
 
-static void update_datarate(DataRateData *drd, INT64 count)
+static void update_datarate(DataRateData *drd, int64_t count)
 {
     if (!drd->time1 && !drd->count1) {
         drd->time1 = drd->time2 = cur_time;
@@ -339,7 +339,7 @@ static void update_datarate(DataRateData *drd, INT64 count)
 }
 
 /* In bytes per second */
-static int compute_datarate(DataRateData *drd, INT64 count)
+static int compute_datarate(DataRateData *drd, int64_t count)
 {
     if (cur_time == drd->time1)
         return 0;
@@ -347,7 +347,7 @@ static int compute_datarate(DataRateData *drd, INT64 count)
     return ((count - drd->count1) * 1000) / (cur_time - drd->time1);
 }
 
-static int get_longterm_datarate(DataRateData *drd, INT64 count)
+static int get_longterm_datarate(DataRateData *drd, int64_t count)
 {
     /* You get the first 3 seconds flat out */
     if (cur_time - drd->time1 < 3000)
@@ -775,7 +775,7 @@ static int handle_connection(HTTPContext *c)
             return -1;
         } else {
             /* search for end of request. XXX: not fully correct since garbage could come after the end */
-            UINT8 *ptr;
+            uint8_t *ptr;
             c->buffer_ptr += len;
             ptr = c->buffer_ptr;
             if ((ptr >= c->buffer + 2 && !memcmp(ptr-2, "\n\n", 2)) ||
@@ -1351,7 +1351,7 @@ static int http_parse_request(HTTPContext *c)
                         break;
                     case REDIR_SDP:
                         {
-                            UINT8 *sdp_data;
+                            uint8_t *sdp_data;
                             int sdp_data_size, len;
                             struct sockaddr_in my_addr;
 
@@ -1529,7 +1529,7 @@ static int http_parse_request(HTTPContext *c)
     return 0;
 }
 
-static void fmt_bytecount(ByteIOContext *pb, INT64 count)
+static void fmt_bytecount(ByteIOContext *pb, int64_t count)
 {
     static const char *suffix = " kMGTP";
     const char *s;
@@ -1837,7 +1837,7 @@ static int open_input_stream(HTTPContext *c, const char *info)
     char input_filename[1024];
     AVFormatContext *s;
     int buf_size, i;
-    INT64 stream_pos;
+    int64_t stream_pos;
 
     /* find file name */
     if (c->stream->feed) {
@@ -1848,9 +1848,9 @@ static int open_input_stream(HTTPContext *c, const char *info)
             stream_pos = parse_date(buf, 0);
         } else if (find_info_tag(buf, sizeof(buf), "buffer", info)) {
             int prebuffer = strtol(buf, 0, 10);
-            stream_pos = av_gettime() - prebuffer * (INT64)1000000;
+            stream_pos = av_gettime() - prebuffer * (int64_t)1000000;
         } else {
-            stream_pos = av_gettime() - c->stream->prebuffer * (INT64)1000;
+            stream_pos = av_gettime() - c->stream->prebuffer * (int64_t)1000;
         }
     } else {
         strcpy(input_filename, c->stream->feed_filename);
@@ -1930,14 +1930,14 @@ int av_read_frame(AVFormatContext *s, AVPacket *pkt)
                     if (st->pts.den == 0) {
                         switch(st->codec.codec_type) {
                         case CODEC_TYPE_AUDIO:
-                            st->pts_incr = (INT64)s->pts_den;
+                            st->pts_incr = (int64_t)s->pts_den;
                             av_frac_init(&st->pts, st->pts.val, 0, 
-                                         (INT64)s->pts_num * st->codec.sample_rate);
+                                         (int64_t)s->pts_num * st->codec.sample_rate);
                             break;
                         case CODEC_TYPE_VIDEO:
-                            st->pts_incr = (INT64)s->pts_den * FRAME_RATE_BASE;
+                            st->pts_incr = (int64_t)s->pts_den * FRAME_RATE_BASE;
                             av_frac_init(&st->pts, st->pts.val, 0,
-                                         (INT64)s->pts_num * st->codec.frame_rate);
+                                         (int64_t)s->pts_num * st->codec.frame_rate);
                             break;
                         default:
                             av_abort();
@@ -1998,14 +1998,14 @@ int av_read_frame(AVFormatContext *s, AVPacket *pkt)
                 if (st->pts.den == 0) {
                     switch(st->codec.codec_type) {
                     case CODEC_TYPE_AUDIO:
-                        st->pts_incr = (INT64)s->pts_den * st->codec.frame_size;
+                        st->pts_incr = (int64_t)s->pts_den * st->codec.frame_size;
                         av_frac_init(&st->pts, st->pts.val, 0, 
-                                     (INT64)s->pts_num * st->codec.sample_rate);
+                                     (int64_t)s->pts_num * st->codec.sample_rate);
                         break;
                     case CODEC_TYPE_VIDEO:
-                        st->pts_incr = (INT64)s->pts_den * FRAME_RATE_BASE;
+                        st->pts_incr = (int64_t)s->pts_den * FRAME_RATE_BASE;
                         av_frac_init(&st->pts, st->pts.val, 0,
-                                     (INT64)s->pts_num * st->codec.frame_rate);
+                                     (int64_t)s->pts_num * st->codec.frame_rate);
                         break;
                     default:
                         av_abort();
@@ -2023,11 +2023,11 @@ int av_read_frame(AVFormatContext *s, AVPacket *pkt)
 
 static int compute_send_delay(HTTPContext *c)
 {
-    INT64 cur_pts, delta_pts, next_pts;
+    int64_t cur_pts, delta_pts, next_pts;
     int delay1;
     
     /* compute current pts value from system time */
-    cur_pts = ((INT64)(cur_time - c->start_time) * c->fmt_in->pts_den) / 
+    cur_pts = ((int64_t)(cur_time - c->start_time) * c->fmt_in->pts_den) / 
         (c->fmt_in->pts_num * 1000LL);
     /* compute the delta from the stream we choose as
        main clock (we do that to avoid using explicit
@@ -2328,8 +2328,8 @@ static int http_send_data(HTTPContext *c)
             if (dt < 1)
                 dt = 1;
 
-            if ((c->packet_byte_count + len) * (INT64)1000000 >= 
-                (SHORT_TERM_BANDWIDTH / 8) * (INT64)dt) {
+            if ((c->packet_byte_count + len) * (int64_t)1000000 >= 
+                (SHORT_TERM_BANDWIDTH / 8) * (int64_t)dt) {
                 /* bandwidth overflow : wait at most one tick and retry */
                 c->state = HTTPSTATE_WAIT_SHORT;
                 return 0;
@@ -2620,7 +2620,7 @@ static int rtsp_parse_request(HTTPContext *c)
 
 /* XXX: move that to rtsp.c, but would need to replace FFStream by
    AVFormatContext */
-static int prepare_sdp_description(FFStream *stream, UINT8 **pbuffer, 
+static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer, 
                                    struct in_addr my_ip)
 {
     ByteIOContext pb1, *pb = &pb1;
@@ -2710,7 +2710,7 @@ static void rtsp_cmd_describe(HTTPContext *c, const char *url)
     FFStream *stream;
     char path1[1024];
     const char *path;
-    UINT8 *content;
+    uint8_t *content;
     int content_length, len;
     struct sockaddr_in my_addr;
     
@@ -3087,7 +3087,7 @@ static int rtp_new_av_stream(HTTPContext *c,
     AVStream *st;
     char *ipaddr;
     URLContext *h;
-    UINT8 *dummy_buf;
+    uint8_t *dummy_buf;
     char buf2[32];
     
     /* now we can open the relevant output stream */
@@ -3240,7 +3240,7 @@ static void extract_mpeg4_header(AVFormatContext *infile)
     int mpeg4_count, i, size;
     AVPacket pkt;
     AVStream *st;
-    const UINT8 *p;
+    const uint8_t *p;
 
     mpeg4_count = 0;
     for(i=0;i<infile->nb_streams;i++) {
@@ -3805,7 +3805,7 @@ static int parse_ffconfig(const char *filename)
                     fsize *= 1024 * 1024 * 1024;
                     break;
                 }
-                feed->feed_max_size = (INT64)fsize;
+                feed->feed_max_size = (int64_t)fsize;
             }
         } else if (!strcasecmp(cmd, "</Feed>")) {
             if (!feed) {
@@ -4251,14 +4251,14 @@ static int parse_ffconfig(const char *filename)
 
 #if 0
 static void write_packet(FFCodec *ffenc,
-                         UINT8 *buf, int size)
+                         uint8_t *buf, int size)
 {
     PacketHeader hdr;
     AVCodecContext *enc = &ffenc->enc;
-    UINT8 *wptr;
+    uint8_t *wptr;
     mk_header(&hdr, enc, size);
     wptr = http_fifo.wptr;
-    fifo_write(&http_fifo, (UINT8 *)&hdr, sizeof(hdr), &wptr);
+    fifo_write(&http_fifo, (uint8_t *)&hdr, sizeof(hdr), &wptr);
     fifo_write(&http_fifo, buf, size, &wptr);
     /* atomic modification of wptr */
     http_fifo.wptr = wptr;

libavcodec/a52dec.c

@@ -29,8 +29,8 @@ static const char* liba52name = "liba52.so.0";
  * released under the GPL license.
  */
 typedef struct AC3DecodeState {
-    UINT8 inbuf[4096]; /* input buffer */
-    UINT8 *inbuf_ptr;
+    uint8_t inbuf[4096]; /* input buffer */
+    uint8_t *inbuf_ptr;
     int frame_size;
     int flags;
     int channels;
@@ -123,7 +123,7 @@ static inline int blah (int32_t i)
     return i - 0x43c00000;
 }
 
-static inline void float_to_int (float * _f, INT16 * s16, int nchannels)
+static inline void float_to_int (float * _f, int16_t * s16, int nchannels)
 {
     int i, j, c;
     int32_t * f = (int32_t *) _f;	// XXX assumes IEEE float format
@@ -142,10 +142,10 @@ static inline void float_to_int (float * _f, INT16 * s16, int nchannels)
 
 static int a52_decode_frame(AVCodecContext *avctx,
                             void *data, int *data_size,
-                            UINT8 *buf, int buf_size)
+                            uint8_t *buf, int buf_size)
 {
     AC3DecodeState *s = avctx->priv_data;
-    UINT8 *buf_ptr;
+    uint8_t *buf_ptr;
     int flags, i, len;
     int sample_rate, bit_rate;
     short *out_samples = data;
@@ -221,7 +221,7 @@ static int a52_decode_frame(AVCodecContext *avctx,
             }
             s->inbuf_ptr = s->inbuf;
             s->frame_size = 0;
-            *data_size = 6 * avctx->channels * 256 * sizeof(INT16);
+            *data_size = 6 * avctx->channels * 256 * sizeof(int16_t);
             break;
         }
     }

libavcodec/ac3.h

@@ -38,19 +38,19 @@ typedef struct AC3BitAllocParameters {
     int cplfleak, cplsleak;
 } AC3BitAllocParameters;
 
-extern const UINT16 ac3_freqs[3];
-extern const UINT16 ac3_bitratetab[19];
-extern const INT16 ac3_window[256];
-extern const UINT8 sdecaytab[4];
-extern const UINT8 fdecaytab[4];
-extern const UINT16 sgaintab[4];
-extern const UINT16 dbkneetab[4];
-extern const UINT16 floortab[8];
-extern const UINT16 fgaintab[8];
+extern const uint16_t ac3_freqs[3];
+extern const uint16_t ac3_bitratetab[19];
+extern const int16_t ac3_window[256];
+extern const uint8_t sdecaytab[4];
+extern const uint8_t fdecaytab[4];
+extern const uint16_t sgaintab[4];
+extern const uint16_t dbkneetab[4];
+extern const uint16_t floortab[8];
+extern const uint16_t fgaintab[8];
 
 void ac3_common_init(void);
-void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, UINT8 *bap,
-                                   INT8 *exp, int start, int end,
+void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, uint8_t *bap,
+                                   int8_t *exp, int start, int end,
                                    int snroffset, int fgain, int is_lfe,
                                    int deltbae,int deltnseg, 
-                                   UINT8 *deltoffst, UINT8 *deltlen, UINT8 *deltba);
+                                   uint8_t *deltoffst, uint8_t *deltlen, uint8_t *deltba);

libavcodec/ac3dec.c

@@ -22,8 +22,8 @@
 /* currently, I use libac3 which is Copyright (C) Aaron Holtzman and
    released under the GPL license. I may reimplement it someday... */
 typedef struct AC3DecodeState {
-    UINT8 inbuf[4096]; /* input buffer */
-    UINT8 *inbuf_ptr;
+    uint8_t inbuf[4096]; /* input buffer */
+    uint8_t *inbuf_ptr;
     int frame_size;
     int flags;
     int channels;
@@ -53,7 +53,7 @@ static inline int blah (int32_t i)
 	return i - 0x43c00000;
 }
 
-static inline void float_to_int (float * _f, INT16 * s16, int nchannels)
+static inline void float_to_int (float * _f, int16_t * s16, int nchannels)
 {
     int i, j, c;
     int32_t * f = (int32_t *) _f;	// XXX assumes IEEE float format
@@ -72,10 +72,10 @@ static inline void float_to_int (float * _f, INT16 * s16, int nchannels)
 
 static int ac3_decode_frame(AVCodecContext *avctx, 
                             void *data, int *data_size,
-                            UINT8 *buf, int buf_size)
+                            uint8_t *buf, int buf_size)
 {
     AC3DecodeState *s = avctx->priv_data;
-    UINT8 *buf_ptr;
+    uint8_t *buf_ptr;
     int flags, i, len;
     int sample_rate, bit_rate;
     short *out_samples = data;
@@ -151,7 +151,7 @@ static int ac3_decode_frame(AVCodecContext *avctx,
             }
             s->inbuf_ptr = s->inbuf;
             s->frame_size = 0;
-            *data_size = 6 * avctx->channels * 256 * sizeof(INT16);
+            *data_size = 6 * avctx->channels * 256 * sizeof(int16_t);
             break;
         }
     }

libavcodec/ac3enc.c

@@ -63,7 +63,7 @@ typedef struct AC3EncodeContext {
 static void fft_init(int ln);
 static void ac3_crc_init(void);
 
-static inline INT16 fix15(float a)
+static inline int16_t fix15(float a)
 {
     int v;
     v = (int)(a * (float)(1 << 15));
@@ -110,18 +110,18 @@ static inline int calc_lowcomp(int a, int b0, int b1, int bin)
 
 /* AC3 bit allocation. The algorithm is the one described in the AC3
    spec. */
-void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, UINT8 *bap,
-                                   INT8 *exp, int start, int end,
+void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, uint8_t *bap,
+                                   int8_t *exp, int start, int end,
                                    int snroffset, int fgain, int is_lfe,
                                    int deltbae,int deltnseg, 
-                                   UINT8 *deltoffst, UINT8 *deltlen, UINT8 *deltba)
+                                   uint8_t *deltoffst, uint8_t *deltlen, uint8_t *deltba)
 {
     int bin,i,j,k,end1,v,v1,bndstrt,bndend,lowcomp,begin;
     int fastleak,slowleak,address,tmp;
-    INT16 psd[256]; /* scaled exponents */
-    INT16 bndpsd[50]; /* interpolated exponents */
-    INT16 excite[50]; /* excitation */
-    INT16 mask[50];   /* masking value */
+    int16_t psd[256]; /* scaled exponents */
+    int16_t bndpsd[50]; /* interpolated exponents */
+    int16_t excite[50]; /* excitation */
+    int16_t mask[50];   /* masking value */
 
     /* exponent mapping to PSD */
     for(bin=start;bin<end;bin++) {
@@ -404,10 +404,10 @@ static void fft(IComplex *z, int ln)
 }
 
 /* do a 512 point mdct */
-static void mdct512(INT32 *out, INT16 *in)
+static void mdct512(int32_t *out, int16_t *in)
 {
     int i, re, im, re1, im1;
-    INT16 rot[N]; 
+    int16_t rot[N]; 
     IComplex x[N/4];
 
     /* shift to simplify computations */
@@ -436,7 +436,7 @@ static void mdct512(INT32 *out, INT16 *in)
 }
 
 /* XXX: use another norm ? */
-static int calc_exp_diff(UINT8 *exp1, UINT8 *exp2, int n)
+static int calc_exp_diff(uint8_t *exp1, uint8_t *exp2, int n)
 {
     int sum, i;
     sum = 0;
@@ -446,8 +446,8 @@ static int calc_exp_diff(UINT8 *exp1, UINT8 *exp2, int n)
     return sum;
 }
 
-static void compute_exp_strategy(UINT8 exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
-                                 UINT8 exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
+static void compute_exp_strategy(uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
+                                 uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
                                  int ch, int is_lfe)
 {
     int i, j;
@@ -493,7 +493,7 @@ static void compute_exp_strategy(UINT8 exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS]
 }
 
 /* set exp[i] to min(exp[i], exp1[i]) */
-static void exponent_min(UINT8 exp[N/2], UINT8 exp1[N/2], int n)
+static void exponent_min(uint8_t exp[N/2], uint8_t exp1[N/2], int n)
 {
     int i;
 
@@ -505,13 +505,13 @@ static void exponent_min(UINT8 exp[N/2], UINT8 exp1[N/2], int n)
                                  
 /* update the exponents so that they are the ones the decoder will
    decode. Return the number of bits used to code the exponents */
-static int encode_exp(UINT8 encoded_exp[N/2], 
-                      UINT8 exp[N/2], 
+static int encode_exp(uint8_t encoded_exp[N/2], 
+                      uint8_t exp[N/2], 
                       int nb_exps,
                       int exp_strategy)
 {
     int group_size, nb_groups, i, j, k, recurse, exp_min, delta;
-    UINT8 exp1[N/2];
+    uint8_t exp1[N/2];
 
     switch(exp_strategy) {
     case EXP_D15:
@@ -586,7 +586,7 @@ static int encode_exp(UINT8 encoded_exp[N/2],
 }
 
 /* return the size in bits taken by the mantissa */
-static int compute_mantissa_size(AC3EncodeContext *s, UINT8 *m, int nb_coefs)
+static int compute_mantissa_size(AC3EncodeContext *s, uint8_t *m, int nb_coefs)
 {
     int bits, mant, i;
 
@@ -637,9 +637,9 @@ static int compute_mantissa_size(AC3EncodeContext *s, UINT8 *m, int nb_coefs)
 
 
 static int bit_alloc(AC3EncodeContext *s,
-                     UINT8 bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
-                     UINT8 encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
-                     UINT8 exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
+                     uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
+                     uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
+                     uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
                      int frame_bits, int csnroffst, int fsnroffst)
 {
     int i, ch;
@@ -651,7 +651,7 @@ static int bit_alloc(AC3EncodeContext *s,
         s->mant4_cnt = 0;
         for(ch=0;ch<s->nb_all_channels;ch++) {
             ac3_parametric_bit_allocation(&s->bit_alloc, 
-                                          bap[i][ch], (INT8 *)encoded_exp[i][ch], 
+                                          bap[i][ch], (int8_t *)encoded_exp[i][ch], 
                                           0, s->nb_coefs[ch], 
                                           (((csnroffst-15) << 4) + 
                                            fsnroffst) << 2, 
@@ -673,14 +673,14 @@ static int bit_alloc(AC3EncodeContext *s,
 #define SNR_INC1 4
 
 static int compute_bit_allocation(AC3EncodeContext *s,
-                                  UINT8 bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
-                                  UINT8 encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
-                                  UINT8 exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
+                                  uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
+                                  uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
+                                  uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
                                   int frame_bits)
 {
     int i, ch;
     int csnroffst, fsnroffst;
-    UINT8 bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
+    uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
     static int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
 
     /* init default parameters */
@@ -816,7 +816,7 @@ static int AC3_encode_init(AVCodecContext *avctx)
     AC3EncodeContext *s = avctx->priv_data;
     int i, j, ch;
     float alpha;
-    static const UINT8 acmod_defs[6] = {
+    static const uint8_t acmod_defs[6] = {
 	0x01, /* C */
 	0x02, /* L R */
 	0x03, /* L C R */
@@ -966,19 +966,19 @@ static inline int asym_quant(int c, int e, int qbits)
 /* Output one audio block. There are NB_BLOCKS audio blocks in one AC3
    frame */
 static void output_audio_block(AC3EncodeContext *s,
-                               UINT8 exp_strategy[AC3_MAX_CHANNELS],
-                               UINT8 encoded_exp[AC3_MAX_CHANNELS][N/2],
-                               UINT8 bap[AC3_MAX_CHANNELS][N/2],
-                               INT32 mdct_coefs[AC3_MAX_CHANNELS][N/2],
-                               INT8 global_exp[AC3_MAX_CHANNELS],
+                               uint8_t exp_strategy[AC3_MAX_CHANNELS],
+                               uint8_t encoded_exp[AC3_MAX_CHANNELS][N/2],
+                               uint8_t bap[AC3_MAX_CHANNELS][N/2],
+                               int32_t mdct_coefs[AC3_MAX_CHANNELS][N/2],
+                               int8_t global_exp[AC3_MAX_CHANNELS],
                                int block_num)
 {
     int ch, nb_groups, group_size, i, baie;
-    UINT8 *p;
-    UINT16 qmant[AC3_MAX_CHANNELS][N/2];
+    uint8_t *p;
+    uint16_t qmant[AC3_MAX_CHANNELS][N/2];
     int exp0, exp1;
     int mant1_cnt, mant2_cnt, mant4_cnt;
-    UINT16 *qmant1_ptr, *qmant2_ptr, *qmant4_ptr;
+    uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr;
     int delta0, delta1, delta2;
 
     for(ch=0;ch<s->nb_channels;ch++) 
@@ -1244,7 +1244,7 @@ static void ac3_crc_init(void)
     }
 }
 
-static unsigned int ac3_crc(UINT8 *data, int n, unsigned int crc)
+static unsigned int ac3_crc(uint8_t *data, int n, unsigned int crc)
 {
     int i;
     for(i=0;i<n;i++) {
@@ -1284,7 +1284,7 @@ static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
 
 
 /* compute log2(max(abs(tab[]))) */
-static int log2_tab(INT16 *tab, int n)
+static int log2_tab(int16_t *tab, int n)
 {
     int i, v;
 
@@ -1295,7 +1295,7 @@ static int log2_tab(INT16 *tab, int n)
     return av_log2(v);
 }
 
-static void lshift_tab(INT16 *tab, int n, int lshift)
+static void lshift_tab(int16_t *tab, int n, int lshift)
 {
     int i;
 
@@ -1315,7 +1315,7 @@ static void lshift_tab(INT16 *tab, int n, int lshift)
 static int output_frame_end(AC3EncodeContext *s)
 {
     int frame_size, frame_size_58, n, crc1, crc2, crc_inv;
-    UINT8 *frame;
+    uint8_t *frame;
 
     frame_size = s->frame_size; /* frame size in words */
     /* align to 8 bits */
@@ -1350,24 +1350,24 @@ static int AC3_encode_frame(AVCodecContext *avctx,
     AC3EncodeContext *s = avctx->priv_data;
     short *samples = data;
     int i, j, k, v, ch;
-    INT16 input_samples[N];
-    INT32 mdct_coef[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
-    UINT8 exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
-    UINT8 exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS];
-    UINT8 encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
-    UINT8 bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
-    INT8 exp_samples[NB_BLOCKS][AC3_MAX_CHANNELS];
+    int16_t input_samples[N];
+    int32_t mdct_coef[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
+    uint8_t exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
+    uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS];
+    uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
+    uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
+    int8_t exp_samples[NB_BLOCKS][AC3_MAX_CHANNELS];
     int frame_bits;
 
     frame_bits = 0;
     for(ch=0;ch<s->nb_all_channels;ch++) {
         /* fixed mdct to the six sub blocks & exponent computation */
         for(i=0;i<NB_BLOCKS;i++) {
-            INT16 *sptr;
+            int16_t *sptr;
             int sinc;
 
             /* compute input samples */
-            memcpy(input_samples, s->last_samples[ch], N/2 * sizeof(INT16));
+            memcpy(input_samples, s->last_samples[ch], N/2 * sizeof(int16_t));
             sinc = s->nb_all_channels;
             sptr = samples + (sinc * (N/2) * i) + ch;
             for(j=0;j<N/2;j++) {
@@ -1432,7 +1432,7 @@ static int AC3_encode_frame(AVCodecContext *avctx,
             /* copy encoded exponents for reuse case */
             for(k=i+1;k<j;k++) {
                 memcpy(encoded_exp[k][ch], encoded_exp[i][ch], 
-                       s->nb_coefs[ch] * sizeof(UINT8));
+                       s->nb_coefs[ch] * sizeof(uint8_t));
             }
             i = j;
         }
@@ -1492,8 +1492,8 @@ void fft_test(void)
 
 void mdct_test(void)
 {
-    INT16 input[N];
-    INT32 output[N/2];
+    int16_t input[N];
+    int32_t output[N/2];
     float input1[N];
     float output1[N/2];
     float s, a, err, e, emax;

libavcodec/ac3tab.h

@@ -1,10 +1,10 @@
 /* tables taken directly from AC3 spec */
 
 /* possible frequencies */
-const UINT16 ac3_freqs[3] = { 48000, 44100, 32000 };
+const uint16_t ac3_freqs[3] = { 48000, 44100, 32000 };
 
 /* possible bitrates */
-const UINT16 ac3_bitratetab[19] = {
+const uint16_t ac3_bitratetab[19] = {
     32, 40, 48, 56, 64, 80, 96, 112, 128, 
     160, 192, 224, 256, 320, 384, 448, 512, 576, 640 
 };
@@ -12,7 +12,7 @@ const UINT16 ac3_bitratetab[19] = {
 /* AC3 MDCT window */
 
 /* MDCT window */
-const INT16 ac3_window[256] = {
+const int16_t ac3_window[256] = {
     4,    7,   12,   16,   21,   28,   34,   42,
    51,   61,   72,   84,   97,  111,  127,  145,
   164,  184,  207,  231,  257,  285,  315,  347,
@@ -47,9 +47,9 @@ const INT16 ac3_window[256] = {
 32767,32767,32767,32767,32767,32767,32767,32767,  
 };
 
-static UINT8 masktab[253];
+static uint8_t masktab[253];
 
-static const UINT8 latab[260]= {
+static const uint8_t latab[260]= {
 0x0040,0x003f,0x003e,0x003d,0x003c,0x003b,0x003a,0x0039,0x0038,0x0037,
 0x0036,0x0035,0x0034,0x0034,0x0033,0x0032,0x0031,0x0030,0x002f,0x002f,
 0x002e,0x002d,0x002c,0x002c,0x002b,0x002a,0x0029,0x0029,0x0028,0x0027,
@@ -78,7 +78,7 @@ static const UINT8 latab[260]= {
 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
 };
 
-static const UINT16 hth[50][3]= {
+static const uint16_t hth[50][3]= {
 { 0x04d0,0x04f0,0x0580 },
 { 0x04d0,0x04f0,0x0580 },
 { 0x0440,0x0460,0x04b0 },
@@ -131,7 +131,7 @@ static const UINT16 hth[50][3]= {
 { 0x0840,0x0840,0x04e0 },
 };
 
-static const UINT8 baptab[64]= {
+static const uint8_t baptab[64]= {
     0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 
     3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 
     7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 
@@ -141,43 +141,43 @@ static const UINT8 baptab[64]= {
     15, 15, 15, 15,
 };
 
-const UINT8 sdecaytab[4]={ 
+const uint8_t sdecaytab[4]={ 
     0x0f, 0x11, 0x13, 0x15,
 };
 
-const UINT8 fdecaytab[4]={ 
+const uint8_t fdecaytab[4]={ 
     0x3f, 0x53, 0x67, 0x7b, 
 };
 
-const UINT16 sgaintab[4]= { 
+const uint16_t sgaintab[4]= { 
     0x540, 0x4d8, 0x478, 0x410,
 };
 
-const UINT16 dbkneetab[4]= { 
+const uint16_t dbkneetab[4]= { 
     0x000, 0x700, 0x900, 0xb00,
 };
 
-const UINT16 floortab[8]= { 
+const uint16_t floortab[8]= { 
     0x2f0, 0x2b0, 0x270, 0x230, 0x1f0, 0x170, 0x0f0, 0xf800,
 };
 
-const UINT16 fgaintab[8]= {
+const uint16_t fgaintab[8]= {
     0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400,
 };
 
-static const UINT8 bndsz[50]={
+static const uint8_t bndsz[50]={
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 
     3, 6, 6, 6, 6, 6, 6, 12, 12, 12, 12, 24, 24, 24, 24, 24 
 };
 
-static UINT8 bndtab[51]; 
+static uint8_t bndtab[51]; 
 
 /* fft & mdct sin cos tables */
-static INT16 costab[64];
-static INT16 sintab[64];
-static INT16 fft_rev[512];
-static INT16 xcos1[128];
-static INT16 xsin1[128];
+static int16_t costab[64];
+static int16_t sintab[64];
+static int16_t fft_rev[512];
+static int16_t xcos1[128];
+static int16_t xsin1[128];
 
-static UINT16 crc_table[256];
+static uint16_t crc_table[256];

libavcodec/adpcm.c

@@ -329,14 +329,14 @@ static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble)
 
 static int adpcm_decode_frame(AVCodecContext *avctx,
 			    void *data, int *data_size,
-			    UINT8 *buf, int buf_size)
+			    uint8_t *buf, int buf_size)
 {
     ADPCMContext *c = avctx->priv_data;
     ADPCMChannelStatus *cs;
     int n, m, channel;
     int block_predictor[2];
     short *samples;
-    UINT8 *src;
+    uint8_t *src;
     int st; /* stereo */
 
     samples = data;
@@ -500,7 +500,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx,
         *data_size = 0;
         return -1;
     }
-    *data_size = (UINT8 *)samples - (UINT8 *)data;
+    *data_size = (uint8_t *)samples - (uint8_t *)data;
     return src - buf;
 }
 

libavcodec/apiexample.c

@@ -28,7 +28,7 @@ void audio_encode_example(const char *filename)
     FILE *f;
     short *samples;
     float t, tincr;
-    UINT8 *outbuf;
+    uint8_t *outbuf;
 
     printf("Audio encoding\n");
 
@@ -94,8 +94,8 @@ void audio_decode_example(const char *outfilename, const char *filename)
     AVCodecContext *c= NULL;
     int out_size, size, len;
     FILE *f, *outfile;
-    UINT8 *outbuf;
-    UINT8 inbuf[INBUF_SIZE], *inbuf_ptr;
+    uint8_t *outbuf;
+    uint8_t inbuf[INBUF_SIZE], *inbuf_ptr;
 
     printf("Audio decoding\n");
 
@@ -169,7 +169,7 @@ void video_encode_example(const char *filename)
     int i, out_size, size, x, y, outbuf_size;
     FILE *f;
     AVFrame *picture;
-    UINT8 *outbuf, *picture_buf;
+    uint8_t *outbuf, *picture_buf;
 
     printf("Video encoding\n");
 
@@ -283,7 +283,7 @@ void video_decode_example(const char *outfilename, const char *filename)
     int frame, size, got_picture, len;
     FILE *f;
     AVFrame *picture;
-    UINT8 inbuf[INBUF_SIZE], *inbuf_ptr;
+    uint8_t inbuf[INBUF_SIZE], *inbuf_ptr;
     char buf[1024];
 
     printf("Video decoding\n");

libavcodec/armv4l/mpegvideo_arm.c

@@ -23,17 +23,17 @@
 
 extern void j_rev_dct_ARM(DCTELEM *data);
 /* XXX: local hack */
-static void (*ff_put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
-static void (*ff_add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
+static void (*ff_put_pixels_clamped)(const DCTELEM *block, uint8_t *pixels, int line_size);
+static void (*ff_add_pixels_clamped)(const DCTELEM *block, uint8_t *pixels, int line_size);
 
 /* XXX: those functions should be suppressed ASAP when all IDCTs are
    converted */
-static void arm_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
+static void arm_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
 {
     j_rev_dct_ARM (block);
     ff_put_pixels_clamped(block, dest, line_size);
 }
-static void arm_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
+static void arm_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
 {
     j_rev_dct_ARM (block);
     ff_add_pixels_clamped(block, dest, line_size);

libavcodec/avcodec.h

@@ -393,7 +393,7 @@ typedef struct AVCodecContext {
      * decoding: set by user.
      */
     void (*draw_horiz_band)(struct AVCodecContext *s,
-                            UINT8 **src_ptr, int linesize,
+                            uint8_t **src_ptr, int linesize,
                             int y, int width, int height);
 
     /* audio only */
@@ -992,10 +992,10 @@ typedef struct AVCodec {
     int id;
     int priv_data_size;
     int (*init)(AVCodecContext *);
-    int (*encode)(AVCodecContext *, UINT8 *buf, int buf_size, void *data);
+    int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data);
     int (*close)(AVCodecContext *);
     int (*decode)(AVCodecContext *, void *outdata, int *outdata_size,
-                  UINT8 *buf, int buf_size);
+                  uint8_t *buf, int buf_size);
     int capabilities;
     const AVOption *options;
     struct AVCodec *next;
@@ -1006,7 +1006,7 @@ typedef struct AVCodec {
  * the last component is alpha
  */
 typedef struct AVPicture {
-    UINT8 *data[4];
+    uint8_t *data[4];
     int linesize[4];
 } AVPicture;
 
@@ -1110,7 +1110,7 @@ void img_resample(ImgReSampleContext *s,
 
 void img_resample_close(ImgReSampleContext *s);
 
-int avpicture_fill(AVPicture *picture, UINT8 *ptr,
+int avpicture_fill(AVPicture *picture, uint8_t *ptr,
                    int pix_fmt, int width, int height);
 int avpicture_get_size(int pix_fmt, int width, int height);
 void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift);
@@ -1152,18 +1152,18 @@ int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic);
 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic);
 
 int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
-int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, 
+int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples, 
                          int *frame_size_ptr,
-                         UINT8 *buf, int buf_size);
+                         uint8_t *buf, int buf_size);
 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, 
                          int *got_picture_ptr,
-                         UINT8 *buf, int buf_size);
-int avcodec_parse_frame(AVCodecContext *avctx, UINT8 **pdata, 
+                         uint8_t *buf, int buf_size);
+int avcodec_parse_frame(AVCodecContext *avctx, uint8_t **pdata, 
                         int *data_size_ptr,
-                        UINT8 *buf, int buf_size);
-int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
+                        uint8_t *buf, int buf_size);
+int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
                          const short *samples);
-int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
+int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
                          const AVFrame *pict);
 
 int avcodec_close(AVCodecContext *avctx);

libavcodec/common.c

@@ -20,7 +20,7 @@
  */
 #include "avcodec.h"
 
-const UINT8 ff_sqrt_tab[128]={
+const uint8_t ff_sqrt_tab[128]={
         0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,
         5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
@@ -39,9 +39,9 @@ const uint8_t ff_log2_tab[256]={
 };
 
 void init_put_bits(PutBitContext *s, 
-                   UINT8 *buffer, int buffer_size,
+                   uint8_t *buffer, int buffer_size,
                    void *opaque,
-                   void (*write_data)(void *, UINT8 *, int))
+                   void (*write_data)(void *, uint8_t *, int))
 {
     s->buf = buffer;
     s->buf_end = s->buf + buffer_size;
@@ -62,12 +62,12 @@ void init_put_bits(PutBitContext *s,
 }
 
 /* return the number of bits output */
-INT64 get_bit_count(PutBitContext *s)
+int64_t get_bit_count(PutBitContext *s)
 {
 #ifdef ALT_BITSTREAM_WRITER
     return s->data_out_size * 8 + s->index;
 #else
-    return (s->buf_ptr - s->buf + s->data_out_size) * 8 + 32 - (INT64)s->bit_left;
+    return (s->buf_ptr - s->buf + s->data_out_size) * 8 + 32 - (int64_t)s->bit_left;
 #endif
 }
 
@@ -110,7 +110,7 @@ void put_string(PutBitContext * pbc, char *s)
 /* bit input functions */
 
 void init_get_bits(GetBitContext *s,
-                   UINT8 *buffer, int bit_size)
+                   uint8_t *buffer, int bit_size)
 {
     const int buffer_size= (bit_size+7)>>3;
 
@@ -160,16 +160,16 @@ int check_marker(GetBitContext *s, const char *msg)
 
 #define GET_DATA(v, table, i, wrap, size) \
 {\
-    const UINT8 *ptr = (const UINT8 *)table + i * wrap;\
+    const uint8_t *ptr = (const uint8_t *)table + i * wrap;\
     switch(size) {\
     case 1:\
-        v = *(const UINT8 *)ptr;\
+        v = *(const uint8_t *)ptr;\
         break;\
     case 2:\
-        v = *(const UINT16 *)ptr;\
+        v = *(const uint16_t *)ptr;\
         break;\
     default:\
-        v = *(const UINT32 *)ptr;\
+        v = *(const uint32_t *)ptr;\
         break;\
     }\
 }
@@ -194,10 +194,10 @@ static int build_table(VLC *vlc, int table_nb_bits,
                        int nb_codes,
                        const void *bits, int bits_wrap, int bits_size,
                        const void *codes, int codes_wrap, int codes_size,
-                       UINT32 code_prefix, int n_prefix)
+                       uint32_t code_prefix, int n_prefix)
 {
     int i, j, k, n, table_size, table_index, nb, n1, index;
-    UINT32 code;
+    uint32_t code;
     VLC_TYPE (*table)[2];
 
     table_size = 1 << table_nb_bits;

libavcodec/common.h

@@ -72,33 +72,24 @@
 
 /* windows */
 
-typedef unsigned short UINT16;
-typedef signed short INT16;
-typedef unsigned char UINT8;
-typedef unsigned int UINT32;
-typedef unsigned __int64 UINT64;
-typedef signed char INT8;
-typedef signed int INT32;
-typedef signed __int64 INT64;
-
-typedef UINT8 uint8_t;
-typedef INT8 int8_t;
-typedef UINT16 uint16_t;
-typedef INT16 int16_t;
-typedef UINT32 uint32_t;
-typedef INT32 int32_t;
-typedef UINT64 uint64_t;
-typedef INT64 int64_t;
+typedef unsigned short uint16_t;
+typedef signed short int16_t;
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+typedef unsigned __int64 uint64_t;
+typedef signed char int8_t;
+typedef signed int int32_t;
+typedef signed __int64 int64_t;
 
 #    ifndef __MINGW32__
-#        define INT64_C(c)     (c ## i64)
-#        define UINT64_C(c)    (c ## i64)
+#        define int64_t_C(c)     (c ## i64)
+#        define uint64_t_C(c)    (c ## i64)
 
 #        define inline __inline
 
 #    else
-#        define INT64_C(c)     (c ## LL)
-#        define UINT64_C(c)    (c ## ULL)
+#        define int64_t_C(c)     (c ## LL)
+#        define uint64_t_C(c)    (c ## ULL)
 #    endif /* __MINGW32__ */
 
 #    ifdef _DEBUG
@@ -114,20 +105,11 @@ typedef INT64 int64_t;
 
 #include <inttypes.h>
 
-typedef unsigned char UINT8;
-typedef unsigned short UINT16;
-typedef unsigned int UINT32;
-typedef unsigned long long UINT64;
-typedef signed char INT8;
-typedef signed short INT16;
-typedef signed int INT32;
-typedef signed long long INT64;
-
 #ifdef HAVE_AV_CONFIG_H
 
-#ifndef INT64_C
-#define INT64_C(c)     (c ## LL)
-#define UINT64_C(c)    (c ## ULL)
+#ifndef int64_t_C
+#define int64_t_C(c)     (c ## LL)
+#define uint64_t_C(c)    (c ## ULL)
 #endif
 
 #ifdef USE_FASTMEMCPY
@@ -145,23 +127,10 @@ typedef signed long long INT64;
 
 #    include <inttypes.h>
 
-#    ifndef __WINE_WINDEF16_H
-/* workaround for typedef conflict in MPlayer (wine typedefs) */
-typedef unsigned short UINT16;
-typedef signed short INT16;
-#    endif
-
-typedef unsigned char UINT8;
-typedef unsigned int UINT32;
-typedef unsigned long long UINT64;
-typedef signed char INT8;
-typedef signed int INT32;
-typedef signed long long INT64;
-
 #    ifdef HAVE_AV_CONFIG_H
-#        ifndef INT64_C
-#            define INT64_C(c)     (c ## LL)
-#            define UINT64_C(c)    (c ## ULL)
+#        ifndef int64_t_C
+#            define int64_t_C(c)     (c ## LL)
+#            define uint64_t_C(c)    (c ## ULL)
 #        endif
 
 #        ifdef USE_FASTMEMCPY
@@ -240,26 +209,26 @@ static inline uint32_t NEG_USR32(uint32_t a, int8_t s){
 
 struct PutBitContext;
 
-typedef void (*WriteDataFunc)(void *, UINT8 *, int);
+typedef void (*WriteDataFunc)(void *, uint8_t *, int);
 
 typedef struct PutBitContext {
 #ifdef ALT_BITSTREAM_WRITER
-    UINT8 *buf, *buf_end;
+    uint8_t *buf, *buf_end;
     int index;
 #else
-    UINT32 bit_buf;
+    uint32_t bit_buf;
     int bit_left;
-    UINT8 *buf, *buf_ptr, *buf_end;
+    uint8_t *buf, *buf_ptr, *buf_end;
 #endif
-    INT64 data_out_size; /* in bytes */
+    int64_t data_out_size; /* in bytes */
 } PutBitContext;
 
 void init_put_bits(PutBitContext *s, 
-                   UINT8 *buffer, int buffer_size,
+                   uint8_t *buffer, int buffer_size,
                    void *opaque,
-                   void (*write_data)(void *, UINT8 *, int));
+                   void (*write_data)(void *, uint8_t *, int));
 
-INT64 get_bit_count(PutBitContext *s); /* XXX: change function name */
+int64_t get_bit_count(PutBitContext *s); /* XXX: change function name */
 void align_put_bits(PutBitContext *s);
 void flush_put_bits(PutBitContext *s);
 void put_string(PutBitContext * pbc, char *s);
@@ -267,17 +236,17 @@ void put_string(PutBitContext * pbc, char *s);
 /* bit input */
 
 typedef struct GetBitContext {
-    UINT8 *buffer, *buffer_end;
+    uint8_t *buffer, *buffer_end;
 #ifdef ALT_BITSTREAM_READER
     int index;
 #elif defined LIBMPEG2_BITSTREAM_READER
-    UINT8 *buffer_ptr;
-    UINT32 cache;
+    uint8_t *buffer_ptr;
+    uint32_t cache;
     int bit_count;
 #elif defined A32_BITSTREAM_READER
-    UINT32 *buffer_ptr;
-    UINT32 cache0;
-    UINT32 cache1;
+    uint32_t *buffer_ptr;
+    uint32_t cache0;
+    uint32_t cache1;
     int bit_count;
 #endif
     int size_in_bits;
@@ -285,7 +254,7 @@ typedef struct GetBitContext {
 
 static inline int get_bits_count(GetBitContext *s);
 
-#define VLC_TYPE INT16
+#define VLC_TYPE int16_t
 
 typedef struct VLC {
     int bits;
@@ -305,7 +274,7 @@ typedef struct RL_VLC_ELEM {
 
 /* used to avoid missaligned exceptions on some archs (alpha, ...) */
 #ifdef ARCH_X86
-#    define unaligned32(a) (*(UINT32*)(a))
+#    define unaligned32(a) (*(uint32_t*)(a))
 #else
 #    ifdef __GNUC__
 static inline uint32_t unaligned32(const void *v) {
@@ -357,7 +326,7 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
             s->buf_ptr[3] = bit_buf      ;
         } else
 #endif
-        *(UINT32 *)s->buf_ptr = be2me_32(bit_buf);
+        *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
         //printf("bitbuf = %08x\n", bit_buf);
         s->buf_ptr+=4;
 	bit_left+=32 - n;
@@ -700,7 +669,7 @@ static inline void skip_bits1(GetBitContext *s){
 }
 
 void init_get_bits(GetBitContext *s,
-                   UINT8 *buffer, int buffer_size);
+                   uint8_t *buffer, int buffer_size);
 
 int check_marker(GetBitContext *s, const char *msg);
 void align_get_bits(GetBitContext *s);

libavcodec/cyuv.c

@@ -56,7 +56,7 @@ static int cyuv_decode_init(AVCodecContext *avctx)
 
 static int cyuv_decode_frame(AVCodecContext *avctx, 
                              void *data, int *data_size,
-                             UINT8 *buf, int buf_size)
+                             uint8_t *buf, int buf_size)
 {
     CyuvDecodeContext *s=avctx->priv_data;
 

libavcodec/dct-test.c

@@ -40,13 +40,13 @@ static const unsigned short aanscales[64] = {
     4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
 };
 
-UINT8 cropTbl[256 + 2 * MAX_NEG_CROP];
+uint8_t cropTbl[256 + 2 * MAX_NEG_CROP];
 
-INT64 gettime(void)
+int64_t gettime(void)
 {
     struct timeval tv;
     gettimeofday(&tv,NULL);
-    return (INT64)tv.tv_sec * 1000000 + tv.tv_usec;
+    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
 }
 
 #define NB_ITS 20000
@@ -86,8 +86,8 @@ void dct_error(const char *name, int is_idct,
 {
     int it, i, scale;
     int err_inf, v;
-    INT64 err2, ti, ti1, it1;
-    INT64 sysErr[64], sysErrMax=0;
+    int64_t err2, ti, ti1, it1;
+    int64_t sysErr[64], sysErrMax=0;
     int maxout=0;
     int blockSumErrMax=0, blockSumErr;
 
@@ -261,10 +261,10 @@ void dct_error(const char *name, int is_idct,
 #endif
 }
 
-static UINT8 img_dest[64] __attribute__ ((aligned (8)));
-static UINT8 img_dest1[64] __attribute__ ((aligned (8)));
+static uint8_t img_dest[64] __attribute__ ((aligned (8)));
+static uint8_t img_dest1[64] __attribute__ ((aligned (8)));
 
-void idct248_ref(UINT8 *dest, int linesize, INT16 *block)
+void idct248_ref(uint8_t *dest, int linesize, int16_t *block)
 {
     static int init;
     static double c8[8][8];
@@ -345,7 +345,7 @@ void idct248_ref(UINT8 *dest, int linesize, INT16 *block)
 }
 
 void idct248_error(const char *name, 
-                    void (*idct248_put)(UINT8 *dest, int line_size, INT16 *block))
+                    void (*idct248_put)(uint8_t *dest, int line_size, int16_t *block))
 {
     int it, i, it1, ti, ti1, err_max, v;
 

libavcodec/dsputil.c

@@ -24,10 +24,10 @@
 
 int ff_bit_exact=0;
 
-UINT8 cropTbl[256 + 2 * MAX_NEG_CROP];
-UINT32 squareTbl[512];
+uint8_t cropTbl[256 + 2 * MAX_NEG_CROP];
+uint32_t squareTbl[512];
 
-const UINT8 ff_zigzag_direct[64] = {
+const uint8_t ff_zigzag_direct[64] = {
     0,   1,  8, 16,  9,  2,  3, 10,
     17, 24, 32, 25, 18, 11,  4,  5,
     12, 19, 26, 33, 40, 48, 41, 34,
@@ -39,9 +39,9 @@ const UINT8 ff_zigzag_direct[64] = {
 };
 
 /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
-UINT16 __align8 inv_zigzag_direct16[64];
+uint16_t __align8 inv_zigzag_direct16[64];
 
-const UINT8 ff_alternate_horizontal_scan[64] = {
+const uint8_t ff_alternate_horizontal_scan[64] = {
     0,  1,   2,  3,  8,  9, 16, 17, 
     10, 11,  4,  5,  6,  7, 15, 14,
     13, 12, 19, 18, 24, 25, 32, 33, 
@@ -52,7 +52,7 @@ const UINT8 ff_alternate_horizontal_scan[64] = {
     52, 53, 54, 55, 60, 61, 62, 63,
 };
 
-const UINT8 ff_alternate_vertical_scan[64] = {
+const uint8_t ff_alternate_vertical_scan[64] = {
     0,  8,  16, 24,  1,  9,  2, 10, 
     17, 25, 32, 40, 48, 56, 57, 49,
     41, 33, 26, 18,  3, 11,  4, 12, 
@@ -64,7 +64,7 @@ const UINT8 ff_alternate_vertical_scan[64] = {
 };
 
 /* a*inverse[b]>>32 == a/b for all 0<=a<=65536 && 2<=b<=255 */
-const UINT32 inverse[256]={
+const uint32_t inverse[256]={
          0, 4294967295U,2147483648U,1431655766, 1073741824,  858993460,  715827883,  613566757, 
  536870912,  477218589,  429496730,  390451573,  357913942,  330382100,  306783379,  286331154, 
  268435456,  252645136,  238609295,  226050911,  214748365,  204522253,  195225787,  186737709, 
@@ -99,7 +99,7 @@ const UINT32 inverse[256]={
   17318417,   17248865,   17179870,   17111424,   17043522,   16976156,   16909321,   16843010,
 };
 
-static int pix_sum_c(UINT8 * pix, int line_size)
+static int pix_sum_c(uint8_t * pix, int line_size)
 {
     int s, i, j;
 
@@ -121,10 +121,10 @@ static int pix_sum_c(UINT8 * pix, int line_size)
     return s;
 }
 
-static int pix_norm1_c(UINT8 * pix, int line_size)
+static int pix_norm1_c(uint8_t * pix, int line_size)
 {
     int s, i, j;
-    UINT32 *sq = squareTbl + 256;
+    uint32_t *sq = squareTbl + 256;
 
     s = 0;
     for (i = 0; i < 16; i++) {
@@ -170,10 +170,10 @@ static int pix_norm1_c(UINT8 * pix, int line_size)
 }
 
 
-static int sse8_c(void *v, UINT8 * pix1, UINT8 * pix2, int line_size)
+static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size)
 {
     int s, i;
-    UINT32 *sq = squareTbl + 256;
+    uint32_t *sq = squareTbl + 256;
 
     s = 0;
     for (i = 0; i < 8; i++) {
@@ -221,7 +221,7 @@ static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size)
     return s;
 }
 
-static void get_pixels_c(DCTELEM *restrict block, const UINT8 *pixels, int line_size)
+static void get_pixels_c(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
 {
     int i;
 
@@ -240,8 +240,8 @@ static void get_pixels_c(DCTELEM *restrict block, const UINT8 *pixels, int line_
     }
 }
 
-static void diff_pixels_c(DCTELEM *restrict block, const UINT8 *s1,
-			  const UINT8 *s2, int stride){
+static void diff_pixels_c(DCTELEM *restrict block, const uint8_t *s1,
+			  const uint8_t *s2, int stride){
     int i;
 
     /* read the pixels */
@@ -261,11 +261,11 @@ static void diff_pixels_c(DCTELEM *restrict block, const UINT8 *s1,
 }
 
 
-static void put_pixels_clamped_c(const DCTELEM *block, UINT8 *restrict pixels,
+static void put_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
 				 int line_size)
 {
     int i;
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;
     
     /* read the pixels */
     for(i=0;i<8;i++) {
@@ -283,11 +283,11 @@ static void put_pixels_clamped_c(const DCTELEM *block, UINT8 *restrict pixels,
     }
 }
 
-static void add_pixels_clamped_c(const DCTELEM *block, UINT8 *restrict pixels,
+static void add_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
                           int line_size)
 {
     int i;
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;
     
     /* read the pixels */
     for(i=0;i<8;i++) {
@@ -702,7 +702,7 @@ PIXOP2(put, op_put)
 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
 
 
-static void gmc1_c(UINT8 *dst, UINT8 *src, int stride, int h, int x16, int y16, int rounder)
+static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
 {
     const int A=(16-x16)*(16-y16);
     const int B=(   x16)*(16-y16);
@@ -725,7 +725,7 @@ static void gmc1_c(UINT8 *dst, UINT8 *src, int stride, int h, int x16, int y16,
     }
 }
 
-static void gmc_c(UINT8 *dst, UINT8 *src, int stride, int h, int ox, int oy, 
+static void gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy, 
                   int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
 {
     int y, vx, vy;
@@ -783,7 +783,7 @@ static void gmc_c(UINT8 *dst, UINT8 *src, int stride, int h, int ox, int oy,
     }
 }
 
-static inline void copy_block17(UINT8 *dst, UINT8 *src, int dstStride, int srcStride, int h)
+static inline void copy_block17(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
 {
     int i;
     for(i=0; i<h; i++)
@@ -798,7 +798,7 @@ static inline void copy_block17(UINT8 *dst, UINT8 *src, int dstStride, int srcSt
     }
 }
 
-static inline void copy_block9(UINT8 *dst, UINT8 *src, int dstStride, int srcStride, int h)
+static inline void copy_block9(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
 {
     int i;
     for(i=0; i<h; i++)
@@ -813,8 +813,8 @@ static inline void copy_block9(UINT8 *dst, UINT8 *src, int dstStride, int srcStr
 
 
 #define QPEL_MC(r, OPNAME, RND, OP) \
-static void OPNAME ## mpeg4_qpel8_h_lowpass(UINT8 *dst, UINT8 *src, int dstStride, int srcStride, int h){\
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;\
+static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     int i;\
     for(i=0; i<h; i++)\
     {\
@@ -831,9 +831,9 @@ static void OPNAME ## mpeg4_qpel8_h_lowpass(UINT8 *dst, UINT8 *src, int dstStrid
     }\
 }\
 \
-static void OPNAME ## mpeg4_qpel8_v_lowpass(UINT8 *dst, UINT8 *src, int dstStride, int srcStride){\
+static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
     const int w=8;\
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;\
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     int i;\
     for(i=0; i<w; i++)\
     {\
@@ -859,8 +859,8 @@ static void OPNAME ## mpeg4_qpel8_v_lowpass(UINT8 *dst, UINT8 *src, int dstStrid
     }\
 }\
 \
-static void OPNAME ## mpeg4_qpel16_h_lowpass(UINT8 *dst, UINT8 *src, int dstStride, int srcStride, int h){\
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;\
+static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     int i;\
     \
     for(i=0; i<h; i++)\
@@ -886,8 +886,8 @@ static void OPNAME ## mpeg4_qpel16_h_lowpass(UINT8 *dst, UINT8 *src, int dstStri
     }\
 }\
 \
-static void OPNAME ## mpeg4_qpel16_v_lowpass(UINT8 *dst, UINT8 *src, int dstStride, int srcStride){\
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;\
+static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;\
     int i;\
     const int w=16;\
     for(i=0; i<w; i++)\
@@ -930,367 +930,367 @@ static void OPNAME ## mpeg4_qpel16_v_lowpass(UINT8 *dst, UINT8 *src, int dstStri
     }\
 }\
 \
-static void OPNAME ## qpel8_mc00_c (UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## pixels8_c(dst, src, stride, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc10_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 half[64];\
+static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t half[64];\
     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
     OPNAME ## pixels8_l2(dst, src, half, stride, stride, 8, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc20_c(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc30_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 half[64];\
+static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t half[64];\
     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
     OPNAME ## pixels8_l2(dst, src+1, half, stride, stride, 8, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc01_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 half[64];\
+static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t half[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
     OPNAME ## pixels8_l2(dst, full, half, stride, 16, 8, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc02_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
+static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
     copy_block9(full, src, 16, stride, 9);\
     OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\
 }\
 \
-static void OPNAME ## qpel8_mc03_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 half[64];\
+static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t half[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
     OPNAME ## pixels8_l2(dst, full+16, half, stride, 16, 8, 8);\
 }\
-void ff_ ## OPNAME ## qpel8_mc11_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfV[64];\
-    UINT8 halfHV[64];\
+void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfV[64];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l4(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc11_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfHV[64];\
+static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
 }\
-void ff_ ## OPNAME ## qpel8_mc31_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfV[64];\
-    UINT8 halfHV[64];\
+void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfV[64];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l4(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc31_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfHV[64];\
+static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
 }\
-void ff_ ## OPNAME ## qpel8_mc13_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfV[64];\
-    UINT8 halfHV[64];\
+void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfV[64];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l4(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc13_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfHV[64];\
+static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
 }\
-void ff_ ## OPNAME ## qpel8_mc33_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfV[64];\
-    UINT8 halfHV[64];\
+void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfV[64];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full  , 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l4(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc33_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfHV[64];\
+static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc21_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 halfH[72];\
-    UINT8 halfHV[64];\
+static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t halfH[72];\
+    uint8_t halfHV[64];\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc23_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 halfH[72];\
-    UINT8 halfHV[64];\
+static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t halfH[72];\
+    uint8_t halfHV[64];\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
 }\
-void ff_ ## OPNAME ## qpel8_mc12_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfV[64];\
-    UINT8 halfHV[64];\
+void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfV[64];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc12_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
+static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
 }\
-void ff_ ## OPNAME ## qpel8_mc32_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
-    UINT8 halfV[64];\
-    UINT8 halfHV[64];\
+void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
+    uint8_t halfV[64];\
+    uint8_t halfHV[64];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc32_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[16*9];\
-    UINT8 halfH[72];\
+static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[16*9];\
+    uint8_t halfH[72];\
     copy_block9(full, src, 16, stride, 9);\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
 }\
-static void OPNAME ## qpel8_mc22_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 halfH[72];\
+static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t halfH[72];\
     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
 }\
-static void OPNAME ## qpel16_mc00_c (UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## pixels16_c(dst, src, stride, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc10_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 half[256];\
+static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t half[256];\
     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
     OPNAME ## pixels16_l2(dst, src, half, stride, stride, 16, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc20_c(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc30_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 half[256];\
+static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t half[256];\
     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
     OPNAME ## pixels16_l2(dst, src+1, half, stride, stride, 16, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc01_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 half[256];\
+static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t half[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
     OPNAME ## pixels16_l2(dst, full, half, stride, 24, 16, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc02_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
+static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
     copy_block17(full, src, 24, stride, 17);\
     OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\
 }\
 \
-static void OPNAME ## qpel16_mc03_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 half[256];\
+static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t half[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
     OPNAME ## pixels16_l2(dst, full+24, half, stride, 24, 16, 16);\
 }\
-void ff_ ## OPNAME ## qpel16_mc11_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfV[256];\
-    UINT8 halfHV[256];\
+void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfV[256];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l4(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc11_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfHV[256];\
+static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
 }\
-void ff_ ## OPNAME ## qpel16_mc31_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfV[256];\
-    UINT8 halfHV[256];\
+void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfV[256];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l4(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc31_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfHV[256];\
+static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
 }\
-void ff_ ## OPNAME ## qpel16_mc13_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfV[256];\
-    UINT8 halfHV[256];\
+void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfV[256];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l4(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc13_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfHV[256];\
+static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
 }\
-void ff_ ## OPNAME ## qpel16_mc33_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfV[256];\
-    UINT8 halfHV[256];\
+void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfV[256];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full  , 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l4(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc33_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfHV[256];\
+static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc21_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 halfH[272];\
-    UINT8 halfHV[256];\
+static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t halfH[272];\
+    uint8_t halfHV[256];\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc23_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 halfH[272];\
-    UINT8 halfHV[256];\
+static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t halfH[272];\
+    uint8_t halfHV[256];\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
 }\
-void ff_ ## OPNAME ## qpel16_mc12_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfV[256];\
-    UINT8 halfHV[256];\
+void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfV[256];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc12_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
+static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
 }\
-void ff_ ## OPNAME ## qpel16_mc32_old_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
-    UINT8 halfV[256];\
-    UINT8 halfHV[256];\
+void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
+    uint8_t halfV[256];\
+    uint8_t halfHV[256];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc32_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 full[24*17];\
-    UINT8 halfH[272];\
+static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t full[24*17];\
+    uint8_t halfH[272];\
     copy_block17(full, src, 24, stride, 17);\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
 }\
-static void OPNAME ## qpel16_mc22_c(UINT8 *dst, UINT8 *src, int stride){\
-    UINT8 halfH[272];\
+static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
+    uint8_t halfH[272];\
     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
 }
@@ -1405,7 +1405,7 @@ static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
 }
 
 
-static inline int pix_abs16x16_c(UINT8 *pix1, UINT8 *pix2, int line_size)
+static inline int pix_abs16x16_c(uint8_t *pix1, uint8_t *pix2, int line_size)
 {
     int s, i;
 
@@ -1433,7 +1433,7 @@ static inline int pix_abs16x16_c(UINT8 *pix1, UINT8 *pix2, int line_size)
     return s;
 }
 
-static int pix_abs16x16_x2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
+static int pix_abs16x16_x2_c(uint8_t *pix1, uint8_t *pix2, int line_size)
 {
     int s, i;
 
@@ -1461,10 +1461,10 @@ static int pix_abs16x16_x2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
     return s;
 }
 
-static int pix_abs16x16_y2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
+static int pix_abs16x16_y2_c(uint8_t *pix1, uint8_t *pix2, int line_size)
 {
     int s, i;
-    UINT8 *pix3 = pix2 + line_size;
+    uint8_t *pix3 = pix2 + line_size;
 
     s = 0;
     for(i=0;i<16;i++) {
@@ -1491,10 +1491,10 @@ static int pix_abs16x16_y2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
     return s;
 }
 
-static int pix_abs16x16_xy2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
+static int pix_abs16x16_xy2_c(uint8_t *pix1, uint8_t *pix2, int line_size)
 {
     int s, i;
-    UINT8 *pix3 = pix2 + line_size;
+    uint8_t *pix3 = pix2 + line_size;
 
     s = 0;
     for(i=0;i<16;i++) {
@@ -1521,7 +1521,7 @@ static int pix_abs16x16_xy2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
     return s;
 }
 
-static inline int pix_abs8x8_c(UINT8 *pix1, UINT8 *pix2, int line_size)
+static inline int pix_abs8x8_c(uint8_t *pix1, uint8_t *pix2, int line_size)
 {
     int s, i;
 
@@ -1541,7 +1541,7 @@ static inline int pix_abs8x8_c(UINT8 *pix1, UINT8 *pix2, int line_size)
     return s;
 }
 
-static int pix_abs8x8_x2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
+static int pix_abs8x8_x2_c(uint8_t *pix1, uint8_t *pix2, int line_size)
 {
     int s, i;
 
@@ -1561,10 +1561,10 @@ static int pix_abs8x8_x2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
     return s;
 }
 
-static int pix_abs8x8_y2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
+static int pix_abs8x8_y2_c(uint8_t *pix1, uint8_t *pix2, int line_size)
 {
     int s, i;
-    UINT8 *pix3 = pix2 + line_size;
+    uint8_t *pix3 = pix2 + line_size;
 
     s = 0;
     for(i=0;i<8;i++) {
@@ -1583,10 +1583,10 @@ static int pix_abs8x8_y2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
     return s;
 }
 
-static int pix_abs8x8_xy2_c(UINT8 *pix1, UINT8 *pix2, int line_size)
+static int pix_abs8x8_xy2_c(uint8_t *pix1, uint8_t *pix2, int line_size)
 {
     int s, i;
-    UINT8 *pix3 = pix2 + line_size;
+    uint8_t *pix3 = pix2 + line_size;
 
     s = 0;
     for(i=0;i<8;i++) {
@@ -1613,7 +1613,7 @@ static int sad8x8_c(void *s, uint8_t *a, uint8_t *b, int stride){
     return pix_abs8x8_c(a,b,stride);
 }
 
-void ff_block_permute(DCTELEM *block, UINT8 *permutation, const UINT8 *scantable, int last)
+void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
 {
     int i;
     DCTELEM temp[64];
@@ -1822,7 +1822,7 @@ static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *s
 
 static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride){
     MpegEncContext * const s= (MpegEncContext *)c;
-    const UINT8 *scantable= s->intra_scantable.permutated;
+    const uint8_t *scantable= s->intra_scantable.permutated;
     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64/8];
     uint64_t __align8 aligned_bak[stride];
     DCTELEM * const temp= (DCTELEM*)aligned_temp;
@@ -1896,7 +1896,7 @@ static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int
 
 static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride){
     MpegEncContext * const s= (MpegEncContext *)c;
-    const UINT8 *scantable= s->intra_scantable.permutated;
+    const uint8_t *scantable= s->intra_scantable.permutated;
     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64/8];
     DCTELEM * const temp= (DCTELEM*)aligned_temp;
     int i, last, run, bits, level, start_i;

libavcodec/dsputil.h

@@ -35,16 +35,16 @@ void j_rev_dct (DCTELEM *data);
 void ff_fdct_mmx(DCTELEM *block);
 
 /* encoding scans */
-extern const UINT8 ff_alternate_horizontal_scan[64];
-extern const UINT8 ff_alternate_vertical_scan[64];
-extern const UINT8 ff_zigzag_direct[64];
+extern const uint8_t ff_alternate_horizontal_scan[64];
+extern const uint8_t ff_alternate_vertical_scan[64];
+extern const uint8_t ff_zigzag_direct[64];
 
 /* pixel operations */
 #define MAX_NEG_CROP 384
 
 /* temporary */
-extern UINT32 squareTbl[512];
-extern UINT8 cropTbl[256 + 2 * MAX_NEG_CROP];
+extern uint32_t squareTbl[512];
+extern uint8_t cropTbl[256 + 2 * MAX_NEG_CROP];
 
 
 /* minimum alignment rules ;)
@@ -58,22 +58,22 @@ i (michael) didnt check them, these are just the alignents which i think could b
 */
 
 /*
-void get_pixels_c(DCTELEM *block, const UINT8 *pixels, int line_size);
-void diff_pixels_c(DCTELEM *block, const UINT8 *s1, const UINT8 *s2, int stride);
-void put_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size);
-void add_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size);
+void get_pixels_c(DCTELEM *block, const uint8_t *pixels, int line_size);
+void diff_pixels_c(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, int stride);
+void put_pixels_clamped_c(const DCTELEM *block, uint8_t *pixels, int line_size);
+void add_pixels_clamped_c(const DCTELEM *block, uint8_t *pixels, int line_size);
 void clear_blocks_c(DCTELEM *blocks);
 */
 
 /* add and put pixel (decoding) */
 // blocksizes for op_pixels_func are 8x4,8x8 16x8 16x16
-typedef void (*op_pixels_func)(UINT8 *block/*align width (8 or 16)*/, const UINT8 *pixels/*align 1*/, int line_size, int h);
-typedef void (*qpel_mc_func)(UINT8 *dst/*align width (8 or 16)*/, UINT8 *src/*align 1*/, int stride);
+typedef void (*op_pixels_func)(uint8_t *block/*align width (8 or 16)*/, const uint8_t *pixels/*align 1*/, int line_size, int h);
+typedef void (*qpel_mc_func)(uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);
 
 #define DEF_OLD_QPEL(name)\
-void ff_put_        ## name (UINT8 *dst/*align width (8 or 16)*/, UINT8 *src/*align 1*/, int stride);\
-void ff_put_no_rnd_ ## name (UINT8 *dst/*align width (8 or 16)*/, UINT8 *src/*align 1*/, int stride);\
-void ff_avg_        ## name (UINT8 *dst/*align width (8 or 16)*/, UINT8 *src/*align 1*/, int stride);
+void ff_put_        ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\
+void ff_put_no_rnd_ ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\
+void ff_avg_        ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);
 
 DEF_OLD_QPEL(qpel16_mc11_old_c)
 DEF_OLD_QPEL(qpel16_mc31_old_c)
@@ -96,22 +96,22 @@ static void a(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
 
 /* motion estimation */
 
-typedef int (*op_pixels_abs_func)(UINT8 *blk1/*align width (8 or 16)*/, UINT8 *blk2/*align 1*/, int line_size)/* __attribute__ ((const))*/;
+typedef int (*op_pixels_abs_func)(uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size)/* __attribute__ ((const))*/;
 
-typedef int (*me_cmp_func)(void /*MpegEncContext*/ *s, UINT8 *blk1/*align width (8 or 16)*/, UINT8 *blk2/*align 1*/, int line_size)/* __attribute__ ((const))*/;
+typedef int (*me_cmp_func)(void /*MpegEncContext*/ *s, uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size)/* __attribute__ ((const))*/;
 
 typedef struct DSPContext {
     /* pixel ops : interface with DCT */
-    void (*get_pixels)(DCTELEM *block/*align 16*/, const UINT8 *pixels/*align 8*/, int line_size);
-    void (*diff_pixels)(DCTELEM *block/*align 16*/, const UINT8 *s1/*align 8*/, const UINT8 *s2/*align 8*/, int stride);
-    void (*put_pixels_clamped)(const DCTELEM *block/*align 16*/, UINT8 *pixels/*align 8*/, int line_size);
-    void (*add_pixels_clamped)(const DCTELEM *block/*align 16*/, UINT8 *pixels/*align 8*/, int line_size);
-    void (*gmc1)(UINT8 *dst/*align 8*/, UINT8 *src/*align 1*/, int srcStride, int h, int x16, int y16, int rounder);
-    void (*gmc )(UINT8 *dst/*align 8*/, UINT8 *src/*align 1*/, int stride, int h, int ox, int oy,
+    void (*get_pixels)(DCTELEM *block/*align 16*/, const uint8_t *pixels/*align 8*/, int line_size);
+    void (*diff_pixels)(DCTELEM *block/*align 16*/, const uint8_t *s1/*align 8*/, const uint8_t *s2/*align 8*/, int stride);
+    void (*put_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
+    void (*add_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
+    void (*gmc1)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x16, int y16, int rounder);
+    void (*gmc )(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int ox, int oy,
 		    int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
     void (*clear_blocks)(DCTELEM *blocks/*align 16*/);
-    int (*pix_sum)(UINT8 * pix, int line_size);
-    int (*pix_norm1)(UINT8 * pix, int line_size);
+    int (*pix_sum)(uint8_t * pix, int line_size);
+    int (*pix_norm1)(uint8_t * pix, int line_size);
     me_cmp_func sad[2]; /* identical to pix_absAxA except additional void * */
     me_cmp_func sse[2];
     me_cmp_func hadamard8_diff[2];
@@ -157,7 +157,7 @@ void dsputil_init(DSPContext* p, unsigned mask);
  * permute block according to permuatation.
  * @param last last non zero element in scantable order
  */
-void ff_block_permute(DCTELEM *block, UINT8 *permutation, const UINT8 *scantable, int last);
+void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last);
 
 #define emms_c()
 
@@ -177,8 +177,8 @@ int mm_support(void);
 
 extern int mm_flags;
 
-void add_pixels_clamped_mmx(const DCTELEM *block, UINT8 *pixels, int line_size);
-void put_pixels_clamped_mmx(const DCTELEM *block, UINT8 *pixels, int line_size);
+void add_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size);
+void put_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size);
 
 static inline void emms(void)
 {
@@ -264,7 +264,7 @@ struct unaligned_32 { uint32_t l; } __attribute__((packed));
 #endif /* !__GNUC__ */
 
 /* PSNR */
-void get_psnr(UINT8 *orig_image[3], UINT8 *coded_image[3],
+void get_psnr(uint8_t *orig_image[3], uint8_t *coded_image[3],
               int orig_linesize[3], int coded_linesize,
               AVCodecContext *avctx);
 

libavcodec/dv.c

@@ -32,15 +32,15 @@ typedef struct DVVideoDecodeContext {
     VLC *vlc;
     int sampling_411; /* 0 = 420, 1 = 411 */
     int width, height;
-    UINT8 *current_picture[3]; /* picture structure */
+    uint8_t *current_picture[3]; /* picture structure */
     AVFrame picture;
     int linesize[3];
     DCTELEM block[5*6][64] __align8;
-    UINT8 dv_zigzag[2][64];
-    UINT8 idct_permutation[64];
+    uint8_t dv_zigzag[2][64];
+    uint8_t idct_permutation[64];
     /* XXX: move it to static storage ? */
-    UINT8 dv_shift[2][22][64];
-    void (*idct_put[2])(UINT8 *dest, int line_size, DCTELEM *block);
+    uint8_t dv_shift[2][22][64];
+    void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
 } DVVideoDecodeContext;
 
 #include "dvdata.h"
@@ -136,18 +136,18 @@ static int dvvideo_decode_init(AVCodecContext *avctx)
 //#define VLC_DEBUG
 
 typedef struct BlockInfo {
-    const UINT8 *shift_table;
-    const UINT8 *scan_table;
-    UINT8 pos; /* position in block */
-    UINT8 eob_reached; /* true if EOB has been reached */
-    UINT8 dct_mode;
-    UINT8 partial_bit_count;
-    UINT16 partial_bit_buffer;
+    const uint8_t *shift_table;
+    const uint8_t *scan_table;
+    uint8_t pos; /* position in block */
+    uint8_t eob_reached; /* true if EOB has been reached */
+    uint8_t dct_mode;
+    uint8_t partial_bit_count;
+    uint16_t partial_bit_buffer;
     int shift_offset;
 } BlockInfo;
 
 /* block size in bits */
-static const UINT16 block_sizes[6] = {
+static const uint16_t block_sizes[6] = {
     112, 112, 112, 112, 80, 80
 };
 
@@ -161,8 +161,8 @@ static void dv_decode_ac(DVVideoDecodeContext *s,
 {
     int last_re_index;
     int shift_offset = mb->shift_offset;
-    const UINT8 *scan_table = mb->scan_table;
-    const UINT8 *shift_table = mb->shift_table;
+    const uint8_t *scan_table = mb->scan_table;
+    const uint8_t *shift_table = mb->shift_table;
     int pos = mb->pos;
     int level, pos1, sign, run;
     int partial_bit_count;
@@ -176,8 +176,8 @@ static void dv_decode_ac(DVVideoDecodeContext *s,
     /* if we must parse a partial vlc, we do it here */
     partial_bit_count = mb->partial_bit_count;
     if (partial_bit_count > 0) {
-        UINT8 buf[4];
-        UINT32 v;
+        uint8_t buf[4];
+        uint32_t v;
         int l, l1;
         GetBitContext gb1;
 
@@ -298,21 +298,21 @@ static inline void bit_copy(PutBitContext *pb, GetBitContext *gb, int bits_left)
 
 /* mb_x and mb_y are in units of 8 pixels */
 static inline void dv_decode_video_segment(DVVideoDecodeContext *s, 
-                                           UINT8 *buf_ptr1, 
-                                           const UINT16 *mb_pos_ptr)
+                                           uint8_t *buf_ptr1, 
+                                           const uint16_t *mb_pos_ptr)
 {
     int quant, dc, dct_mode, class1, j;
     int mb_index, mb_x, mb_y, v, last_index;
     DCTELEM *block, *block1;
     int c_offset, bits_left;
-    UINT8 *y_ptr;
+    uint8_t *y_ptr;
     BlockInfo mb_data[5 * 6], *mb, *mb1;
-    void (*idct_put)(UINT8 *dest, int line_size, DCTELEM *block);
-    UINT8 *buf_ptr;
+    void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
+    uint8_t *buf_ptr;
     PutBitContext pb, vs_pb;
-    UINT8 mb_bit_buffer[80 + 4]; /* allow some slack */
+    uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */
     int mb_bit_count;
-    UINT8 vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
+    uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
     int vs_bit_count;
     
     memset(s->block, 0, sizeof(s->block));
@@ -493,12 +493,12 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
    144000 bytes for PAL) */
 static int dvvideo_decode_frame(AVCodecContext *avctx, 
                                  void *data, int *data_size,
-                                 UINT8 *buf, int buf_size)
+                                 uint8_t *buf, int buf_size)
 {
     DVVideoDecodeContext *s = avctx->priv_data;
     int sct, dsf, apt, ds, nb_dif_segs, vs, width, height, i, packet_size;
-    UINT8 *buf_ptr;
-    const UINT16 *mb_pos_ptr;
+    uint8_t *buf_ptr;
+    const uint16_t *mb_pos_ptr;
     
     /* parse id */
     init_get_bits(&s->gb, buf, buf_size*8);
@@ -642,9 +642,9 @@ static int dvaudio_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-static UINT16 dv_audio_12to16(UINT16 sample)
+static uint16_t dv_audio_12to16(uint16_t sample)
 {
-    UINT16 shift, result;
+    uint16_t shift, result;
     
     sample = (sample < 0x800) ? sample : sample | 0xf000;
     shift = (sample & 0xf00) >> 8;
@@ -676,13 +676,13 @@ static UINT16 dv_audio_12to16(UINT16 sample)
 */
 static int dvaudio_decode_frame(AVCodecContext *avctx, 
                                  void *data, int *data_size,
-                                 UINT8 *buf, int buf_size)
+                                 uint8_t *buf, int buf_size)
 {
     DVVideoDecodeContext *s = avctx->priv_data;
-    const UINT16 (*unshuffle)[9];
+    const uint16_t (*unshuffle)[9];
     int smpls, freq, quant, sys, stride, difseg, ad, dp, nb_dif_segs, i;
-    UINT16 lc, rc;
-    UINT8 *buf_ptr;
+    uint16_t lc, rc;
+    uint8_t *buf_ptr;
     
     /* parse id */
     init_get_bits(&s->gb, &buf[AAUX_OFFSET], 5*8);
@@ -742,10 +742,10 @@ static int dvaudio_decode_frame(AVCodecContext *avctx,
 		       if (difseg >= nb_dif_segs/2)
 			   goto out;  /* We're not doing 4ch at this time */
 		       
-		       lc = ((UINT16)buf_ptr[dp] << 4) | 
-			    ((UINT16)buf_ptr[dp+2] >> 4);
-		       rc = ((UINT16)buf_ptr[dp+1] << 4) |
-			    ((UINT16)buf_ptr[dp+2] & 0x0f);
+		       lc = ((uint16_t)buf_ptr[dp] << 4) | 
+			    ((uint16_t)buf_ptr[dp+2] >> 4);
+		       rc = ((uint16_t)buf_ptr[dp+1] << 4) |
+			    ((uint16_t)buf_ptr[dp+2] & 0x0f);
 		       lc = dv_audio_12to16(lc);
 		       rc = dv_audio_12to16(rc);
 

libavcodec/dvdata.h

@@ -20,7 +20,7 @@
 #define NB_DV_VLC 409
 #define AAUX_OFFSET (80*6 + 80*16*3 + 3)
 
-static const UINT16 dv_vlc_bits[409] = {
+static const uint16_t dv_vlc_bits[409] = {
  0x0000, 0x0002, 0x0007, 0x0008, 0x0009, 0x0014, 0x0015, 0x0016,
  0x0017, 0x0030, 0x0031, 0x0032, 0x0033, 0x0068, 0x0069, 0x006a,
  0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 0x00e0, 0x00e1, 0x00e2,
@@ -75,7 +75,7 @@ static const UINT16 dv_vlc_bits[409] = {
  0x0006,
 };
 
-static const UINT8 dv_vlc_len[409] = {
+static const uint8_t dv_vlc_len[409] = {
   2,  3,  4,  4,  4,  5,  5,  5,
   5,  6,  6,  6,  6,  7,  7,  7,
   7,  7,  7,  7,  7,  8,  8,  8,
@@ -130,7 +130,7 @@ static const UINT8 dv_vlc_len[409] = {
   4,
 };
 
-static const UINT8 dv_vlc_run[409] = {
+static const uint8_t dv_vlc_run[409] = {
   0,  0,  1,  0,  0,  2,  1,  0,
   0,  3,  4,  0,  0,  5,  6,  2,
   1,  1,  0,  0,  0,  7,  8,  9,
@@ -185,7 +185,7 @@ static const UINT8 dv_vlc_run[409] = {
   0,
 };
 
-static const UINT8 dv_vlc_level[409] = {
+static const uint8_t dv_vlc_level[409] = {
   1,  2,  1,  3,  4,  1,  2,  5,
   6,  1,  1,  7,  8,  1,  1,  2,
   3,  4,  9, 10, 11,  1,  1,  1,
@@ -242,7 +242,7 @@ static const UINT8 dv_vlc_level[409] = {
 
 /* Specific zigzag scan for 248 idct. NOTE that unlike the
    specification, we interleave the fields */
-static const UINT8 dv_248_zigzag[64] = {
+static const uint8_t dv_248_zigzag[64] = {
   0,  8,  1,  9, 16, 24,  2, 10,
  17, 25, 32, 40, 48, 56, 33, 41,
  18, 26,  3, 11,  4, 12, 19, 27,
@@ -254,7 +254,7 @@ static const UINT8 dv_248_zigzag[64] = {
 };
 
 /* unquant tables (not used directly) */
-static const UINT8 dv_88_areas[64] = {
+static const uint8_t dv_88_areas[64] = {
     0,0,0,1,1,1,2,2,
     0,0,1,1,1,2,2,2,
     0,1,1,1,2,2,2,3,
@@ -265,7 +265,7 @@ static const UINT8 dv_88_areas[64] = {
     2,2,3,3,3,3,3,3,
 };
 
-static const UINT8 dv_248_areas[64] = {
+static const uint8_t dv_248_areas[64] = {
     0,0,1,1,1,2,2,3,
     0,0,1,1,2,2,2,3,
     0,1,1,2,2,2,3,3,
@@ -276,7 +276,7 @@ static const UINT8 dv_248_areas[64] = {
     1,2,2,3,3,3,3,3,
 };
 
-static UINT8 dv_quant_shifts[22][4] = {
+static uint8_t dv_quant_shifts[22][4] = {
   { 3,3,4,4 }, 
   { 3,3,4,4 }, 
   { 2,3,3,4 }, 
@@ -301,12 +301,12 @@ static UINT8 dv_quant_shifts[22][4] = {
   { 0,0,0,0 },
 };
 
-static const UINT8 dv_quant_offset[4] = { 6, 3, 0, 1 };
+static const uint8_t dv_quant_offset[4] = { 6, 3, 0, 1 };
 
 /* NOTE: I prefer hardcoding the positionning of dv blocks, it is
    simpler :-) */
 
-static const UINT16 dv_place_420[1620] = {
+static const uint16_t dv_place_420[1620] = {
  0x0c24, 0x2412, 0x3036, 0x0000, 0x1848,
  0x0e24, 0x2612, 0x3236, 0x0200, 0x1a48,
  0x1024, 0x2812, 0x3436, 0x0400, 0x1c48,
@@ -633,7 +633,7 @@ static const UINT16 dv_place_420[1620] = {
  0x0a34, 0x2222, 0x2e46, 0x4610, 0x1658,
 };
 
-static const UINT16 dv_place_411[1350] = {
+static const uint16_t dv_place_411[1350] = {
  0x0c24, 0x2710, 0x3334, 0x0000, 0x1848,
  0x0d24, 0x2810, 0x3434, 0x0100, 0x1948,
  0x0e24, 0x2910, 0x3534, 0x0200, 0x1a48,
@@ -906,7 +906,7 @@ static const UINT16 dv_place_411[1350] = {
  0x0834, 0x2320, 0x2f44, 0x3810, 0x1658,
 };
 
-static const UINT16 dv_place_audio60[10][9] = {
+static const uint16_t dv_place_audio60[10][9] = {
   {  0, 30, 60, 20, 50, 80, 10, 40, 70 }, /* 1st channel */
   {  6, 36, 66, 26, 56, 86, 16, 46, 76 },
   { 12, 42, 72,  2, 32, 62, 22, 52, 82 },
@@ -920,7 +920,7 @@ static const UINT16 dv_place_audio60[10][9] = {
   { 25, 55, 85, 15, 45, 75,  5, 35, 65 },
 };
 
-static const UINT16 dv_place_audio50[12][9] = {
+static const uint16_t dv_place_audio50[12][9] = {
   {   0,  36,  72,  26,  62,  98,  16,  52,  88}, /* 1st channel */
   {   6,  42,  78,  32,  68, 104,  22,  58,  94},
   {  12,  48,  84,   2,  38,  74,  28,  64, 100},

libavcodec/error_resilience.c

@@ -54,7 +54,7 @@ static void put_dc(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t
     }
 }
 
-static void filter181(INT16 *data, int width, int height, int stride){
+static void filter181(int16_t *data, int width, int height, int stride){
     int x,y;
 
     /* horizontal filter */
@@ -95,7 +95,7 @@ static void filter181(INT16 *data, int width, int height, int stride){
  * @param w	width in 8 pixel blocks
  * @param h	height in 8 pixel blocks
  */
-static void guess_dc(MpegEncContext *s, INT16 *dc, int w, int h, int stride, int is_luma){
+static void guess_dc(MpegEncContext *s, int16_t *dc, int w, int h, int stride, int is_luma){
     int b_x, b_y;
 
     for(b_y=0; b_y<h; b_y++){
@@ -103,7 +103,7 @@ static void guess_dc(MpegEncContext *s, INT16 *dc, int w, int h, int stride, int
             int color[4]={1024,1024,1024,1024};
             int distance[4]={9999,9999,9999,9999};
             int mb_index, error, j;
-            INT64 guess, weight_sum;
+            int64_t guess, weight_sum;
             
             mb_index= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_width;
             
@@ -163,8 +163,8 @@ static void guess_dc(MpegEncContext *s, INT16 *dc, int w, int h, int stride, int
             weight_sum=0;
             guess=0;
             for(j=0; j<4; j++){
-                INT64 weight= 256*256*256*16/distance[j];
-                guess+= weight*(INT64)color[j];
+                int64_t weight= 256*256*256*16/distance[j];
+                guess+= weight*(int64_t)color[j];
                 weight_sum+= weight;
             }
             guess= (guess + weight_sum/2) / weight_sum;
@@ -179,9 +179,9 @@ static void guess_dc(MpegEncContext *s, INT16 *dc, int w, int h, int stride, int
  * @param w	width in 8 pixel blocks
  * @param h	height in 8 pixel blocks
  */
-static void h_block_filter(MpegEncContext *s, UINT8 *dst, int w, int h, int stride, int is_luma){
+static void h_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
     int b_x, b_y;
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
     for(b_y=0; b_y<h; b_y++){
         for(b_x=0; b_x<w-1; b_x++){
@@ -193,8 +193,8 @@ static void h_block_filter(MpegEncContext *s, UINT8 *dst, int w, int h, int stri
             int left_damage =  left_status&(DC_ERROR|AC_ERROR|MV_ERROR);
             int right_damage= right_status&(DC_ERROR|AC_ERROR|MV_ERROR);
             int offset= b_x*8 + b_y*stride*8;
-            INT16 *left_mv=  s->motion_val[s->block_wrap[0]*((b_y<<(1-is_luma)) + 1) + ( b_x   <<(1-is_luma))];
-            INT16 *right_mv= s->motion_val[s->block_wrap[0]*((b_y<<(1-is_luma)) + 1) + ((b_x+1)<<(1-is_luma))];
+            int16_t *left_mv=  s->motion_val[s->block_wrap[0]*((b_y<<(1-is_luma)) + 1) + ( b_x   <<(1-is_luma))];
+            int16_t *right_mv= s->motion_val[s->block_wrap[0]*((b_y<<(1-is_luma)) + 1) + ((b_x+1)<<(1-is_luma))];
             
             if(!(left_damage||right_damage)) continue; // both undamaged
             
@@ -239,9 +239,9 @@ static void h_block_filter(MpegEncContext *s, UINT8 *dst, int w, int h, int stri
  * @param w	width in 8 pixel blocks
  * @param h	height in 8 pixel blocks
  */
-static void v_block_filter(MpegEncContext *s, UINT8 *dst, int w, int h, int stride, int is_luma){
+static void v_block_filter(MpegEncContext *s, uint8_t *dst, int w, int h, int stride, int is_luma){
     int b_x, b_y;
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
     for(b_y=0; b_y<h-1; b_y++){
         for(b_x=0; b_x<w; b_x++){
@@ -253,8 +253,8 @@ static void v_block_filter(MpegEncContext *s, UINT8 *dst, int w, int h, int stri
             int top_damage =      top_status&(DC_ERROR|AC_ERROR|MV_ERROR);
             int bottom_damage= bottom_status&(DC_ERROR|AC_ERROR|MV_ERROR);
             int offset= b_x*8 + b_y*stride*8;
-            INT16 *top_mv=    s->motion_val[s->block_wrap[0]*(( b_y   <<(1-is_luma)) + 1) + (b_x<<(1-is_luma))];
-            INT16 *bottom_mv= s->motion_val[s->block_wrap[0]*(((b_y+1)<<(1-is_luma)) + 1) + (b_x<<(1-is_luma))];
+            int16_t *top_mv=    s->motion_val[s->block_wrap[0]*(( b_y   <<(1-is_luma)) + 1) + (b_x<<(1-is_luma))];
+            int16_t *bottom_mv= s->motion_val[s->block_wrap[0]*(((b_y+1)<<(1-is_luma)) + 1) + (b_x<<(1-is_luma))];
             
             if(!(top_damage||bottom_damage)) continue; // both undamaged
             
@@ -295,7 +295,7 @@ static void v_block_filter(MpegEncContext *s, UINT8 *dst, int w, int h, int stri
 }
 
 static void guess_mv(MpegEncContext *s){
-    UINT8 fixed[s->mb_num];
+    uint8_t fixed[s->mb_num];
 #define MV_FROZEN    3
 #define MV_CHANGED   2
 #define MV_UNCHANGED 1
@@ -464,7 +464,7 @@ int score_sum=0;
                     s->mb_y= mb_y;
                     for(j=0; j<pred_count; j++){
                         int score=0;
-                        UINT8 *src= s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
+                        uint8_t *src= s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
 
                         s->motion_val[mot_index][0]= s->mv[0][0][0]= mv_predictor[j][0];
                         s->motion_val[mot_index][1]= s->mv[0][0][1]= mv_predictor[j][1];
@@ -558,8 +558,8 @@ static int is_intra_more_likely(MpegEncContext *s){
             if((j%skip_amount) != 0) continue; //skip a few to speed things up
     
             if(s->pict_type==I_TYPE){
-                UINT8 *mb_ptr     = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
-                UINT8 *last_mb_ptr= s->last_picture.data   [0] + mb_x*16 + mb_y*16*s->linesize;
+                uint8_t *mb_ptr     = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;
+                uint8_t *last_mb_ptr= s->last_picture.data   [0] + mb_x*16 + mb_y*16*s->linesize;
     
 		is_intra_likely += s->dsp.pix_abs16x16(last_mb_ptr, mb_ptr                    , s->linesize);
                 is_intra_likely -= s->dsp.pix_abs16x16(last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize);
@@ -795,8 +795,8 @@ void ff_error_resilience(MpegEncContext *s){
     for(mb_y=0; mb_y<s->mb_height; mb_y++){
         for(mb_x=0; mb_x<s->mb_width; mb_x++){
             int dc, dcu, dcv, y, n;
-            INT16 *dc_ptr;
-            UINT8 *dest_y, *dest_cb, *dest_cr;
+            int16_t *dc_ptr;
+            uint8_t *dest_y, *dest_cb, *dest_cr;
            
             i++;
             error= s->error_status_table[i];
@@ -846,7 +846,7 @@ void ff_error_resilience(MpegEncContext *s){
     i= -1;
     for(mb_y=0; mb_y<s->mb_height; mb_y++){
         for(mb_x=0; mb_x<s->mb_width; mb_x++){
-            UINT8 *dest_y, *dest_cb, *dest_cr;
+            uint8_t *dest_y, *dest_cb, *dest_cr;
            
             i++;
             error= s->error_status_table[i];

libavcodec/fft-test.c

@@ -105,11 +105,11 @@ float frandom(void)
     return (float)((random() & 0xffff) - 32768) / 32768.0;
 }
 
-INT64 gettime(void)
+int64_t gettime(void)
 {
     struct timeval tv;
     gettimeofday(&tv,NULL);
-    return (INT64)tv.tv_sec * 1000000 + tv.tv_usec;
+    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
 }
 
 void check_diff(float *tab1, float *tab2, int n)
@@ -233,7 +233,7 @@ int main(int argc, char **argv)
     /* do a speed test */
 
     if (do_speed) {
-        INT64 time_start, duration;
+        int64_t time_start, duration;
         int nb_its;
 
         printf("Speed test...\n");

libavcodec/h263.c

@@ -61,7 +61,7 @@ static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
 static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
 static void h263p_encode_umotion(MpegEncContext * s, int val);
 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
-			       int n, int dc, UINT8 *scan_table, 
+			       int n, int dc, uint8_t *scan_table, 
                                PutBitContext *dc_pb, PutBitContext *ac_pb);
 #endif
 
@@ -72,23 +72,23 @@ static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
                               int n, int coded, int intra);
-static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
+static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
                               int dir);
 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
-static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
+static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
 
-extern UINT32 inverse[256];
+extern uint32_t inverse[256];
 
-static UINT8 uni_DCtab_lum_len[512];
-static UINT8 uni_DCtab_chrom_len[512];
-static UINT16 uni_DCtab_lum_bits[512];
-static UINT16 uni_DCtab_chrom_bits[512];
+static uint8_t uni_DCtab_lum_len[512];
+static uint8_t uni_DCtab_chrom_len[512];
+static uint16_t uni_DCtab_lum_bits[512];
+static uint16_t uni_DCtab_chrom_bits[512];
 
 #ifdef CONFIG_ENCODERS
-static UINT16 (*mv_penalty)[MAX_MV*2+1]= NULL;
-static UINT8 fcode_tab[MAX_MV*2+1];
-static UINT8 umv_fcode_tab[MAX_MV*2+1];
+static uint16_t (*mv_penalty)[MAX_MV*2+1]= NULL;
+static uint8_t fcode_tab[MAX_MV*2+1];
+static uint8_t umv_fcode_tab[MAX_MV*2+1];
 
 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
 static uint8_t  uni_mpeg4_intra_rl_len [64*64*2*2];
@@ -161,7 +161,7 @@ void h263_encode_picture_header(MpegEncContext * s, int picture_number)
     s->gob_number = 0;
 
     put_bits(&s->pb, 22, 0x20); /* PSC */
-    put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) / 
+    put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * FRAME_RATE_BASE) / 
                          s->frame_rate) & 0xff);
 
     put_bits(&s->pb, 1, 1);	/* marker */
@@ -280,7 +280,7 @@ static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int d
     int8_t * const qscale_table= s->current_picture.qscale_table;
 
     for(n=0; n<6; n++){
-        INT16 *ac_val, *ac_val1;
+        int16_t *ac_val, *ac_val1;
 
         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
         ac_val1= ac_val;
@@ -728,12 +728,12 @@ void mpeg4_encode_mb(MpegEncContext * s,
         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_t *scan_table[6];
         int i;
 
         for(i=0; i<6; i++){
             const int level= block[i][0];
-            UINT16 *dc_ptr;
+            uint16_t *dc_ptr;
 
             dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
             if (i < 4) {
@@ -747,7 +747,7 @@ void mpeg4_encode_mb(MpegEncContext * s,
 
         if(s->ac_pred){
             for(i=0; i<6; i++){
-                UINT8 *st;
+                uint8_t *st;
                 int last_index;
 
                 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
@@ -817,7 +817,7 @@ void mpeg4_encode_mb(MpegEncContext * s,
         if(s->ac_pred){
             for(i=0; i<6; i++){
                 int j;    
-                INT16 *ac_val;
+                int16_t *ac_val;
 
                 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
 
@@ -839,9 +839,9 @@ void h263_encode_mb(MpegEncContext * s,
 		    int motion_x, int motion_y)
 {
     int cbpc, cbpy, i, cbp, pred_x, pred_y;
-    INT16 pred_dc;
-    INT16 rec_intradc[6];
-    UINT16 *dc_ptr[6];
+    int16_t pred_dc;
+    int16_t rec_intradc[6];
+    uint16_t *dc_ptr[6];
     const int dquant_code[5]= {1,0,9,2,3};
            
     //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
@@ -890,7 +890,7 @@ void h263_encode_mb(MpegEncContext * s,
         for(i=0; i<6; i++) {
             /* Predict DC */
             if (s->h263_aic && s->mb_intra) {
-                INT16 level = block[i][0];
+                int16_t level = block[i][0];
             
                 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
                 level -= pred_dc;
@@ -965,10 +965,10 @@ void h263_encode_mb(MpegEncContext * s,
 }
 #endif
 
-static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
+static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
 {
     int x, y, wrap, a, c, pred_dc, scale;
-    INT16 *dc_val, *ac_val;
+    int16_t *dc_val, *ac_val;
 
     /* find prediction */
     if (n < 4) {
@@ -1014,7 +1014,7 @@ static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
 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;
+    int16_t *dc_val, *ac_val, *ac_val1;
 
     /* find prediction */
     if (n < 4) {
@@ -1095,11 +1095,11 @@ static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
         ac_val1[8 + i] = block[s->idct_permutation[i   ]];
 }
 
-INT16 *h263_pred_motion(MpegEncContext * s, int block, 
+int16_t *h263_pred_motion(MpegEncContext * s, int block, 
                         int *px, int *py)
 {
     int xy, wrap;
-    INT16 *A, *B, *C, *mot_val;
+    int16_t *A, *B, *C, *mot_val;
     static const int off[4]= {2, 1, 1, -1};
 
     wrap = s->block_wrap[0];
@@ -1249,7 +1249,7 @@ static void init_mv_penalty_and_fcode(MpegEncContext *s)
     int mv;
     
     if(mv_penalty==NULL)
-        mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
+        mv_penalty= av_mallocz( sizeof(uint16_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
     
     for(f_code=1; f_code<=MAX_FCODE; f_code++){
         for(mv=-MAX_MV; mv<=MAX_MV; mv++){
@@ -1343,7 +1343,7 @@ static void init_uni_dc_tab(void)
 }
 
 #ifdef CONFIG_ENCODERS
-static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
+static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
     int slevel, run, last;
     
     assert(MAX_LEVEL >= 64);
@@ -1575,7 +1575,7 @@ void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
     if(s->current_picture.pts)
         s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
     else
-        s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
+        s->time= picture_number*(int64_t)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
     time_div= s->time/s->time_increment_resolution;
     time_mod= s->time%s->time_increment_resolution;
 
@@ -1821,10 +1821,10 @@ static void change_qscale(MpegEncContext * s, int dquant)
  * @param dir_ptr pointer to an integer where the prediction direction will be stored
  * @return the quantized predicted dc
  */
-static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
+static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
 {
     int a, b, c, wrap, pred, scale;
-    UINT16 *dc_val;
+    uint16_t *dc_val;
     int dummy;
 
     /* find prediction */
@@ -1887,7 +1887,7 @@ void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
                    int dir)
 {
     int i;
-    INT16 *ac_val, *ac_val1;
+    int16_t *ac_val, *ac_val1;
     int8_t * const qscale_table= s->current_picture.qscale_table;
 
     /* find prediction */
@@ -1942,7 +1942,7 @@ static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
                               int dir)
 {
     int i;
-    INT16 *ac_val;
+    int16_t *ac_val;
     int8_t * const qscale_table= s->current_picture.qscale_table;
 
     /* find prediction */
@@ -2031,15 +2031,15 @@ static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
  * @param n block index (0-3 are luma, 4-5 are chroma)
  */
 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
-                               UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
+                               uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
 {
     int i, last_non_zero;
 #if 0 //variables for the outcommented version
     int code, sign, last;
 #endif
     const RLTable *rl;
-    UINT32 *bits_tab;
-    UINT8 *len_tab;
+    uint32_t *bits_tab;
+    uint8_t *len_tab;
     const int last_index = s->block_last_index[n];
 
     if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
@@ -2147,11 +2147,11 @@ static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n
 }
 
 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
-                               UINT8 *scan_table)
+                               uint8_t *scan_table)
 {
     int i, last_non_zero;
     const RLTable *rl;
-    UINT8 *len_tab;
+    uint8_t *len_tab;
     const int last_index = s->block_last_index[n];
     int len=0;
 
@@ -2564,14 +2564,14 @@ void ff_mpeg4_clean_buffers(MpegEncContext *s)
 #endif
 
     /* clean AC */
-    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
-    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
-    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(INT16));
+    memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
+    memset(s->ac_val[1] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
+    memset(s->ac_val[2] + c_xy, 0, (c_wrap  +1)*16*sizeof(int16_t));
 
     /* clean MV */
     // we cant clear the MVs as they might be needed by a b frame
-//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
-//    memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
+//    memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
+//    memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
     s->last_mv[0][0][0]=
     s->last_mv[0][0][1]=
     s->last_mv[1][0][0]=
@@ -2671,7 +2671,7 @@ static inline int get_amv(MpegEncContext *s, int n){
  */
 static int mpeg4_decode_partition_a(MpegEncContext *s){
     int mb_num;
-    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
+    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
     
     /* decode first partition */
     mb_num=0;
@@ -2729,7 +2729,7 @@ static int mpeg4_decode_partition_a(MpegEncContext *s){
                 s->error_status_table[xy]= AC_ERROR;
             }else{ /* P/S_TYPE */
                 int mx, my, pred_x, pred_y, bits;
-                INT16 * const mot_val= s->motion_val[s->block_index[0]];
+                int16_t * const mot_val= s->motion_val[s->block_index[0]];
                 const int stride= s->block_wrap[0]*2;
 
                 bits= show_bits(&s->gb, 17);
@@ -2817,7 +2817,7 @@ static int mpeg4_decode_partition_a(MpegEncContext *s){
                         PRINT_MB_TYPE("4");
                         s->mb_type[xy]= MB_TYPE_INTER4V;
                         for(i=0;i<4;i++) {
-                            INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
+                            int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
                             mx = h263_decode_motion(s, pred_x, s->f_code);
                             if (mx >= 0xffff)
                                 return -1;
@@ -2845,7 +2845,7 @@ static int mpeg4_decode_partition_a(MpegEncContext *s){
  */
 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
     int mb_num=0;
-    static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
+    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 
     s->mb_x= s->resync_mb_x;
     s->first_slice_line=1;
@@ -3073,8 +3073,8 @@ int ff_h263_decode_mb(MpegEncContext *s,
                       DCTELEM block[6][64])
 {
     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
-    INT16 *mot_val;
-    static INT8 quant_tab[4] = { -1, -2, 1, 2 };
+    int16_t *mot_val;
+    static int8_t quant_tab[4] = { -1, -2, 1, 2 };
 
     s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
 
@@ -3216,7 +3216,6 @@ int ff_h263_decode_mb(MpegEncContext *s,
         int modb1; // first bit of modb
         int modb2; // second bit of modb
         int mb_type;
-        int xy;
 
         s->mb_intra = 0; //B-frames never contain intra blocks
         s->mcsel=0;      //     ...               true gmc blocks
@@ -3501,7 +3500,7 @@ static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
 {
     int code, level, i, j, last, run;
     RLTable *rl = &rl_inter;
-    const UINT8 *scan_table;
+    const uint8_t *scan_table;
 
     scan_table = s->intra_scantable.permutated;
     if (s->h263_aic && s->mb_intra) {
@@ -3556,7 +3555,7 @@ static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
             /* escape */
             last = get_bits1(&s->gb);
             run = get_bits(&s->gb, 6);
-            level = (INT8)get_bits(&s->gb, 8);
+            level = (int8_t)get_bits(&s->gb, 8);
             if (s->h263_rv10 && level == -128) {
                 /* XXX: should patch encoder too */
                 level = get_bits(&s->gb, 12);
@@ -3598,7 +3597,7 @@ not_coded:
 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
 {
     int level, pred, code;
-    UINT16 *dc_val;
+    uint16_t *dc_val;
 
     if (n < 4) 
         code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
@@ -3657,7 +3656,7 @@ static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
     int dc_pred_dir;
     RLTable * rl;
     RL_VLC_ELEM * rl_vlc;
-    const UINT8 * scan_table;
+    const uint8_t * scan_table;
     int qmul, qadd;
 
     if(intra) {

libavcodec/h263data.h

@@ -1,11 +1,11 @@
 
 /* intra MCBPC, mb_type = (intra), then (intraq) */
-const UINT8 intra_MCBPC_code[8] = { 1, 1, 2, 3, 1, 1, 2, 3 };
-const UINT8 intra_MCBPC_bits[8] = { 1, 3, 3, 3, 4, 6, 6, 6 };
+const uint8_t intra_MCBPC_code[8] = { 1, 1, 2, 3, 1, 1, 2, 3 };
+const uint8_t intra_MCBPC_bits[8] = { 1, 3, 3, 3, 4, 6, 6, 6 };
 
 /* inter MCBPC, mb_type = (inter), (intra), (interq), (intraq), (inter4v) */
 /* Changed the tables for interq and inter4v+q, following the standard ** Juanjo ** */
-const UINT8 inter_MCBPC_code[25] = { 
+const uint8_t inter_MCBPC_code[25] = { 
     1, 3, 2, 5, 
     3, 4, 3, 3, 
     3, 7, 6, 5,
@@ -14,7 +14,7 @@ const UINT8 inter_MCBPC_code[25] = {
     1, /* Stuffing */
     2, 12, 14, 15,
 };
-const UINT8 inter_MCBPC_bits[25] = { 
+const uint8_t inter_MCBPC_bits[25] = { 
     1, 4, 4, 6, 
     5, 8, 8, 7,
     3, 7, 7, 9,
@@ -25,14 +25,14 @@ const UINT8 inter_MCBPC_bits[25] = {
 };
 
 /* This is the old table 
-static const UINT8 inter_MCBPC_code[20] = { 
+static const uint8_t inter_MCBPC_code[20] = { 
     1, 3, 2, 5, 
     3, 4, 3, 3, 
     0, 1, 2, 3,
     4, 4, 3, 2,
     2, 5, 4, 5,
 };
-static const UINT8 inter_MCBPC_bits[20] = { 
+static const uint8_t inter_MCBPC_bits[20] = { 
     1, 4, 4, 6, 
     5, 8, 8, 7,
     12, 12, 12, 12,
@@ -40,13 +40,13 @@ static const UINT8 inter_MCBPC_bits[20] = {
     3, 7, 7, 8,
 };*/
 
-const UINT8 cbpy_tab[16][2] =
+const uint8_t cbpy_tab[16][2] =
 {
   {3,4}, {5,5}, {4,5}, {9,4}, {3,5}, {7,4}, {2,6}, {11,4},
   {2,5}, {3,6}, {5,4}, {10,4}, {4,4}, {8,4}, {6,4}, {3,2}
 };
 
-const UINT8 mvtab[33][2] =
+const uint8_t mvtab[33][2] =
 {
   {1,1}, {1,2}, {1,3}, {1,4}, {3,6}, {5,7}, {4,7}, {3,7},
   {11,9}, {10,9}, {9,9}, {17,10}, {16,10}, {15,10}, {14,10}, {13,10},
@@ -56,7 +56,7 @@ const UINT8 mvtab[33][2] =
 };
 
 /* third non intra table */
-const UINT16 inter_vlc[103][2] = {
+const uint16_t inter_vlc[103][2] = {
 { 0x2, 2 },{ 0xf, 4 },{ 0x15, 6 },{ 0x17, 7 },
 { 0x1f, 8 },{ 0x25, 9 },{ 0x24, 9 },{ 0x21, 10 },
 { 0x20, 10 },{ 0x7, 11 },{ 0x6, 11 },{ 0x20, 11 },
@@ -85,7 +85,7 @@ const UINT16 inter_vlc[103][2] = {
 { 0x5e, 12 },{ 0x5f, 12 },{ 0x3, 7 },
 };
 
-const INT8 inter_level[102] = {
+const int8_t inter_level[102] = {
   1,  2,  3,  4,  5,  6,  7,  8,
   9, 10, 11, 12,  1,  2,  3,  4,
   5,  6,  1,  2,  3,  4,  1,  2,
@@ -101,7 +101,7 @@ const INT8 inter_level[102] = {
   1,  1,  1,  1,  1,  1,
 };
 
-const INT8 inter_run[102] = {
+const int8_t inter_run[102] = {
   0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  1,  1,  1,  1,
   1,  1,  2,  2,  2,  2,  3,  3,
@@ -125,7 +125,7 @@ static RLTable rl_inter = {
     inter_level,
 };
 
-const UINT16 intra_vlc_aic[103][2] = {
+const uint16_t intra_vlc_aic[103][2] = {
 {  0x2,  2 }, {  0x6,  3 }, {  0xe,  4 }, {  0xc,  5 }, 
 {  0xd,  5 }, { 0x10,  6 }, { 0x11,  6 }, { 0x12,  6 }, 
 { 0x16,  7 }, { 0x1b,  8 }, { 0x20,  9 }, { 0x21,  9 }, 
@@ -154,7 +154,7 @@ const UINT16 intra_vlc_aic[103][2] = {
 { 0x59, 12 }, { 0x5a, 12 }, {  0x3,  7 },
 };
 
-const INT8 intra_run_aic[102] = {
+const int8_t intra_run_aic[102] = {
  0,  0,  0,  0,  0,  0,  0,  0, 
  0,  0,  0,  0,  0,  0,  0,  0, 
  0,  0,  0,  0,  0,  0,  0,  0, 
@@ -170,7 +170,7 @@ const INT8 intra_run_aic[102] = {
 18, 19, 20, 21, 22, 23, 
 };
 
-const INT8 intra_level_aic[102] = {
+const int8_t intra_level_aic[102] = {
  1,  2,  3,  4,  5,  6,  7,  8, 
  9, 10, 11, 12, 13, 14, 15, 16, 
 17, 18, 19, 20, 21, 22, 23, 24, 
@@ -194,7 +194,7 @@ static RLTable rl_intra_aic = {
     intra_level_aic,
 };
 
-static const UINT16 h263_format[8][2] = {
+static const uint16_t h263_format[8][2] = {
     { 0, 0 },
     { 128, 96 },
     { 176, 144 },
@@ -203,7 +203,7 @@ static const UINT16 h263_format[8][2] = {
     { 1408, 1152 },
 };
 
-static UINT8 h263_aic_dc_scale_table[32]={
+static uint8_t h263_aic_dc_scale_table[32]={
 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
     0, 2, 4, 6, 8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62
 };

libavcodec/h263dec.c

@@ -299,7 +299,7 @@ static int decode_slice(MpegEncContext *s){
  * finds the end of the current frame in the bitstream.
  * @return the position of the first byte of the next frame, or -1
  */
-static int mpeg4_find_frame_end(MpegEncContext *s, UINT8 *buf, int buf_size){
+static int mpeg4_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
     ParseContext *pc= &s->parse_context;
     int vop_found, i;
     uint32_t state;
@@ -403,7 +403,7 @@ static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int
 
 int ff_h263_decode_frame(AVCodecContext *avctx, 
                              void *data, int *data_size,
-                             UINT8 *buf, int buf_size)
+                             uint8_t *buf, int buf_size)
 {
     MpegEncContext *s = avctx->priv_data;
     int ret,i;
@@ -629,7 +629,7 @@ retry:
 #endif
 
     if(s->error_resilience)
-        memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_num*sizeof(UINT8));
+        memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_num*sizeof(uint8_t));
     
     /* decode each macroblock */
     s->block_wrap[0]=

libavcodec/huffyuv.c

@@ -638,7 +638,7 @@ static void decode_bgr_bitstream(HYuvContext *s, int count){
 
 static void draw_slice(HYuvContext *s, int y){
     int h, cy;
-    UINT8 *src_ptr[3];
+    uint8_t *src_ptr[3];
     
     if(s->avctx->draw_horiz_band==NULL) 
         return;

libavcodec/i386/dsputil_mmx.c

@@ -172,7 +172,7 @@ static const uint64_t ff_pw_15 __attribute__ ((aligned(8))) = 0x000F000F000F000F
 /***********************************/
 /* standard MMX */
 
-static void get_pixels_mmx(DCTELEM *block, const UINT8 *pixels, int line_size)
+static void get_pixels_mmx(DCTELEM *block, const uint8_t *pixels, int line_size)
 {
     asm volatile(
         "movl $-128, %%eax	\n\t"
@@ -200,7 +200,7 @@ static void get_pixels_mmx(DCTELEM *block, const UINT8 *pixels, int line_size)
     );
 }
 
-static inline void diff_pixels_mmx(DCTELEM *block, const UINT8 *s1, const UINT8 *s2, int stride)
+static inline void diff_pixels_mmx(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, int stride)
 {
     asm volatile(
         "pxor %%mm7, %%mm7	\n\t"
@@ -229,10 +229,10 @@ static inline void diff_pixels_mmx(DCTELEM *block, const UINT8 *s1, const UINT8
     );
 }
 
-void put_pixels_clamped_mmx(const DCTELEM *block, UINT8 *pixels, int line_size)
+void put_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size)
 {
     const DCTELEM *p;
-    UINT8 *pix;
+    uint8_t *pix;
 
     /* read the pixels */
     p = block;
@@ -284,10 +284,10 @@ void put_pixels_clamped_mmx(const DCTELEM *block, UINT8 *pixels, int line_size)
 	    :"memory");
 }
 
-void add_pixels_clamped_mmx(const DCTELEM *block, UINT8 *pixels, int line_size)
+void add_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size)
 {
     const DCTELEM *p;
-    UINT8 *pix;
+    uint8_t *pix;
     int i;
 
     /* read the pixels */
@@ -325,7 +325,7 @@ void add_pixels_clamped_mmx(const DCTELEM *block, UINT8 *pixels, int line_size)
     } while (--i);
 }
 
-static void put_pixels8_mmx(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void put_pixels8_mmx(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
 	 "lea (%3, %3), %%eax		\n\t"
@@ -351,7 +351,7 @@ static void put_pixels8_mmx(UINT8 *block, const UINT8 *pixels, int line_size, in
 	);
 }
 
-static void put_pixels16_mmx(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void put_pixels16_mmx(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
 	 "lea (%3, %3), %%eax		\n\t"
@@ -402,7 +402,7 @@ static void clear_blocks_mmx(DCTELEM *blocks)
         );
 }
 
-static int pix_sum16_mmx(UINT8 * pix, int line_size){
+static int pix_sum16_mmx(uint8_t * pix, int line_size){
     const int h=16;
     int sum;
     int index= -line_size*h;
@@ -505,7 +505,7 @@ static int pix_norm1_mmx(uint8_t *pix, int line_size) {
     return tmp;
 }
 
-static int sse16_mmx(void *v, UINT8 * pix1, UINT8 * pix2, int line_size) {
+static int sse16_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size) {
     int tmp;
   asm volatile (
       "movl $16,%%ecx\n"
@@ -1158,46 +1158,46 @@ static void OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src,
    );\
 }\
 \
-static void OPNAME ## qpel8_mc00_ ## MMX (UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## pixels8_mmx(dst, src, stride, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc10_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[8];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
     OPNAME ## pixels8_l2_mmx(dst, src, half, stride, stride, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc20_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## mpeg4_qpel8_h_lowpass_ ## MMX(dst, src, stride, stride, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc30_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[8];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
     OPNAME ## pixels8_l2_mmx(dst, src+1, half, stride, stride, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc01_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[8];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
     OPNAME ## pixels8_l2_mmx(dst, src, half, stride, stride, 8);\
 }\
 \
-static void OPNAME ## qpel8_mc02_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, src, stride, stride);\
 }\
 \
-static void OPNAME ## qpel8_mc03_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[8];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
     OPNAME ## pixels8_l2_mmx(dst, src+stride, half, stride, stride, 8);\
 }\
-static void OPNAME ## qpel8_mc11_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1206,7 +1206,7 @@ static void OPNAME ## qpel8_mc11_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2_mmx(dst, halfH, halfHV, stride, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc31_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1215,7 +1215,7 @@ static void OPNAME ## qpel8_mc31_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2_mmx(dst, halfH, halfHV, stride, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc13_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1224,7 +1224,7 @@ static void OPNAME ## qpel8_mc13_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2_mmx(dst, halfH+8, halfHV, stride, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc33_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1233,7 +1233,7 @@ static void OPNAME ## qpel8_mc33_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2_mmx(dst, halfH+8, halfHV, stride, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc21_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1241,7 +1241,7 @@ static void OPNAME ## qpel8_mc21_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2_mmx(dst, halfH, halfHV, stride, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc23_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1249,66 +1249,66 @@ static void OPNAME ## qpel8_mc23_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
     OPNAME ## pixels8_l2_mmx(dst, halfH+8, halfHV, stride, 8, 8);\
 }\
-static void OPNAME ## qpel8_mc12_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
     put ## RND ## pixels8_l2_mmx(halfH, src, halfH, 8, stride, 9);\
     OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
 }\
-static void OPNAME ## qpel8_mc32_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
     put ## RND ## pixels8_l2_mmx(halfH, src+1, halfH, 8, stride, 9);\
     OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
 }\
-static void OPNAME ## qpel8_mc22_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel8_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[9];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
     OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
 }\
-static void OPNAME ## qpel16_mc00_ ## MMX (UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## pixels16_mmx(dst, src, stride, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc10_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[32];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
     OPNAME ## pixels16_l2_mmx(dst, src, half, stride, stride, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc20_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## mpeg4_qpel16_h_lowpass_ ## MMX(dst, src, stride, stride, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc30_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[32];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
     OPNAME ## pixels16_l2_mmx(dst, src+1, half, stride, stride, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc01_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[32];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
     OPNAME ## pixels16_l2_mmx(dst, src, half, stride, stride, 16);\
 }\
 \
-static void OPNAME ## qpel16_mc02_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, src, stride, stride);\
 }\
 \
-static void OPNAME ## qpel16_mc03_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[32];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
     OPNAME ## pixels16_l2_mmx(dst, src+stride, half, stride, stride, 16);\
 }\
-static void OPNAME ## qpel16_mc11_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1317,7 +1317,7 @@ static void OPNAME ## qpel16_mc11_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2_mmx(dst, halfH, halfHV, stride, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc31_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1326,7 +1326,7 @@ static void OPNAME ## qpel16_mc31_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2_mmx(dst, halfH, halfHV, stride, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc13_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1335,7 +1335,7 @@ static void OPNAME ## qpel16_mc13_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2_mmx(dst, halfH+16, halfHV, stride, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc33_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1344,7 +1344,7 @@ static void OPNAME ## qpel16_mc33_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2_mmx(dst, halfH+16, halfHV, stride, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc21_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1352,7 +1352,7 @@ static void OPNAME ## qpel16_mc21_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2_mmx(dst, halfH, halfHV, stride, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc23_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
@@ -1360,21 +1360,21 @@ static void OPNAME ## qpel16_mc23_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
     OPNAME ## pixels16_l2_mmx(dst, halfH+16, halfHV, stride, 16, 16);\
 }\
-static void OPNAME ## qpel16_mc12_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[17*2];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
     put ## RND ## pixels16_l2_mmx(halfH, src, halfH, 16, stride, 17);\
     OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
 }\
-static void OPNAME ## qpel16_mc32_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[17*2];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
     put ## RND ## pixels16_l2_mmx(halfH, src+1, halfH, 16, stride, 17);\
     OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
 }\
-static void OPNAME ## qpel16_mc22_ ## MMX(UINT8 *dst, UINT8 *src, int stride){\
+static void OPNAME ## qpel16_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[17*2];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\

libavcodec/i386/dsputil_mmx_avg.h

@@ -25,7 +25,7 @@
 /* XXX: we use explicit registers to avoid a gcc 2.95.2 register asm
    clobber bug - now it will work with 2.95.2 and also with -fPIC
  */
-static void DEF(put_pixels8_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(put_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
 	"lea (%3, %3), %%eax		\n\t"
@@ -85,7 +85,7 @@ static void DEF(put_pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int
 	:"memory");
 }
 
-static void DEF(put_pixels16_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(put_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
 	"lea (%3, %3), %%eax		\n\t"
@@ -154,7 +154,7 @@ static void DEF(put_pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int
 }
  
 /* GL: this function does incorrect rounding if overflow */
-static void DEF(put_no_rnd_pixels8_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(put_no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BONE(mm6);
     __asm __volatile(
@@ -191,7 +191,7 @@ static void DEF(put_no_rnd_pixels8_x2)(UINT8 *block, const UINT8 *pixels, int li
 	:"%eax", "memory");
 }
 
-static void DEF(put_pixels8_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(put_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
 	"lea (%3, %3), %%eax		\n\t"
@@ -222,7 +222,7 @@ static void DEF(put_pixels8_y2)(UINT8 *block, const UINT8 *pixels, int line_size
 }
 
 /* GL: this function does incorrect rounding if overflow */
-static void DEF(put_no_rnd_pixels8_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(put_no_rnd_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BONE(mm6);
     __asm __volatile(
@@ -255,7 +255,7 @@ static void DEF(put_no_rnd_pixels8_y2)(UINT8 *block, const UINT8 *pixels, int li
 	:"%eax", "memory");
 }
 
-static void DEF(avg_pixels8)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg_pixels8)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
 	"lea (%3, %3), %%eax		\n\t"
@@ -283,7 +283,7 @@ static void DEF(avg_pixels8)(UINT8 *block, const UINT8 *pixels, int line_size, i
 	:"%eax", "memory");
 }
 
-static void DEF(avg_pixels8_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
 	"lea (%3, %3), %%eax		\n\t"
@@ -315,7 +315,7 @@ static void DEF(avg_pixels8_x2)(UINT8 *block, const UINT8 *pixels, int line_size
 	:"%eax", "memory");
 }
 
-static void DEF(avg_pixels8_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
 	"lea (%3, %3), %%eax		\n\t"
@@ -354,7 +354,7 @@ static void DEF(avg_pixels8_y2)(UINT8 *block, const UINT8 *pixels, int line_size
 }
 
 // Note this is not correctly rounded, but this function is only used for b frames so it doesnt matter 
-static void DEF(avg_pixels8_xy2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BONE(mm6);
     __asm __volatile(
@@ -396,31 +396,31 @@ static void DEF(avg_pixels8_xy2)(UINT8 *block, const UINT8 *pixels, int line_siz
 }
 
 //FIXME the following could be optimized too ...
-static void DEF(put_no_rnd_pixels16_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(put_no_rnd_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(put_no_rnd_pixels8_x2)(block  , pixels  , line_size, h);
     DEF(put_no_rnd_pixels8_x2)(block+8, pixels+8, line_size, h);
 }
-static void DEF(put_pixels16_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(put_pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(put_pixels8_y2)(block  , pixels  , line_size, h);
     DEF(put_pixels8_y2)(block+8, pixels+8, line_size, h);
 }
-static void DEF(put_no_rnd_pixels16_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(put_no_rnd_pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(put_no_rnd_pixels8_y2)(block  , pixels  , line_size, h);
     DEF(put_no_rnd_pixels8_y2)(block+8, pixels+8, line_size, h);
 }
-static void DEF(avg_pixels16)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(avg_pixels16)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(avg_pixels8)(block  , pixels  , line_size, h);
     DEF(avg_pixels8)(block+8, pixels+8, line_size, h);
 }
-static void DEF(avg_pixels16_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(avg_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(avg_pixels8_x2)(block  , pixels  , line_size, h);
     DEF(avg_pixels8_x2)(block+8, pixels+8, line_size, h);
 }
-static void DEF(avg_pixels16_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(avg_pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(avg_pixels8_y2)(block  , pixels  , line_size, h);
     DEF(avg_pixels8_y2)(block+8, pixels+8, line_size, h);
 }
-static void DEF(avg_pixels16_xy2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(avg_pixels16_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(avg_pixels8_xy2)(block  , pixels  , line_size, h);
     DEF(avg_pixels8_xy2)(block+8, pixels+8, line_size, h);
 }

libavcodec/i386/dsputil_mmx_rnd.h

@@ -22,7 +22,7 @@
  */
 
 // put_pixels
-static void DEF(put, pixels8_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(put, pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BFE(mm6);
     __asm __volatile(
@@ -104,7 +104,7 @@ static void DEF(put, pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int
 	:"memory");
 }
 
-static void DEF(put, pixels16_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(put, pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BFE(mm6);
     __asm __volatile(
@@ -199,7 +199,7 @@ static void DEF(put, pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, in
 	:"memory"); 
 }
 
-static void DEF(put, pixels8_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(put, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BFE(mm6);
     __asm __volatile(
@@ -228,7 +228,7 @@ static void DEF(put, pixels8_y2)(UINT8 *block, const UINT8 *pixels, int line_siz
 	:"eax", "memory");
 }
 
-static void DEF(put, pixels8_xy2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(put, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_ZERO(mm7);
     SET_RND(mm6); // =2 for rnd  and  =1 for no_rnd version
@@ -296,7 +296,7 @@ static void DEF(put, pixels8_xy2)(UINT8 *block, const UINT8 *pixels, int line_si
 
 // avg_pixels
 // in case more speed is needed - unroling would certainly help
-static void DEF(avg, pixels8)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg, pixels8)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BFE(mm6);
     JUMPALIGN();
@@ -315,7 +315,7 @@ static void DEF(avg, pixels8)(UINT8 *block, const UINT8 *pixels, int line_size,
     while (--h);
 }
 
-static void DEF(avg, pixels16)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg, pixels16)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BFE(mm6);
     JUMPALIGN();
@@ -338,7 +338,7 @@ static void DEF(avg, pixels16)(UINT8 *block, const UINT8 *pixels, int line_size,
     while (--h);
 }
 
-static void DEF(avg, pixels8_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg, pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BFE(mm6);
     JUMPALIGN();
@@ -379,7 +379,7 @@ static void DEF(avg, pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int
     } while (--h);
 }
 
-static void DEF(avg, pixels16_x2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg, pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BFE(mm6);
     JUMPALIGN();
@@ -432,7 +432,7 @@ static void DEF(avg, pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, in
     } while (--h);
 }
 
-static void DEF(avg, pixels8_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_BFE(mm6);
     __asm __volatile(
@@ -472,7 +472,7 @@ static void DEF(avg, pixels8_y2)(UINT8 *block, const UINT8 *pixels, int line_siz
 }
 
 // this routine is 'slightly' suboptimal but mostly unused
-static void DEF(avg, pixels8_xy2)(UINT8 *block, const UINT8 *pixels, int line_size, int h)
+static void DEF(avg, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     MOVQ_ZERO(mm7);
     SET_RND(mm6); // =2 for rnd  and  =1 for no_rnd version
@@ -547,22 +547,22 @@ static void DEF(avg, pixels8_xy2)(UINT8 *block, const UINT8 *pixels, int line_si
 }
 
 //FIXME optimize
-static void DEF(put, pixels16_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(put, pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(put, pixels8_y2)(block  , pixels  , line_size, h);
     DEF(put, pixels8_y2)(block+8, pixels+8, line_size, h);
 }
 
-static void DEF(put, pixels16_xy2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(put, pixels16_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(put, pixels8_xy2)(block  , pixels  , line_size, h);
     DEF(put, pixels8_xy2)(block+8, pixels+8, line_size, h);
 }
 
-static void DEF(avg, pixels16_y2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(avg, pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(avg, pixels8_y2)(block  , pixels  , line_size, h);
     DEF(avg, pixels8_y2)(block+8, pixels+8, line_size, h);
 }
 
-static void DEF(avg, pixels16_xy2)(UINT8 *block, const UINT8 *pixels, int line_size, int h){
+static void DEF(avg, pixels16_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
     DEF(avg, pixels8_xy2)(block  , pixels  , line_size, h);
     DEF(avg, pixels8_xy2)(block+8, pixels+8, line_size, h);
 }

libavcodec/i386/motion_est_mmx.c

@@ -23,7 +23,7 @@
 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]={
+static const __attribute__ ((aligned(8))) uint64_t round_tab[3]={
 0x0000000000000000,
 0x0001000100010001,
 0x0002000200020002,
@@ -31,7 +31,7 @@ static const __attribute__ ((aligned(8))) UINT64 round_tab[3]={
 
 static __attribute__ ((aligned(8))) uint64_t bone= 0x0101010101010101LL;
 
-static inline void sad8_mmx(UINT8 *blk1, UINT8 *blk2, int stride, int h)
+static inline void sad8_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 {
     int len= -(stride<<h);
     asm volatile(
@@ -67,7 +67,7 @@ static inline void sad8_mmx(UINT8 *blk1, UINT8 *blk2, int stride, int h)
     );
 }
 
-static inline void sad8_mmx2(UINT8 *blk1, UINT8 *blk2, int stride, int h)
+static inline void sad8_mmx2(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 {
     int len= -(stride<<h);
     asm volatile(
@@ -89,7 +89,7 @@ static inline void sad8_mmx2(UINT8 *blk1, UINT8 *blk2, int stride, int h)
     );
 }
 
-static inline void sad8_2_mmx2(UINT8 *blk1a, UINT8 *blk1b, UINT8 *blk2, int stride, int h)
+static inline void sad8_2_mmx2(uint8_t *blk1a, uint8_t *blk1b, uint8_t *blk2, int stride, int h)
 {
     int len= -(stride<<h);
     asm volatile(
@@ -115,7 +115,7 @@ static inline void sad8_2_mmx2(UINT8 *blk1a, UINT8 *blk1b, UINT8 *blk2, int stri
     );
 }
 
-static inline void sad8_4_mmx2(UINT8 *blk1, UINT8 *blk2, int stride, int h)
+static inline void sad8_4_mmx2(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 { //FIXME reuse src
     int len= -(stride<<h);
     asm volatile(
@@ -152,7 +152,7 @@ static inline void sad8_4_mmx2(UINT8 *blk1, UINT8 *blk2, int stride, int h)
     );
 }
 
-static inline void sad8_2_mmx(UINT8 *blk1a, UINT8 *blk1b, UINT8 *blk2, int stride, int h)
+static inline void sad8_2_mmx(uint8_t *blk1a, uint8_t *blk1b, uint8_t *blk2, int stride, int h)
 {
     int len= -(stride<<h);
     asm volatile(
@@ -190,7 +190,7 @@ static inline void sad8_2_mmx(UINT8 *blk1a, UINT8 *blk1b, UINT8 *blk2, int strid
     );
 }
 
-static inline void sad8_4_mmx(UINT8 *blk1, UINT8 *blk2, int stride, int h)
+static inline void sad8_4_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 {
     int len= -(stride<<h);
     asm volatile(
@@ -268,7 +268,7 @@ static inline int sum_mmx2(void)
 
 
 #define PIX_SAD(suf)\
-static int pix_abs8x8_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs8x8_ ## suf(uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t":);\
@@ -277,7 +277,7 @@ static int pix_abs8x8_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
 \
     return sum_ ## suf();\
 }\
-static int sad8x8_ ## suf(void *s, UINT8 *blk2, UINT8 *blk1, int stride)\
+static int sad8x8_ ## suf(void *s, uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t":);\
@@ -287,7 +287,7 @@ static int sad8x8_ ## suf(void *s, UINT8 *blk2, UINT8 *blk1, int stride)\
     return sum_ ## suf();\
 }\
 \
-static int pix_abs8x8_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs8x8_x2_ ## suf(uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t"\
@@ -300,7 +300,7 @@ static int pix_abs8x8_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
     return sum_ ## suf();\
 }\
 \
-static int pix_abs8x8_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs8x8_y2_ ## suf(uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t"\
@@ -313,7 +313,7 @@ static int pix_abs8x8_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
     return sum_ ## suf();\
 }\
 \
-static int pix_abs8x8_xy2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs8x8_xy2_ ## suf(uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t"\
@@ -326,7 +326,7 @@ static int pix_abs8x8_xy2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
     return sum_ ## suf();\
 }\
 \
-static int pix_abs16x16_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs16x16_ ## suf(uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t":);\
@@ -336,7 +336,7 @@ static int pix_abs16x16_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
 \
     return sum_ ## suf();\
 }\
-static int sad16x16_ ## suf(void *s, UINT8 *blk2, UINT8 *blk1, int stride)\
+static int sad16x16_ ## suf(void *s, uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t":);\
@@ -346,7 +346,7 @@ static int sad16x16_ ## suf(void *s, UINT8 *blk2, UINT8 *blk1, int stride)\
 \
     return sum_ ## suf();\
 }\
-static int pix_abs16x16_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs16x16_x2_ ## suf(uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t"\
@@ -359,7 +359,7 @@ static int pix_abs16x16_x2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
 \
     return sum_ ## suf();\
 }\
-static int pix_abs16x16_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs16x16_y2_ ## suf(uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t"\
@@ -372,7 +372,7 @@ static int pix_abs16x16_y2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
 \
     return sum_ ## suf();\
 }\
-static int pix_abs16x16_xy2_ ## suf(UINT8 *blk2, UINT8 *blk1, int stride)\
+static int pix_abs16x16_xy2_ ## suf(uint8_t *blk2, uint8_t *blk1, int stride)\
 {\
     asm volatile("pxor %%mm7, %%mm7		\n\t"\
                  "pxor %%mm6, %%mm6		\n\t"\

libavcodec/i386/mpegvideo_mmx.c

@@ -25,9 +25,9 @@
 #include "../avcodec.h"
 #include "../simple_idct.h"
 
-extern UINT8 zigzag_direct_noperm[64];
-extern UINT16 inv_zigzag_direct16[64];
-extern UINT32 inverse[256];
+extern uint8_t zigzag_direct_noperm[64];
+extern uint16_t inv_zigzag_direct16[64];
+extern uint32_t inverse[256];
 
 static const unsigned long long int mm_wabs __attribute__ ((aligned(8))) = 0xffffffffffffffffULL;
 static const unsigned long long int mm_wone __attribute__ ((aligned(8))) = 0x0001000100010001ULL;
@@ -144,7 +144,7 @@ static void dct_unquantize_mpeg1_mmx(MpegEncContext *s,
                                      DCTELEM *block, int n, int qscale)
 {
     int nCoeffs;
-    const UINT16 *quant_matrix;
+    const uint16_t *quant_matrix;
 
     assert(s->block_last_index[n]>=0);
 
@@ -272,7 +272,7 @@ static void dct_unquantize_mpeg2_mmx(MpegEncContext *s,
                                      DCTELEM *block, int n, int qscale)
 {
     int nCoeffs;
-    const UINT16 *quant_matrix;
+    const uint16_t *quant_matrix;
     
     assert(s->block_last_index[n]>=0);
 
@@ -404,9 +404,9 @@ asm volatile(
 
 /* draw the edges of width 'w' of an image of size width, height 
    this mmx version can only handle w==8 || w==16 */
-static void draw_edges_mmx(UINT8 *buf, int wrap, int width, int height, int w)
+static void draw_edges_mmx(uint8_t *buf, int wrap, int width, int height, int w)
 {
-    UINT8 *ptr, *last_line;
+    uint8_t *ptr, *last_line;
     int i;
 
     last_line = buf + (height - 1) * wrap;
@@ -505,22 +505,22 @@ void ff_mmxext_idct(DCTELEM *block);
 
 /* XXX: those functions should be suppressed ASAP when all IDCTs are
    converted */
-static void ff_libmpeg2mmx_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
+static void ff_libmpeg2mmx_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
 {
     ff_mmx_idct (block);
     put_pixels_clamped_mmx(block, dest, line_size);
 }
-static void ff_libmpeg2mmx_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
+static void ff_libmpeg2mmx_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
 {
     ff_mmx_idct (block);
     add_pixels_clamped_mmx(block, dest, line_size);
 }
-static void ff_libmpeg2mmx2_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
+static void ff_libmpeg2mmx2_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
 {
     ff_mmxext_idct (block);
     put_pixels_clamped_mmx(block, dest, line_size);
 }
-static void ff_libmpeg2mmx2_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
+static void ff_libmpeg2mmx2_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
 {
     ff_mmxext_idct (block);
     add_pixels_clamped_mmx(block, dest, line_size);

libavcodec/i386/mpegvideo_mmx_template.c

@@ -37,8 +37,8 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
                             int qscale, int *overflow)
 {
     int level=0, last_non_zero_p1, q; //=0 is cuz gcc says uninitalized ...
-    const UINT16 *qmat, *bias;
-    static __align8 INT16 temp_block[64];
+    const uint16_t *qmat, *bias;
+    static __align8 int16_t temp_block[64];
 
     //s->fdct (block);
     ff_fdct_mmx (block); //cant be anything else ...

libavcodec/i386/simple_idct_mmx.c

@@ -1298,12 +1298,12 @@ void ff_simple_idct_mmx(int16_t *block)
 
 //FIXME merge add/put into the idct
 
-void ff_simple_idct_put_mmx(UINT8 *dest, int line_size, DCTELEM *block)
+void ff_simple_idct_put_mmx(uint8_t *dest, int line_size, DCTELEM *block)
 {
     idct(block);
     put_pixels_clamped_mmx(block, dest, line_size);
 }
-void ff_simple_idct_add_mmx(UINT8 *dest, int line_size, DCTELEM *block)
+void ff_simple_idct_add_mmx(uint8_t *dest, int line_size, DCTELEM *block)
 {
     idct(block);
     add_pixels_clamped_mmx(block, dest, line_size);

libavcodec/imgconvert.c

@@ -29,14 +29,14 @@
 
 typedef struct PixFmtInfo {
     const char *name;
-    UINT8 nb_components;     /* number of components in AVPicture array  */
-    UINT8 is_yuv : 1;    /* true if YUV instead of RGB color space */
-    UINT8 is_packed : 1; /* true if multiple components in same word */
-    UINT8 is_paletted : 1; /* true if paletted */
-    UINT8 is_alpha : 1;    /* true if alpha can be specified */
-    UINT8 is_gray : 1;     /* true if gray or monochrome format */
-    UINT8 x_chroma_shift; /* X chroma subsampling factor is 2 ^ shift */
-    UINT8 y_chroma_shift; /* Y chroma subsampling factor is 2 ^ shift */
+    uint8_t nb_components;     /* number of components in AVPicture array  */
+    uint8_t is_yuv : 1;    /* true if YUV instead of RGB color space */
+    uint8_t is_packed : 1; /* true if multiple components in same word */
+    uint8_t is_paletted : 1; /* true if paletted */
+    uint8_t is_alpha : 1;    /* true if alpha can be specified */
+    uint8_t is_gray : 1;     /* true if gray or monochrome format */
+    uint8_t x_chroma_shift; /* X chroma subsampling factor is 2 ^ shift */
+    uint8_t y_chroma_shift; /* Y chroma subsampling factor is 2 ^ shift */
 } PixFmtInfo;
 
 /* this table gives more information about formats */
@@ -136,7 +136,7 @@ const char *avcodec_get_pix_fmt_name(int pix_fmt)
 }
 
 /* Picture field are filled with 'ptr' addresses. Also return size */
-int avpicture_fill(AVPicture *picture, UINT8 *ptr,
+int avpicture_fill(AVPicture *picture, uint8_t *ptr,
                    int pix_fmt, int width, int height)
 {
     int size, w2, h2, size2;
@@ -223,9 +223,9 @@ int avpicture_get_size(int pix_fmt, int width, int height)
 static void yuv422_to_yuv420p(AVPicture *dst, AVPicture *src,
                               int width, int height)
 {
-    UINT8 *lum, *cb, *cr;
+    uint8_t *lum, *cb, *cr;
     int x, y;
-    const UINT8 *p;
+    const uint8_t *p;
  
     lum = dst->data[0];
     cb = dst->data[1];
@@ -258,12 +258,12 @@ static void yuv422_to_yuv420p(AVPicture *dst, AVPicture *src,
 
 /* XXX: use generic filter ? */
 /* 1x2 -> 1x1 */
-static void shrink2(UINT8 *dst, int dst_wrap, 
-                    UINT8 *src, int src_wrap,
+static void shrink2(uint8_t *dst, int dst_wrap, 
+                    uint8_t *src, int src_wrap,
                     int width, int height)
 {
     int w;
-    UINT8 *s1, *s2, *d;
+    uint8_t *s1, *s2, *d;
 
     for(;height > 0; height--) {
         s1 = src;
@@ -290,12 +290,12 @@ static void shrink2(UINT8 *dst, int dst_wrap,
 }
 
 /* 2x2 -> 1x1 */
-static void shrink22(UINT8 *dst, int dst_wrap, 
-                     UINT8 *src, int src_wrap,
+static void shrink22(uint8_t *dst, int dst_wrap, 
+                     uint8_t *src, int src_wrap,
                      int width, int height)
 {
     int w;
-    UINT8 *s1, *s2, *d;
+    uint8_t *s1, *s2, *d;
 
     for(;height > 0; height--) {
         s1 = src;
@@ -322,12 +322,12 @@ static void shrink22(UINT8 *dst, int dst_wrap,
 }
 
 /* 1x1 -> 2x2 */
-static void grow22(UINT8 *dst, int dst_wrap,
-                     UINT8 *src, int src_wrap,
+static void grow22(uint8_t *dst, int dst_wrap,
+                     uint8_t *src, int src_wrap,
                      int width, int height)
 {
     int w;
-    UINT8 *s1, *d;
+    uint8_t *s1, *d;
 
     for(;height > 0; height--) {
         s1 = src;
@@ -350,12 +350,12 @@ static void grow22(UINT8 *dst, int dst_wrap,
 }
 
 /* 1x2 -> 2x1 */
-static void conv411(UINT8 *dst, int dst_wrap, 
-                    UINT8 *src, int src_wrap,
+static void conv411(uint8_t *dst, int dst_wrap, 
+                    uint8_t *src, int src_wrap,
                     int width, int height)
 {
     int w, c;
-    UINT8 *s1, *s2, *d;
+    uint8_t *s1, *s2, *d;
 
     for(;height > 0; height--) {
         s1 = src;
@@ -374,8 +374,8 @@ static void conv411(UINT8 *dst, int dst_wrap,
     }
 }
 
-static void img_copy(UINT8 *dst, int dst_wrap, 
-                     UINT8 *src, int src_wrap,
+static void img_copy(uint8_t *dst, int dst_wrap, 
+                     uint8_t *src, int src_wrap,
                      int width, int height)
 {
     for(;height > 0; height--) {
@@ -407,9 +407,9 @@ static void img_copy(UINT8 *dst, int dst_wrap,
 static void yuv420p_to_ ## rgb_name (AVPicture *dst, AVPicture *src,    \
                                      int width, int height)             \
 {                                                                       \
-    UINT8 *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr, *d, *d1, *d2;             \
+    uint8_t *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr, *d, *d1, *d2;             \
     int w, y, cb, cr, r_add, g_add, b_add, width2;                      \
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;                                 \
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;                                 \
     unsigned int r, g, b;                                               \
                                                                         \
     d = dst->data[0];                                                   \
@@ -521,9 +521,9 @@ static void yuv420p_to_ ## rgb_name (AVPicture *dst, AVPicture *src,    \
 static void yuv422p_to_ ## rgb_name (AVPicture *dst, AVPicture *src,    \
                                     int width, int height)              \
 {                                                                       \
-    UINT8 *y1_ptr, *cb_ptr, *cr_ptr, *d, *d1;                           \
+    uint8_t *y1_ptr, *cb_ptr, *cr_ptr, *d, *d1;                           \
     int w, y, cb, cr, r_add, g_add, b_add, width2;                      \
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;                                 \
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;                                 \
     unsigned int r, g, b;                                               \
                                                                         \
     d = dst->data[0];                                                   \
@@ -582,8 +582,8 @@ static void rgb_name ## _to_yuv420p(AVPicture *dst, AVPicture *src,     \
 {                                                                       \
     int wrap, wrap3, x, y;                                              \
     int r, g, b, r1, g1, b1;                                            \
-    UINT8 *lum, *cb, *cr;                                               \
-    const UINT8 *p;                                                     \
+    uint8_t *lum, *cb, *cr;                                               \
+    const uint8_t *p;                                                     \
                                                                         \
     lum = dst->data[0];                                                 \
     cb = dst->data[1];                                                  \
@@ -739,7 +739,7 @@ static inline unsigned int bitcopy_n(unsigned int a, int n)
 
 #define RGB_IN(r, g, b, s)\
 {\
-    unsigned int v = ((const UINT16 *)(s))[0];\
+    unsigned int v = ((const uint16_t *)(s))[0];\
     r = bitcopy_n(v >> (10 - 3), 3);\
     g = bitcopy_n(v >> (5 - 3), 3);\
     b = bitcopy_n(v << 3, 3);\
@@ -747,7 +747,7 @@ static inline unsigned int bitcopy_n(unsigned int a, int n)
 
 #define RGB_OUT(d, r, g, b)\
 {\
-    ((UINT16 *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3) | 0x8000;\
+    ((uint16_t *)(d))[0] = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3) | 0x8000;\
 }
 
 #define BPP 2
@@ -762,7 +762,7 @@ RGB_FUNCTIONS(rgb555)
 
 #define RGB_IN(r, g, b, s)\
 {\
-    unsigned int v = ((const UINT16 *)(s))[0];\
+    unsigned int v = ((const uint16_t *)(s))[0];\
     r = bitcopy_n(v >> (11 - 3), 3);\
     g = bitcopy_n(v >> (5 - 2), 2);\
     b = bitcopy_n(v << 3, 3);\
@@ -770,7 +770,7 @@ RGB_FUNCTIONS(rgb555)
 
 #define RGB_OUT(d, r, g, b)\
 {\
-    ((UINT16 *)(d))[0] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);\
+    ((uint16_t *)(d))[0] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);\
 }
 
 #define BPP 2
@@ -833,7 +833,7 @@ RGB_FUNCTIONS(rgb24)
 
 #define RGB_IN(r, g, b, s)\
 {\
-    unsigned int v = ((const UINT32 *)(s))[0];\
+    unsigned int v = ((const uint32_t *)(s))[0];\
     r = (v >> 16) & 0xff;\
     g = (v >> 8) & 0xff;\
     b = v & 0xff;\
@@ -841,7 +841,7 @@ RGB_FUNCTIONS(rgb24)
 
 #define RGB_OUT(d, r, g, b)\
 {\
-    ((UINT32 *)(d))[0] = (0xff << 24) | (r << 16) | (g << 8) | b;\
+    ((uint32_t *)(d))[0] = (0xff << 24) | (r << 16) | (g << 8) | b;\
 }
 
 #define BPP 4
@@ -971,8 +971,8 @@ static void gray_to_mono(AVPicture *dst, AVPicture *src,
                          int width, int height, int xor_mask)
 {
     int n;
-    const UINT8 *s;
-    UINT8 *d;
+    const uint8_t *s;
+    uint8_t *d;
     int j, b, v, n1, src_wrap, dst_wrap, y;
 
     s = src->data[0];
@@ -1025,7 +1025,7 @@ static void gray_to_monoblack(AVPicture *dst, AVPicture *src,
 }
 
 /* this is maybe slow, but allows for extensions */
-static inline unsigned char gif_clut_index(UINT8 r, UINT8 g, UINT8 b)
+static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
 {
     return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));
 }
@@ -1330,8 +1330,8 @@ int img_convert(AVPicture *dst, int dst_pix_fmt,
     /* YUV to YUV */
     if (dst_pix->is_yuv && src_pix->is_yuv) {
         int x_shift, y_shift, w, h;
-        void (*resize_func)(UINT8 *dst, int dst_wrap, 
-                            UINT8 *src, int src_wrap,
+        void (*resize_func)(uint8_t *dst, int dst_wrap, 
+                            uint8_t *src, int src_wrap,
                             int width, int height);
 
         /* compute chroma size of the smallest dimensions */
@@ -1447,11 +1447,11 @@ int img_convert(AVPicture *dst, int dst_pix_fmt,
 #endif
 
 /* filter parameters: [-1 4 2 4 -1] // 8 */
-static void deinterlace_line(UINT8 *dst, UINT8 *lum_m4, UINT8 *lum_m3, UINT8 *lum_m2, UINT8 *lum_m1, UINT8 *lum,
+static void deinterlace_line(uint8_t *dst, uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum,
                                 int size)
 {
 #ifndef HAVE_MMX
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;
     int sum;
 
     for(;size > 0;size--) {
@@ -1490,11 +1490,11 @@ static void deinterlace_line(UINT8 *dst, UINT8 *lum_m4, UINT8 *lum_m3, UINT8 *lu
     }
 #endif
 }
-static void deinterlace_line_inplace(UINT8 *lum_m4, UINT8 *lum_m3, UINT8 *lum_m2, UINT8 *lum_m1, UINT8 *lum,
+static void deinterlace_line_inplace(uint8_t *lum_m4, uint8_t *lum_m3, uint8_t *lum_m2, uint8_t *lum_m1, uint8_t *lum,
                              int size)
 {
 #ifndef HAVE_MMX
-    UINT8 *cm = cropTbl + MAX_NEG_CROP;
+    uint8_t *cm = cropTbl + MAX_NEG_CROP;
     int sum;
 
     for(;size > 0;size--) {
@@ -1536,11 +1536,11 @@ static void deinterlace_line_inplace(UINT8 *lum_m4, UINT8 *lum_m3, UINT8 *lum_m2
 /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The
    top field is copied as is, but the bottom field is deinterlaced
    against the top field. */
-static void deinterlace_bottom_field(UINT8 *dst, int dst_wrap,
-                                    UINT8 *src1, int src_wrap,
+static void deinterlace_bottom_field(uint8_t *dst, int dst_wrap,
+                                    uint8_t *src1, int src_wrap,
                                     int width, int height)
 {
-    UINT8 *src_m2, *src_m1, *src_0, *src_p1, *src_p2;
+    uint8_t *src_m2, *src_m1, *src_0, *src_p1, *src_p2;
     int y;
 
     src_m2 = src1;
@@ -1565,13 +1565,13 @@ static void deinterlace_bottom_field(UINT8 *dst, int dst_wrap,
     deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width);
 }
 
-static void deinterlace_bottom_field_inplace(UINT8 *src1, int src_wrap,
+static void deinterlace_bottom_field_inplace(uint8_t *src1, int src_wrap,
                                      int width, int height)
 {
-    UINT8 *src_m1, *src_0, *src_p1, *src_p2;
+    uint8_t *src_m1, *src_0, *src_p1, *src_p2;
     int y;
-    UINT8 *buf;
-    buf = (UINT8*)av_malloc(width);
+    uint8_t *buf;
+    buf = (uint8_t*)av_malloc(width);
 
     src_m1 = src1;
     memcpy(buf,src_m1,width);

libavcodec/imgresample.c

@@ -41,9 +41,9 @@
 struct ImgReSampleContext {
     int iwidth, iheight, owidth, oheight, topBand, bottomBand, leftBand, rightBand;
     int h_incr, v_incr;
-    INT16 h_filters[NB_PHASES][NB_TAPS] __align8; /* horizontal filters */
-    INT16 v_filters[NB_PHASES][NB_TAPS] __align8; /* vertical filters */
-    UINT8 *line_buf;
+    int16_t h_filters[NB_PHASES][NB_TAPS] __align8; /* horizontal filters */
+    int16_t v_filters[NB_PHASES][NB_TAPS] __align8; /* vertical filters */
+    uint8_t *line_buf;
 };
 
 static inline int get_phase(int pos)
@@ -52,12 +52,12 @@ static inline int get_phase(int pos)
 }
 
 /* This function must be optimized */
-static void h_resample_fast(UINT8 *dst, int dst_width, UINT8 *src, int src_width,
-                            int src_start, int src_incr, INT16 *filters)
+static void h_resample_fast(uint8_t *dst, int dst_width, uint8_t *src, int src_width,
+                            int src_start, int src_incr, int16_t *filters)
 {
     int src_pos, phase, sum, i;
-    UINT8 *s;
-    INT16 *filter;
+    uint8_t *s;
+    int16_t *filter;
 
     src_pos = src_start;
     for(i=0;i<dst_width;i++) {
@@ -95,11 +95,11 @@ static void h_resample_fast(UINT8 *dst, int dst_width, UINT8 *src, int src_width
 }
 
 /* This function must be optimized */
-static void v_resample(UINT8 *dst, int dst_width, UINT8 *src, int wrap, 
-                       INT16 *filter)
+static void v_resample(uint8_t *dst, int dst_width, uint8_t *src, int wrap, 
+                       int16_t *filter)
 {
     int sum, i;
-    UINT8 *s;
+    uint8_t *s;
 
     s = src;
     for(i=0;i<dst_width;i++) {
@@ -111,7 +111,7 @@ static void v_resample(UINT8 *dst, int dst_width, UINT8 *src, int wrap,
 #else
         {
             int j;
-            UINT8 *s1 = s;
+            uint8_t *s1 = s;
 
             sum = 0;
             for(j=0;j<NB_TAPS;j++) {
@@ -154,12 +154,12 @@ static void v_resample(UINT8 *dst, int dst_width, UINT8 *src, int wrap,
 #define DUMP(reg) movq_r2m(reg, tmp); printf(#reg "=%016Lx\n", tmp.uq);
 
 /* XXX: do four pixels at a time */
-static void h_resample_fast4_mmx(UINT8 *dst, int dst_width, UINT8 *src, int src_width,
-                                 int src_start, int src_incr, INT16 *filters)
+static void h_resample_fast4_mmx(uint8_t *dst, int dst_width, uint8_t *src, int src_width,
+                                 int src_start, int src_incr, int16_t *filters)
 {
     int src_pos, phase;
-    UINT8 *s;
-    INT16 *filter;
+    uint8_t *s;
+    int16_t *filter;
     mmx_t tmp;
     
     src_pos = src_start;
@@ -198,11 +198,11 @@ static void h_resample_fast4_mmx(UINT8 *dst, int dst_width, UINT8 *src, int src_
     emms();
 }
 
-static void v_resample4_mmx(UINT8 *dst, int dst_width, UINT8 *src, int wrap, 
-                            INT16 *filter)
+static void v_resample4_mmx(uint8_t *dst, int dst_width, uint8_t *src, int wrap, 
+                            int16_t *filter)
 {
     int sum, i, v;
-    UINT8 *s;
+    uint8_t *s;
     mmx_t tmp;
     mmx_t coefs[4];
     
@@ -239,7 +239,7 @@ static void v_resample4_mmx(UINT8 *dst, int dst_width, UINT8 *src, int wrap,
         packuswb_r2r(mm7, mm0);
         movq_r2m(mm0, tmp);
 
-        *(UINT32 *)dst = tmp.ud[0];
+        *(uint32_t *)dst = tmp.ud[0];
         dst += 4;
         s += 4;
         dst_width -= 4;
@@ -274,8 +274,8 @@ typedef	union {
     signed short s[8];
 } vec_ss_t;
 
-void v_resample16_altivec(UINT8 *dst, int dst_width, UINT8 *src, int wrap,
-                            INT16 *filter)
+void v_resample16_altivec(uint8_t *dst, int dst_width, uint8_t *src, int wrap,
+                            int16_t *filter)
 {
     int sum, i;
     uint8_t *s;
@@ -391,12 +391,12 @@ void v_resample16_altivec(UINT8 *dst, int dst_width, UINT8 *src, int wrap,
 #endif
 
 /* slow version to handle limit cases. Does not need optimisation */
-static void h_resample_slow(UINT8 *dst, int dst_width, UINT8 *src, int src_width,
-                            int src_start, int src_incr, INT16 *filters)
+static void h_resample_slow(uint8_t *dst, int dst_width, uint8_t *src, int src_width,
+                            int src_start, int src_incr, int16_t *filters)
 {
     int src_pos, phase, sum, j, v, i;
-    UINT8 *s, *src_end;
-    INT16 *filter;
+    uint8_t *s, *src_end;
+    int16_t *filter;
 
     src_end = src + src_width;
     src_pos = src_start;
@@ -426,8 +426,8 @@ static void h_resample_slow(UINT8 *dst, int dst_width, UINT8 *src, int src_width
     }
 }
 
-static void h_resample(UINT8 *dst, int dst_width, UINT8 *src, int src_width,
-                       int src_start, int src_incr, INT16 *filters)
+static void h_resample(uint8_t *dst, int dst_width, uint8_t *src, int src_width,
+                       int src_start, int src_incr, int16_t *filters)
 {
     int n, src_end;
 
@@ -463,11 +463,11 @@ static void h_resample(UINT8 *dst, int dst_width, UINT8 *src, int src_width,
 }
 
 static void component_resample(ImgReSampleContext *s, 
-                               UINT8 *output, int owrap, int owidth, int oheight,
-                               UINT8 *input, int iwrap, int iwidth, int iheight)
+                               uint8_t *output, int owrap, int owidth, int oheight,
+                               uint8_t *input, int iwrap, int iwidth, int iheight)
 {
     int src_y, src_y1, last_src_y, ring_y, phase_y, y1, y;
-    UINT8 *new_line, *src_line;
+    uint8_t *new_line, *src_line;
 
     last_src_y = - FCENTER - 1;
     /* position of the bottom of the filter in the source image */
@@ -528,7 +528,7 @@ static void component_resample(ImgReSampleContext *s,
 
 /* XXX: the following filter is quite naive, but it seems to suffice
    for 4 taps */
-static void build_filter(INT16 *filter, float factor)
+static void build_filter(int16_t *filter, float factor)
 {
     int ph, i, v;
     float x, y, tab[NB_TAPS], norm, mult;
@@ -641,15 +641,15 @@ void av_free(void *ptr)
 /* input */
 #define XSIZE 256
 #define YSIZE 256
-UINT8 img[XSIZE * YSIZE];
+uint8_t img[XSIZE * YSIZE];
 
 /* output */
 #define XSIZE1 512
 #define YSIZE1 512
-UINT8 img1[XSIZE1 * YSIZE1];
-UINT8 img2[XSIZE1 * YSIZE1];
+uint8_t img1[XSIZE1 * YSIZE1];
+uint8_t img2[XSIZE1 * YSIZE1];
 
-void save_pgm(const char *filename, UINT8 *img, int xsize, int ysize)
+void save_pgm(const char *filename, uint8_t *img, int xsize, int ysize)
 {
     FILE *f;
     f=fopen(filename,"w");
@@ -658,7 +658,7 @@ void save_pgm(const char *filename, UINT8 *img, int xsize, int ysize)
     fclose(f);
 }
 
-static void dump_filter(INT16 *filter)
+static void dump_filter(int16_t *filter)
 {
     int i, ph;
 

libavcodec/jfdctfst.c

@@ -78,10 +78,10 @@
  */
 
 #if CONST_BITS == 8
-#define FIX_0_382683433  ((INT32)   98)		/* FIX(0.382683433) */
-#define FIX_0_541196100  ((INT32)  139)		/* FIX(0.541196100) */
-#define FIX_0_707106781  ((INT32)  181)		/* FIX(0.707106781) */
-#define FIX_1_306562965  ((INT32)  334)		/* FIX(1.306562965) */
+#define FIX_0_382683433  ((int32_t)   98)		/* FIX(0.382683433) */
+#define FIX_0_541196100  ((int32_t)  139)		/* FIX(0.541196100) */
+#define FIX_0_707106781  ((int32_t)  181)		/* FIX(0.707106781) */
+#define FIX_1_306562965  ((int32_t)  334)		/* FIX(1.306562965) */
 #else
 #define FIX_0_382683433  FIX(0.382683433)
 #define FIX_0_541196100  FIX(0.541196100)
@@ -101,7 +101,7 @@
 #endif
 
 
-/* Multiply a DCTELEM variable by an INT32 constant, and immediately
+/* Multiply a DCTELEM variable by an int32_t constant, and immediately
  * descale to yield a DCTELEM result.
  */
 

libavcodec/jfdctint.c

@@ -78,7 +78,7 @@
  * they are represented to better-than-integral precision.  These outputs
  * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
  * with the recommended scaling.  (For 12-bit sample data, the intermediate
- * array is INT32 anyway.)
+ * array is int32_t anyway.)
  *
  * To avoid overflow of the 32-bit intermediate results in pass 2, we must
  * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
@@ -101,18 +101,18 @@
  */
 
 #if CONST_BITS == 13
-#define FIX_0_298631336  ((INT32)  2446)	/* FIX(0.298631336) */
-#define FIX_0_390180644  ((INT32)  3196)	/* FIX(0.390180644) */
-#define FIX_0_541196100  ((INT32)  4433)	/* FIX(0.541196100) */
-#define FIX_0_765366865  ((INT32)  6270)	/* FIX(0.765366865) */
-#define FIX_0_899976223  ((INT32)  7373)	/* FIX(0.899976223) */
-#define FIX_1_175875602  ((INT32)  9633)	/* FIX(1.175875602) */
-#define FIX_1_501321110  ((INT32)  12299)	/* FIX(1.501321110) */
-#define FIX_1_847759065  ((INT32)  15137)	/* FIX(1.847759065) */
-#define FIX_1_961570560  ((INT32)  16069)	/* FIX(1.961570560) */
-#define FIX_2_053119869  ((INT32)  16819)	/* FIX(2.053119869) */
-#define FIX_2_562915447  ((INT32)  20995)	/* FIX(2.562915447) */
-#define FIX_3_072711026  ((INT32)  25172)	/* FIX(3.072711026) */
+#define FIX_0_298631336  ((int32_t)  2446)	/* FIX(0.298631336) */
+#define FIX_0_390180644  ((int32_t)  3196)	/* FIX(0.390180644) */
+#define FIX_0_541196100  ((int32_t)  4433)	/* FIX(0.541196100) */
+#define FIX_0_765366865  ((int32_t)  6270)	/* FIX(0.765366865) */
+#define FIX_0_899976223  ((int32_t)  7373)	/* FIX(0.899976223) */
+#define FIX_1_175875602  ((int32_t)  9633)	/* FIX(1.175875602) */
+#define FIX_1_501321110  ((int32_t)  12299)	/* FIX(1.501321110) */
+#define FIX_1_847759065  ((int32_t)  15137)	/* FIX(1.847759065) */
+#define FIX_1_961570560  ((int32_t)  16069)	/* FIX(1.961570560) */
+#define FIX_2_053119869  ((int32_t)  16819)	/* FIX(2.053119869) */
+#define FIX_2_562915447  ((int32_t)  20995)	/* FIX(2.562915447) */
+#define FIX_3_072711026  ((int32_t)  25172)	/* FIX(3.072711026) */
 #else
 #define FIX_0_298631336  FIX(0.298631336)
 #define FIX_0_390180644  FIX(0.390180644)
@@ -129,7 +129,7 @@
 #endif
 
 
-/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+/* Multiply an int32_t variable by an int32_t constant to yield an int32_t result.
  * For 8-bit samples with the recommended scaling, all the variable
  * and constant values involved are no more than 16 bits wide, so a
  * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
@@ -150,9 +150,9 @@
 GLOBAL(void)
 ff_jpeg_fdct_islow (DCTELEM * data)
 {
-  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
-  INT32 tmp10, tmp11, tmp12, tmp13;
-  INT32 z1, z2, z3, z4, z5;
+  int32_t tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  int32_t tmp10, tmp11, tmp12, tmp13;
+  int32_t z1, z2, z3, z4, z5;
   DCTELEM *dataptr;
   int ctr;
   SHIFT_TEMPS

libavcodec/jrevdct.c

@@ -92,7 +92,7 @@ typedef DCTELEM DCTBLOCK[DCTSIZE2];
 #define PASS1_BITS  1		/* lose a little precision to avoid overflow */
 #endif
 
-#define ONE	((INT32) 1)
+#define ONE	((int32_t) 1)
 
 #define CONST_SCALE (ONE << CONST_BITS)
 
@@ -103,16 +103,16 @@ typedef DCTELEM DCTBLOCK[DCTSIZE2];
  */
 
 /* Actually FIX is no longer used, we precomputed them all */
-#define FIX(x)	((INT32) ((x) * CONST_SCALE + 0.5)) 
+#define FIX(x)	((int32_t) ((x) * CONST_SCALE + 0.5)) 
 
-/* Descale and correctly round an INT32 value that's scaled by N bits.
+/* Descale and correctly round an int32_t value that's scaled by N bits.
  * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
  * the fudge factor is correct for either sign of X.
  */
 
 #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
 
-/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+/* Multiply an int32_t variable by an int32_t constant to yield an int32_t result.
  * For 8-bit samples with the recommended scaling, all the variable
  * and constant values involved are no more than 16 bits wide, so a
  * 16x16->32 bit multiply can be used instead of a full 32x32 multiply;
@@ -125,10 +125,10 @@ typedef DCTELEM DCTBLOCK[DCTSIZE2];
 
 #ifdef EIGHT_BIT_SAMPLES
 #ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
-#define MULTIPLY(var,const)  (((INT16) (var)) * ((INT16) (const)))
+#define MULTIPLY(var,const)  (((int16_t) (var)) * ((int16_t) (const)))
 #endif
 #ifdef SHORTxLCONST_32		/* known to work with Microsoft C 6.0 */
-#define MULTIPLY(var,const)  (((INT16) (var)) * ((INT32) (const)))
+#define MULTIPLY(var,const)  (((int16_t) (var)) * ((int32_t) (const)))
 #endif
 #endif
 
@@ -172,10 +172,10 @@ ones here or successive P-frames will drift too much with Reference frame coding
 
 void j_rev_dct(DCTBLOCK data)
 {
-  INT32 tmp0, tmp1, tmp2, tmp3;
-  INT32 tmp10, tmp11, tmp12, tmp13;
-  INT32 z1, z2, z3, z4, z5;
-  INT32 d0, d1, d2, d3, d4, d5, d6, d7;
+  int32_t tmp0, tmp1, tmp2, tmp3;
+  int32_t tmp10, tmp11, tmp12, tmp13;
+  int32_t z1, z2, z3, z4, z5;
+  int32_t d0, d1, d2, d3, d4, d5, d6, d7;
   register DCTELEM *dataptr;
   int rowctr;
    

libavcodec/mace.c

@@ -24,11 +24,11 @@
  * libavcodec api, context stuff, interlaced stereo out).
  */
 
-static const UINT16 MACEtab1[] = { 0xfff3, 0x0008, 0x004c, 0x00de, 0x00de, 0x004c, 0x0008, 0xfff3 };
+static const uint16_t MACEtab1[] = { 0xfff3, 0x0008, 0x004c, 0x00de, 0x00de, 0x004c, 0x0008, 0xfff3 };
 
-static const UINT16 MACEtab3[] = { 0xffee, 0x008c, 0x008c, 0xffee };
+static const uint16_t MACEtab3[] = { 0xffee, 0x008c, 0x008c, 0xffee };
 
-static const UINT16 MACEtab2[][8] = {
+static const uint16_t MACEtab2[][8] = {
     { 0x0025, 0x0074, 0x00CE, 0x014A, 0xFEB5, 0xFF31, 0xFF8B, 0xFFDA },
     { 0x0027, 0x0079, 0x00D8, 0x015A, 0xFEA5, 0xFF27, 0xFF86, 0xFFD8 },
     { 0x0029, 0x007F, 0x00E1, 0x0169, 0xFE96, 0xFF1E, 0xFF80, 0xFFD6 },
@@ -159,7 +159,7 @@ static const UINT16 MACEtab2[][8] = {
     { 0x25A7, 0x741F, 0x7FFF, 0x7FFF, 0x8000, 0x8000, 0x8BE0, 0xDA58 },
 };
 
-static const UINT16 MACEtab4[][8] = {
+static const uint16_t MACEtab4[][8] = {
     { 0x0040, 0x00D8, 0xFF27, 0xFFBF, 0, 0, 0, 0 },  { 0x0043, 0x00E2, 0xFF1D, 0xFFBC, 0, 0, 0, 0 },
     { 0x0046, 0x00EC, 0xFF13, 0xFFB9, 0, 0, 0, 0 },  { 0x004A, 0x00F6, 0xFF09, 0xFFB5, 0, 0, 0, 0 },
     { 0x004D, 0x0101, 0xFEFE, 0xFFB2, 0, 0, 0, 0 },  { 0x0050, 0x010C, 0xFEF3, 0xFFAF, 0, 0, 0, 0 },
@@ -234,9 +234,9 @@ typedef struct MACEContext {
 
 /* /// "chomp3()" */
 static void chomp3(MACEContext *ctx,
-            UINT8 val,
-            const UINT16 tab1[],
-            const UINT16 tab2[][8])
+            uint8_t val,
+            const uint16_t tab1[],
+            const uint16_t tab2[][8])
 {
   short current;
 
@@ -253,13 +253,13 @@ static void chomp3(MACEContext *ctx,
 
 /* /// "Exp1to3()" */
 static void Exp1to3(MACEContext *ctx,
-             UINT8 *inBuffer,
+             uint8_t *inBuffer,
              void *outBuffer,
-             UINT32 cnt,
-             UINT32 numChannels,
-             UINT32 whichChannel)
+             uint32_t cnt,
+             uint32_t numChannels,
+             uint32_t whichChannel)
 {
-   UINT8 pkt;
+   uint8_t pkt;
 
 /*
    if (inState) {
@@ -298,9 +298,9 @@ static void Exp1to3(MACEContext *ctx,
 
 /* /// "chomp6()" */
 static void chomp6(MACEContext *ctx,
-            UINT8 val,
-            const UINT16 tab1[],
-            const UINT16 tab2[][8])
+            uint8_t val,
+            const uint16_t tab1[],
+            const uint16_t tab2[][8])
 {
   short current;
 
@@ -335,13 +335,13 @@ static void chomp6(MACEContext *ctx,
 
 /* /// "Exp1to6()" */
 static void Exp1to6(MACEContext *ctx,
-             UINT8 *inBuffer,
+             uint8_t *inBuffer,
              void *outBuffer,
-             UINT32 cnt,
-             UINT32 numChannels,
-             UINT32 whichChannel)
+             uint32_t cnt,
+             uint32_t numChannels,
+             uint32_t whichChannel)
 {
-   UINT8 pkt;
+   uint8_t pkt;
 
 /*
    if (inState) {
@@ -389,7 +389,7 @@ static int mace_decode_init(AVCodecContext * avctx)
 
 static int mace_decode_frame(AVCodecContext *avctx,
                             void *data, int *data_size,
-                            UINT8 *buf, int buf_size)
+                            uint8_t *buf, int buf_size)
 {
     short *samples;
     MACEContext *c = avctx->priv_data;

libavcodec/mjpeg.c

@@ -30,15 +30,15 @@
 #undef TWOMATRIXES
 
 typedef struct MJpegContext {
-    UINT8 huff_size_dc_luminance[12];
-    UINT16 huff_code_dc_luminance[12];
-    UINT8 huff_size_dc_chrominance[12];
-    UINT16 huff_code_dc_chrominance[12];
-
-    UINT8 huff_size_ac_luminance[256];
-    UINT16 huff_code_ac_luminance[256];
-    UINT8 huff_size_ac_chrominance[256];
-    UINT16 huff_code_ac_chrominance[256];
+    uint8_t huff_size_dc_luminance[12];
+    uint16_t huff_code_dc_luminance[12];
+    uint8_t huff_size_dc_chrominance[12];
+    uint16_t huff_code_dc_chrominance[12];
+
+    uint8_t huff_size_ac_luminance[256];
+    uint16_t huff_code_ac_luminance[256];
+    uint8_t huff_size_ac_chrominance[256];
+    uint16_t huff_code_ac_chrominance[256];
 } MJpegContext;
 
 /* JPEG marker codes */
@@ -152,19 +152,19 @@ static const unsigned char std_chrominance_quant_tbl[64] = {
 
 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
 /* IMPORTANT: these are only valid for 8-bit data precision! */
-static const UINT8 bits_dc_luminance[17] =
+static const uint8_t bits_dc_luminance[17] =
 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
-static const UINT8 val_dc_luminance[] =
+static const uint8_t val_dc_luminance[] =
 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 
-static const UINT8 bits_dc_chrominance[17] =
+static const uint8_t bits_dc_chrominance[17] =
 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
-static const UINT8 val_dc_chrominance[] =
+static const uint8_t val_dc_chrominance[] =
 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 
-static const UINT8 bits_ac_luminance[17] =
+static const uint8_t bits_ac_luminance[17] =
 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
-static const UINT8 val_ac_luminance[] =
+static const uint8_t val_ac_luminance[] =
 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
@@ -188,10 +188,10 @@ static const UINT8 val_ac_luminance[] =
   0xf9, 0xfa 
 };
 
-static const UINT8 bits_ac_chrominance[17] =
+static const uint8_t bits_ac_chrominance[17] =
 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 
-static const UINT8 val_ac_chrominance[] =
+static const uint8_t val_ac_chrominance[] =
 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
@@ -216,8 +216,8 @@ static const UINT8 val_ac_chrominance[] =
 };
 
 /* isn't this function nicer than the one in the libjpeg ? */
-static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
-                                const UINT8 *bits_table, const UINT8 *val_table)
+static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
+                                const uint8_t *bits_table, const uint8_t *val_table)
 {
     int i, j, k,nb, code, sym;
 
@@ -282,7 +282,7 @@ static inline void put_marker(PutBitContext *p, int code)
 
 /* table_class: 0 = DC coef, 1 = AC coefs */
 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
-                             const UINT8 *bits_table, const UINT8 *value_table)
+                             const uint8_t *bits_table, const uint8_t *value_table)
 {
     PutBitContext *p = &s->pb;
     int n, i;
@@ -306,7 +306,7 @@ static void jpeg_table_header(MpegEncContext *s)
 {
     PutBitContext *p = &s->pb;
     int i, j, size;
-    UINT8 *ptr;
+    uint8_t *ptr;
 
     /* quant matrixes */
     put_marker(p, DQT);
@@ -349,7 +349,7 @@ static void jpeg_put_comments(MpegEncContext *s)
 {
     PutBitContext *p = &s->pb;
     int size;
-    UINT8 *ptr;
+    uint8_t *ptr;
 
     if (s->aspect_ratio_info)
     {
@@ -541,7 +541,7 @@ void mjpeg_picture_trailer(MpegEncContext *s)
 }
 
 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
-				   UINT8 *huff_size, UINT16 *huff_code)
+				   uint8_t *huff_size, uint16_t *huff_code)
 {
     int mant, nbits;
 
@@ -572,8 +572,8 @@ static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
     int mant, nbits, code, i, j;
     int component, dc, run, last_index, val;
     MJpegContext *m = s->mjpeg_ctx;
-    UINT8 *huff_size_ac;
-    UINT16 *huff_code_ac;
+    uint8_t *huff_size_ac;
+    uint16_t *huff_code_ac;
     
     /* DC coef */
     component = (n <= 3 ? 0 : n - 4 + 1);
@@ -651,9 +651,9 @@ typedef struct MJpegDecodeContext {
 
     int start_code; /* current start code */
     int buffer_size;
-    UINT8 *buffer;
+    uint8_t *buffer;
 
-    INT16 quant_matrixes[4][64];
+    int16_t quant_matrixes[4][64];
     VLC vlcs[2][4];
 
     int org_width, org_height;  /* size given at codec init */
@@ -669,11 +669,11 @@ typedef struct MJpegDecodeContext {
     int h_max, v_max; /* maximum h and v counts */
     int quant_index[4];   /* quant table index for each component */
     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
-    UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
+    uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */
     int linesize[MAX_COMPONENTS];
     DCTELEM block[64] __align8;
     ScanTable scantable;
-    void (*idct_put)(UINT8 *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
+    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
 
     int restart_interval;
     int restart_count;
@@ -684,11 +684,11 @@ typedef struct MJpegDecodeContext {
 
 static int mjpeg_decode_dht(MJpegDecodeContext *s);
 
-static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table, 
+static void build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
                       int nb_codes)
 {
-    UINT8 huff_size[256];
-    UINT16 huff_code[256];
+    uint8_t huff_size[256];
+    uint16_t huff_code[256];
 
     memset(huff_size, 0, sizeof(huff_size));
     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
@@ -776,8 +776,8 @@ static int mjpeg_decode_dqt(MJpegDecodeContext *s)
 static int mjpeg_decode_dht(MJpegDecodeContext *s)
 {
     int len, index, i, class, n, v, code_max;
-    UINT8 bits_table[17];
-    UINT8 val_table[256];
+    uint8_t bits_table[17];
+    uint8_t val_table[256];
     
     len = get_bits(&s->gb, 16) - 2;
 
@@ -928,7 +928,7 @@ static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
     int nbits, code, i, j, level;
     int run, val;
     VLC *ac_vlc;
-    INT16 *quant_matrix;
+    int16_t *quant_matrix;
 
     /* DC coef */
     val = mjpeg_decode_dc(s, dc_index);
@@ -1071,7 +1071,7 @@ static int mjpeg_decode_sos(MJpegDecodeContext *s)
     for(mb_y = 0; mb_y < mb_height; mb_y++) {
         for(mb_x = 0; mb_x < mb_width; mb_x++) {
             for(i=0;i<nb_components;i++) {
-                UINT8 *ptr;
+                uint8_t *ptr;
                 int x, y, c;
                 n = nb_blocks[i];
                 c = comp_index[i];
@@ -1266,7 +1266,7 @@ static int mjpeg_decode_com(MJpegDecodeContext *s)
     unsigned int len = get_bits(&s->gb, 16);
     if (len >= 2 && len < 32768) {
 	/* XXX: any better upper bound */
-	UINT8 *cbuf = av_malloc(len - 1);
+	uint8_t *cbuf = av_malloc(len - 1);
 	if (cbuf) {
 	    int i;
 	    for (i = 0; i < len - 2; i++)
@@ -1318,9 +1318,9 @@ static int valid_marker_list[] =
 
 /* return the 8 bit start code value and update the search
    state. Return -1 if no start code found */
-static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end)
+static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
 {
-    UINT8 *buf_ptr;
+    uint8_t *buf_ptr;
     unsigned int v, v2;
     int val;
 #ifdef DEBUG
@@ -1350,10 +1350,10 @@ found:
 
 static int mjpeg_decode_frame(AVCodecContext *avctx, 
                               void *data, int *data_size,
-                              UINT8 *buf, int buf_size)
+                              uint8_t *buf, int buf_size)
 {
     MJpegDecodeContext *s = avctx->priv_data;
-    UINT8 *buf_end, *buf_ptr;
+    uint8_t *buf_end, *buf_ptr;
     int i, start_code;
     AVPicture *picture = data;
 
@@ -1387,12 +1387,12 @@ static int mjpeg_decode_frame(AVCodecContext *avctx,
 		/* unescape buffer of SOS */
 		if (start_code == SOS)
 		{
-		    UINT8 *src = buf_ptr;
-		    UINT8 *dst = s->buffer;
+		    uint8_t *src = buf_ptr;
+		    uint8_t *dst = s->buffer;
 
 		    while (src<buf_end)
 		    {
-			UINT8 x = *(src++);
+			uint8_t x = *(src++);
 
 			*(dst++) = x;
 			if (x == 0xff)
@@ -1527,10 +1527,10 @@ the_end:
 
 static int mjpegb_decode_frame(AVCodecContext *avctx, 
                               void *data, int *data_size,
-                              UINT8 *buf, int buf_size)
+                              uint8_t *buf, int buf_size)
 {
     MJpegDecodeContext *s = avctx->priv_data;
-    UINT8 *buf_end, *buf_ptr;
+    uint8_t *buf_end, *buf_ptr;
     int i;
     AVPicture *picture = data;
     GetBitContext hgb; /* for the header */

libavcodec/mlib/dsputil_mlib.c

@@ -198,10 +198,10 @@ static void avg_pixels8_xy2_mlib (uint8_t * dest, const uint8_t * ref,
 }
 
 
-static void (*put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
+static void (*put_pixels_clamped)(const DCTELEM *block, uint8_t *pixels, int line_size);
 
 
-static void add_pixels_clamped_mlib(const DCTELEM *block, UINT8 *pixels, int line_size)
+static void add_pixels_clamped_mlib(const DCTELEM *block, uint8_t *pixels, int line_size)
 {
     mlib_VideoAddBlock_U8_S16(pixels, (mlib_s16 *)block, line_size);
 }
@@ -209,13 +209,13 @@ static void add_pixels_clamped_mlib(const DCTELEM *block, UINT8 *pixels, int lin
 
 /* XXX: those functions should be suppressed ASAP when all IDCTs are
    converted */
-static void ff_idct_put_mlib(UINT8 *dest, int line_size, DCTELEM *data)
+static void ff_idct_put_mlib(uint8_t *dest, int line_size, DCTELEM *data)
 {
     mlib_VideoIDCT8x8_S16_S16 (data, data);
     put_pixels_clamped(data, dest, line_size);
 }
 
-static void ff_idct_add_mlib(UINT8 *dest, int line_size, DCTELEM *data)
+static void ff_idct_add_mlib(uint8_t *dest, int line_size, DCTELEM *data)
 {
     mlib_VideoIDCT8x8_S16_S16 (data, data);
     mlib_VideoAddBlock_U8_S16(dest, (mlib_s16 *)data, line_size);

libavcodec/motion_est.c

@@ -387,7 +387,7 @@ void ff_init_me(MpegEncContext *s){
     }
 }
       
-static int pix_dev(UINT8 * pix, int line_size, int mean)
+static int pix_dev(uint8_t * pix, int line_size, int mean)
 {
     int s, i, j;
 
@@ -422,7 +422,7 @@ static int full_motion_search(MpegEncContext * s,
 {
     int x1, y1, x2, y2, xx, yy, x, y;
     int mx, my, dmin, d;
-    UINT8 *pix;
+    uint8_t *pix;
 
     xx = 16 * s->mb_x;
     yy = 16 * s->mb_y;
@@ -476,7 +476,7 @@ static int log_motion_search(MpegEncContext * s,
 {
     int x1, y1, x2, y2, xx, yy, x, y;
     int mx, my, dmin, d;
-    UINT8 *pix;
+    uint8_t *pix;
 
     xx = s->mb_x << 4;
     yy = s->mb_y << 4;
@@ -552,7 +552,7 @@ static int phods_motion_search(MpegEncContext * s,
 {
     int x1, y1, x2, y2, xx, yy, x, y, lastx, d;
     int mx, my, dminx, dminy;
-    UINT8 *pix;
+    uint8_t *pix;
 
     xx = s->mb_x << 4;
     yy = s->mb_y << 4;
@@ -657,7 +657,7 @@ static inline int sad_hpel_motion_search(MpegEncContext * s,
     uint32_t *score_map= s->me.score_map;
     const int penalty_factor= s->me.sub_penalty_factor;
     int mx, my, xx, yy, dminh;
-    UINT8 *pix, *ptr;
+    uint8_t *pix, *ptr;
     op_pixels_abs_func pix_abs_x2;
     op_pixels_abs_func pix_abs_y2;
     op_pixels_abs_func pix_abs_xy2;
@@ -964,7 +964,7 @@ static inline int h263_mv4_search(MpegEncContext *s, int xmin, int ymin, int xma
 void ff_estimate_p_frame_motion(MpegEncContext * s,
                                 int mb_x, int mb_y)
 {
-    UINT8 *pix, *ppix;
+    uint8_t *pix, *ppix;
     int sum, varc, vard, mx, my, range, dmin, xx, yy;
     int xmin, ymin, xmax, ymax;
     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
@@ -1302,7 +1302,7 @@ static inline int check_bidir_mv(MpegEncContext * s,
     //FIXME optimize?
     //FIXME move into template?
     //FIXME better f_code prediction (max mv & distance)
-    UINT16 *mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
+    uint16_t *mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
     uint8_t *dest_y = s->me.scratchpad;
     uint8_t *ptr;
     int dxy;
@@ -1535,7 +1535,7 @@ int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type)
     if(s->me_method>=ME_EPZS){
         int score[8];
         int i, y;
-        UINT8 * fcode_tab= s->fcode_tab;
+        uint8_t * fcode_tab= s->fcode_tab;
         int best_fcode=-1;
         int best_score=-10000000;
 
@@ -1584,7 +1584,7 @@ void ff_fix_long_p_mvs(MpegEncContext * s)
 {
     const int f_code= s->f_code;
     int y;
-    UINT8 * fcode_tab= s->fcode_tab;
+    uint8_t * fcode_tab= s->fcode_tab;
 //int clip=0;
 //int noclip=0;
     /* clip / convert to intra 16x16 type MVs */
@@ -1648,7 +1648,7 @@ void ff_fix_long_p_mvs(MpegEncContext * s)
 void ff_fix_long_b_mvs(MpegEncContext * s, int16_t (*mv_table)[2], int f_code, int type)
 {
     int y;
-    UINT8 * fcode_tab= s->fcode_tab;
+    uint8_t * fcode_tab= s->fcode_tab;
 
     // RAL: 8 in MPEG-1, 16 in MPEG-4
     int range = (((s->codec_id == CODEC_ID_MPEG1VIDEO) ? 8 : 16) << f_code);

libavcodec/motion_test.c

@@ -9,27 +9,27 @@
 
 #include "i386/mmx.h"
 
-int pix_abs16x16_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_mmx1(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_x2_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_x2_mmx1(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_x2_c(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_y2_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_y2_mmx1(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_y2_c(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_xy2_mmx(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_xy2_mmx1(UINT8 *blk1, UINT8 *blk2, int lx);
-int pix_abs16x16_xy2_c(UINT8 *blk1, UINT8 *blk2, int lx);
-
-typedef int motion_func(UINT8 *blk1, UINT8 *blk2, int lx);
+int pix_abs16x16_mmx(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_mmx1(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_x2_mmx(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_x2_mmx1(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_x2_c(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_y2_mmx(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_y2_mmx1(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_y2_c(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_xy2_mmx(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_xy2_mmx1(uint8_t *blk1, uint8_t *blk2, int lx);
+int pix_abs16x16_xy2_c(uint8_t *blk1, uint8_t *blk2, int lx);
+
+typedef int motion_func(uint8_t *blk1, uint8_t *blk2, int lx);
 
 #define WIDTH 64
 #define HEIGHT 64
 
-UINT8 img1[WIDTH * HEIGHT];
-UINT8 img2[WIDTH * HEIGHT];
+uint8_t img1[WIDTH * HEIGHT];
+uint8_t img2[WIDTH * HEIGHT];
 
-void fill_random(UINT8 *tab, int size)
+void fill_random(uint8_t *tab, int size)
 {
     int i;
     for(i=0;i<size;i++) {
@@ -48,11 +48,11 @@ void help(void)
     exit(1);
 }
 
-INT64 gettime(void)
+int64_t gettime(void)
 {
     struct timeval tv;
     gettimeofday(&tv,NULL);
-    return (INT64)tv.tv_sec * 1000000 + tv.tv_usec;
+    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
 }
 
 #define NB_ITS 500
@@ -63,8 +63,8 @@ void test_motion(const char *name,
                  motion_func *test_func, motion_func *ref_func)
 {
     int x, y, d1, d2, it;
-    UINT8 *ptr;
-    INT64 ti;
+    uint8_t *ptr;
+    int64_t ti;
     printf("testing '%s'\n", name);
 
     /* test correctness */

libavcodec/mpeg12.c

@@ -67,8 +67,8 @@ static inline int mpeg2_decode_block_intra(MpegEncContext *s,
 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
 
 #ifdef CONFIG_ENCODERS
-static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
-static UINT8 fcode_tab[MAX_MV*2+1];
+static uint16_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
+static uint8_t fcode_tab[MAX_MV*2+1];
 
 static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
 static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
@@ -182,7 +182,7 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s)
         unsigned int vbv_buffer_size;
         unsigned int fps, v;
         int n, i;
-        UINT64 time_code;
+        uint64_t time_code;
         float best_aspect_error= 1E10;
         float aspect_ratio= s->avctx->aspect_ratio;
         
@@ -242,13 +242,13 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s)
             /* time code : we must convert from the real frame rate to a
                fake mpeg frame rate in case of low frame rate */
             fps = frame_rate_tab[s->frame_rate_index];
-            time_code = (INT64)s->fake_picture_number * FRAME_RATE_BASE;
+            time_code = (int64_t)s->fake_picture_number * FRAME_RATE_BASE;
             s->gop_picture_number = s->fake_picture_number;
-            put_bits(&s->pb, 5, (UINT32)((time_code / (fps * 3600)) % 24));
-            put_bits(&s->pb, 6, (UINT32)((time_code / (fps * 60)) % 60));
+            put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
+            put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
             put_bits(&s->pb, 1, 1);
-            put_bits(&s->pb, 6, (UINT32)((time_code / fps) % 60));
-            put_bits(&s->pb, 6, (UINT32)((time_code % fps) / FRAME_RATE_BASE));
+            put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
+            put_bits(&s->pb, 6, (uint32_t)((time_code % fps) / FRAME_RATE_BASE));
             put_bits(&s->pb, 1, 1); /* closed gop */
             put_bits(&s->pb, 1, 0); /* broken link */
         }
@@ -257,7 +257,7 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s)
             /* insert empty P pictures to slow down to the desired
                frame rate. Each fake pictures takes about 20 bytes */
             fps = frame_rate_tab[s->frame_rate_index];
-            n = (((INT64)s->picture_number * fps) / s->frame_rate) - 1;
+            n = (((int64_t)s->picture_number * fps) / s->frame_rate) - 1;
             while (s->fake_picture_number < n) {
                 mpeg1_skip_picture(s, s->fake_picture_number - 
                                    s->gop_picture_number); 
@@ -737,7 +737,7 @@ static void mpeg1_encode_block(MpegEncContext *s,
            it is handled slightly differently */
         level = block[0];
         if (abs(level) == 1) {
-                code = ((UINT32)level >> 31); /* the sign bit */
+                code = ((uint32_t)level >> 31); /* the sign bit */
                 put_bits(&s->pb, 2, code | 0x02);
                 i = 1;
         } else {
@@ -1208,8 +1208,8 @@ static inline int mpeg1_decode_block_intra(MpegEncContext *s,
     int level, dc, diff, i, j, run;
     int component;
     RLTable *rl = &rl_mpeg1;
-    UINT8 * const scantable= s->intra_scantable.permutated;
-    const UINT16 *quant_matrix= s->intra_matrix;
+    uint8_t * const scantable= s->intra_scantable.permutated;
+    const uint16_t *quant_matrix= s->intra_matrix;
     const int qscale= s->qscale;
 
     /* DC coef */
@@ -1280,8 +1280,8 @@ static inline int mpeg1_decode_block_inter(MpegEncContext *s,
 {
     int level, i, j, run;
     RLTable *rl = &rl_mpeg1;
-    UINT8 * const scantable= s->intra_scantable.permutated;
-    const UINT16 *quant_matrix= s->inter_matrix;
+    uint8_t * const scantable= s->intra_scantable.permutated;
+    const uint16_t *quant_matrix= s->inter_matrix;
     const int qscale= s->qscale;
 
     {
@@ -1358,8 +1358,8 @@ static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
 {
     int level, i, j, run;
     RLTable *rl = &rl_mpeg1;
-    UINT8 * const scantable= s->intra_scantable.permutated;
-    const UINT16 *quant_matrix;
+    uint8_t * const scantable= s->intra_scantable.permutated;
+    const uint16_t *quant_matrix;
     const int qscale= s->qscale;
     int mismatch;
 
@@ -1438,8 +1438,8 @@ static inline int mpeg2_decode_block_intra(MpegEncContext *s,
     int level, dc, diff, i, j, run;
     int component;
     RLTable *rl;
-    UINT8 * const scantable= s->intra_scantable.permutated;
-    const UINT16 *quant_matrix;
+    uint8_t * const scantable= s->intra_scantable.permutated;
+    const uint16_t *quant_matrix;
     const int qscale= s->qscale;
     int mismatch;
 
@@ -1516,10 +1516,10 @@ static inline int mpeg2_decode_block_intra(MpegEncContext *s,
 
 typedef struct Mpeg1Context {
     MpegEncContext mpeg_enc_ctx;
-    UINT32 header_state;
+    uint32_t header_state;
     int start_code; /* current start code */
-    UINT8 buffer[PICTURE_BUFFER_SIZE]; 
-    UINT8 *buf_ptr;
+    uint8_t buffer[PICTURE_BUFFER_SIZE]; 
+    uint8_t *buf_ptr;
     int buffer_size;
     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
     int repeat_field; /* true if we must repeat the field */
@@ -1546,10 +1546,10 @@ static int mpeg_decode_init(AVCodecContext *avctx)
 
 /* return the 8 bit start code value and update the search
    state. Return -1 if no start code found */
-static int find_start_code(UINT8 **pbuf_ptr, UINT8 *buf_end, 
-                           UINT32 *header_state)
+static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end, 
+                           uint32_t *header_state)
 {
-    UINT8 *buf_ptr;
+    uint8_t *buf_ptr;
     unsigned int state, v;
     int val;
 
@@ -1572,7 +1572,7 @@ static int find_start_code(UINT8 **pbuf_ptr, UINT8 *buf_end,
 }
 
 static int mpeg1_decode_picture(AVCodecContext *avctx, 
-                                UINT8 *buf, int buf_size)
+                                uint8_t *buf, int buf_size)
 {
     Mpeg1Context *s1 = avctx->priv_data;
     MpegEncContext *s = &s1->mpeg_enc_ctx;
@@ -1724,7 +1724,7 @@ static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
 }
 
 static void mpeg_decode_extension(AVCodecContext *avctx, 
-                                  UINT8 *buf, int buf_size)
+                                  uint8_t *buf, int buf_size)
 {
     Mpeg1Context *s1 = avctx->priv_data;
     MpegEncContext *s = &s1->mpeg_enc_ctx;
@@ -1764,7 +1764,7 @@ static void mpeg_decode_extension(AVCodecContext *avctx,
 static int mpeg_decode_slice(AVCodecContext *avctx, 
                               AVFrame *pict,
                               int start_code,
-                              UINT8 *buf, int buf_size)
+                              uint8_t *buf, int buf_size)
 {
     Mpeg1Context *s1 = avctx->priv_data;
     MpegEncContext *s = &s1->mpeg_enc_ctx;
@@ -1897,7 +1897,7 @@ eos: //end of slice
 }
 
 static int mpeg1_decode_sequence(AVCodecContext *avctx, 
-                                 UINT8 *buf, int buf_size)
+                                 uint8_t *buf, int buf_size)
 {
     Mpeg1Context *s1 = avctx->priv_data;
     MpegEncContext *s = &s1->mpeg_enc_ctx;
@@ -2010,10 +2010,10 @@ static int mpeg1_decode_sequence(AVCodecContext *avctx,
 /* handle buffering and image synchronisation */
 static int mpeg_decode_frame(AVCodecContext *avctx, 
                              void *data, int *data_size,
-                             UINT8 *buf, int buf_size)
+                             uint8_t *buf, int buf_size)
 {
     Mpeg1Context *s = avctx->priv_data;
-    UINT8 *buf_end, *buf_ptr, *buf_start;
+    uint8_t *buf_end, *buf_ptr, *buf_start;
     int len, start_code_found, ret, code, start_code, input_size;
     AVFrame *picture = data;
     MpegEncContext *s2 = &s->mpeg_enc_ctx;

libavcodec/mpeg12data.h

@@ -2,7 +2,7 @@
  * MPEG1/2 tables
  */
 
-const INT16 ff_mpeg1_default_intra_matrix[64] = {
+const int16_t ff_mpeg1_default_intra_matrix[64] = {
 	8, 16, 19, 22, 26, 27, 29, 34,
 	16, 16, 22, 24, 27, 29, 34, 37,
 	19, 22, 26, 27, 29, 34, 34, 38,
@@ -13,7 +13,7 @@ const INT16 ff_mpeg1_default_intra_matrix[64] = {
 	27, 29, 35, 38, 46, 56, 69, 83
 };
 
-const INT16 ff_mpeg1_default_non_intra_matrix[64] = {
+const int16_t ff_mpeg1_default_non_intra_matrix[64] = {
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
     16, 16, 16, 16, 16, 16, 16, 16,
@@ -47,14 +47,14 @@ const unsigned char vlc_dc_table[256] = {
     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
 };
 
-const UINT16 vlc_dc_lum_code[12] = {
+const uint16_t vlc_dc_lum_code[12] = {
     0x4, 0x0, 0x1, 0x5, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe, 0x1ff,
 };
 const unsigned char vlc_dc_lum_bits[12] = {
     3, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 9,
 };
 
-const UINT16 vlc_dc_chroma_code[12] = {
+const uint16_t vlc_dc_chroma_code[12] = {
     0x0, 0x1, 0x2, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe, 0x3fe, 0x3ff,
 };
 const unsigned char vlc_dc_chroma_bits[12] = {
@@ -62,10 +62,10 @@ const unsigned char vlc_dc_chroma_bits[12] = {
 };
 
 /* simple include everything table for dc, first byte is bits number next 3 are code*/
-static UINT32 mpeg1_lum_dc_uni[512];
-static UINT32 mpeg1_chr_dc_uni[512];
+static uint32_t mpeg1_lum_dc_uni[512];
+static uint32_t mpeg1_chr_dc_uni[512];
 
-static const UINT16 mpeg1_vlc[113][2] = {
+static const uint16_t mpeg1_vlc[113][2] = {
  { 0x3, 2 }, { 0x4, 4 }, { 0x5, 5 }, { 0x6, 7 },
  { 0x26, 8 }, { 0x21, 8 }, { 0xa, 10 }, { 0x1d, 12 },
  { 0x18, 12 }, { 0x13, 12 }, { 0x10, 12 }, { 0x1a, 13 },
@@ -98,7 +98,7 @@ static const UINT16 mpeg1_vlc[113][2] = {
  { 0x2, 2 }, /* EOB */
 };
 
-static const UINT16 mpeg2_vlc[113][2] = {
+static const uint16_t mpeg2_vlc[113][2] = {
   {0x02, 2}, {0x06, 3}, {0x07, 4}, {0x1c, 5},
   {0x1d, 5}, {0x05, 6}, {0x04, 6}, {0x7b, 7},
   {0x7c, 7}, {0x23, 8}, {0x22, 8}, {0xfa, 8},
@@ -131,7 +131,7 @@ static const UINT16 mpeg2_vlc[113][2] = {
   {0x06,4}, /* EOB */
 };
 
-static const INT8 mpeg1_level[111] = {
+static const int8_t mpeg1_level[111] = {
   1,  2,  3,  4,  5,  6,  7,  8,
   9, 10, 11, 12, 13, 14, 15, 16,
  17, 18, 19, 20, 21, 22, 23, 24,
@@ -148,7 +148,7 @@ static const INT8 mpeg1_level[111] = {
   1,  1,  1,  1,  1,  1,  1,
 };
 
-static const INT8 mpeg1_run[111] = {
+static const int8_t mpeg1_run[111] = {
   0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,
@@ -165,8 +165,8 @@ static const INT8 mpeg1_run[111] = {
  25, 26, 27, 28, 29, 30, 31,
 };
 
-static UINT8 mpeg1_index_run[2][64];
-static INT8 mpeg1_max_level[2][64];
+static uint8_t mpeg1_index_run[2][64];
+static int8_t mpeg1_max_level[2][64];
 
 static RLTable rl_mpeg1 = {
     111,
@@ -184,7 +184,7 @@ static RLTable rl_mpeg2 = {
     mpeg1_level,
 };
 
-static const UINT8 mbAddrIncrTable[35][2] = {
+static const uint8_t mbAddrIncrTable[35][2] = {
     {0x1, 1},
     {0x3, 3},
     {0x2, 3},
@@ -222,7 +222,7 @@ static const UINT8 mbAddrIncrTable[35][2] = {
     {0xf, 11}, /* stuffing */
 };
 
-static const UINT8 mbPatTable[63][2] = {
+static const uint8_t mbPatTable[63][2] = {
     {0xb, 5},
     {0x9, 5},
     {0xd, 6},
@@ -294,7 +294,7 @@ static const UINT8 mbPatTable[63][2] = {
 #define MB_FOR   0x08
 #define MB_QUANT 0x10  
 
-static const UINT8 table_mb_ptype[32][2] = {
+static const uint8_t table_mb_ptype[32][2] = {
     { 0, 0 }, // 0x00
     { 3, 5 }, // 0x01 MB_INTRA
     { 1, 2 }, // 0x02 MB_PAT
@@ -329,7 +329,7 @@ static const UINT8 table_mb_ptype[32][2] = {
     { 0, 0 }, // 0x1F
 };
 
-static const UINT8 table_mb_btype[32][2] = {
+static const uint8_t table_mb_btype[32][2] = {
     { 0, 0 }, // 0x00
     { 3, 5 }, // 0x01 MB_INTRA
     { 0, 0 }, // 0x02
@@ -364,7 +364,7 @@ static const UINT8 table_mb_btype[32][2] = {
     { 0, 0 }, // 0x1F
 };
 
-static const UINT8 mbMotionVectorTable[17][2] = {
+static const uint8_t mbMotionVectorTable[17][2] = {
 { 0x1, 1 },
 { 0x1, 2 },
 { 0x1, 3 },
@@ -396,14 +396,14 @@ static const int frame_rate_tab[9] = {
     (int)(60 * FRAME_RATE_BASE), 
 };
 
-static const UINT8 non_linear_qscale[32] = {
+static const uint8_t non_linear_qscale[32] = {
     0, 1, 2, 3, 4, 5, 6, 7,
     8,10,12,14,16,18,20,22,
     24,28,32,36,40,44,48,52,
     56,64,72,80,88,96,104,112,
 };
 
-UINT8 ff_mpeg1_dc_scale_table[128]={ // MN: mpeg2 really can have such large qscales?
+uint8_t ff_mpeg1_dc_scale_table[128]={ // MN: mpeg2 really can have such large qscales?
 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,

libavcodec/mpeg4data.h

@@ -34,19 +34,19 @@
 #define VOP_STARTCODE        0x1B6
 
 /* dc encoding for mpeg4 */
-const UINT8 DCtab_lum[13][2] =
+const uint8_t DCtab_lum[13][2] =
 {
     {3,3}, {3,2}, {2,2}, {2,3}, {1,3}, {1,4}, {1,5}, {1,6}, {1,7},
     {1,8}, {1,9}, {1,10}, {1,11},
 }; 
 
-const UINT8 DCtab_chrom[13][2] =
+const uint8_t DCtab_chrom[13][2] =
 {
     {3,2}, {2,2}, {1,2}, {1,3}, {1,4}, {1,5}, {1,6}, {1,7}, {1,8},
     {1,9}, {1,10}, {1,11}, {1,12},
 }; 
 
-const UINT16 intra_vlc[103][2] = {
+const uint16_t intra_vlc[103][2] = {
 { 0x2, 2 },
 { 0x6, 3 },{ 0xf, 4 },{ 0xd, 5 },{ 0xc, 5 },
 { 0x15, 6 },{ 0x13, 6 },{ 0x12, 6 },{ 0x17, 7 },
@@ -76,7 +76,7 @@ const UINT16 intra_vlc[103][2] = {
 { 0x5f, 12 },{ 0x3, 7 },
 };
 
-const INT8 intra_level[102] = {
+const int8_t intra_level[102] = {
   1,  2,  3,  4,  5,  6,  7,  8,
   9, 10, 11, 12, 13, 14, 15, 16,
  17, 18, 19, 20, 21, 22, 23, 24,
@@ -92,7 +92,7 @@ const INT8 intra_level[102] = {
   1,  1,  1,  1,  1,  1,
 };
 
-const INT8 intra_run[102] = {
+const int8_t intra_run[102] = {
   0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,
@@ -116,17 +116,17 @@ static RLTable rl_intra = {
     intra_level,
 };
 
-static const UINT16 sprite_trajectory_tab[15][2] = {
+static const uint16_t sprite_trajectory_tab[15][2] = {
  {0x00, 2}, {0x02, 3},  {0x03, 3},  {0x04, 3}, {0x05, 3}, {0x06, 3},
  {0x0E, 4}, {0x1E, 5},  {0x3E, 6},  {0x7E, 7}, {0xFE, 8}, 
  {0x1FE, 9},{0x3FE, 10},{0x7FE, 11},{0xFFE, 12},
 };
 
-static const UINT8 mb_type_b_tab[4][2] = {
+static const uint8_t mb_type_b_tab[4][2] = {
  {1, 1}, {1, 2}, {1, 3}, {1, 4},
 };
 
-static const UINT16 pixel_aspect[16][2]={
+static const uint16_t pixel_aspect[16][2]={
  {0, 0},
  {1, 1},
  {12, 11},
@@ -146,7 +146,7 @@ static const UINT16 pixel_aspect[16][2]={
 };
 
 /* these matrixes will be permuted for the idct */
-const INT16 ff_mpeg4_default_intra_matrix[64] = {
+const int16_t ff_mpeg4_default_intra_matrix[64] = {
   8, 17, 18, 19, 21, 23, 25, 27,
  17, 18, 19, 21, 23, 25, 27, 28,
  20, 21, 22, 23, 24, 26, 28, 30,
@@ -157,7 +157,7 @@ const INT16 ff_mpeg4_default_intra_matrix[64] = {
  27, 28, 30, 32, 35, 38, 41, 45, 
 };
 
-const INT16 ff_mpeg4_default_non_intra_matrix[64] = {
+const int16_t ff_mpeg4_default_non_intra_matrix[64] = {
  16, 17, 18, 19, 20, 21, 22, 23,
  17, 18, 19, 20, 21, 22, 23, 24,
  18, 19, 20, 21, 22, 23, 24, 25,
@@ -168,15 +168,15 @@ const INT16 ff_mpeg4_default_non_intra_matrix[64] = {
  23, 24, 25, 27, 28, 30, 31, 33,
 };
 
-UINT8 ff_mpeg4_y_dc_scale_table[32]={
+uint8_t ff_mpeg4_y_dc_scale_table[32]={
 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
     0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
 };
-UINT8 ff_mpeg4_c_dc_scale_table[32]={
+uint8_t ff_mpeg4_c_dc_scale_table[32]={
 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
     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
 };
 
-const UINT16 ff_mpeg4_resync_prefix[8]={
+const uint16_t ff_mpeg4_resync_prefix[8]={
     0x7F00, 0x7E00, 0x7C00, 0x7800, 0x7000, 0x6000, 0x4000, 0x0000
 };

libavcodec/mpegaudio.c

@@ -23,7 +23,7 @@
    quantization stage) */
 #define FRAC_BITS 15
 #define WFRAC_BITS  14
-#define MUL(a,b) (((INT64)(a) * (INT64)(b)) >> FRAC_BITS)
+#define MUL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS)
 #define FIX(a)   ((int)((a) * (1 << FRAC_BITS)))
 
 #define SAMPLES_BUF_SIZE 4096
@@ -36,7 +36,7 @@ typedef struct MpegAudioContext {
     int bitrate_index; /* bit rate */
     int freq_index;
     int frame_size; /* frame size, in bits, without padding */
-    INT64 nb_samples; /* total number of samples encoded */
+    int64_t nb_samples; /* total number of samples encoded */
     /* padding computation */
     int frame_frac, frame_frac_incr, do_padding;
     short samples_buf[MPA_MAX_CHANNELS][SAMPLES_BUF_SIZE]; /* buffer for filter */

libavcodec/mpegaudio.h

@@ -17,11 +17,11 @@
 
 int l2_select_table(int bitrate, int nb_channels, int freq, int lsf);
 
-extern const UINT16 mpa_bitrate_tab[2][3][15];
-extern const UINT16 mpa_freq_tab[3];
+extern const uint16_t mpa_bitrate_tab[2][3][15];
+extern const uint16_t mpa_freq_tab[3];
 extern const unsigned char *alloc_tables[5];
 extern const double enwindow[512];
 extern const int sblimit_table[5];
 extern const int quant_steps[17];
 extern const int quant_bits[17];
-extern const INT32 mpa_enwindow[257];
+extern const int32_t mpa_enwindow[257];

libavcodec/mpegaudiodec.c

@@ -42,17 +42,17 @@
 
 #define FRAC_ONE    (1 << FRAC_BITS)
 
-#define MULL(a,b) (((INT64)(a) * (INT64)(b)) >> FRAC_BITS)
-#define MUL64(a,b) ((INT64)(a) * (INT64)(b))
+#define MULL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS)
+#define MUL64(a,b) ((int64_t)(a) * (int64_t)(b))
 #define FIX(a)   ((int)((a) * FRAC_ONE))
 /* WARNING: only correct for posititive numbers */
 #define FIXR(a)   ((int)((a) * FRAC_ONE + 0.5))
 #define FRAC_RND(a) (((a) + (FRAC_ONE/2)) >> FRAC_BITS)
 
 #if FRAC_BITS <= 15
-typedef INT16 MPA_INT;
+typedef int16_t MPA_INT;
 #else
-typedef INT32 MPA_INT;
+typedef int32_t MPA_INT;
 #endif
 
 /****************/
@@ -61,14 +61,14 @@ typedef INT32 MPA_INT;
 #define BACKSTEP_SIZE 512
 
 typedef struct MPADecodeContext {
-    UINT8 inbuf1[2][MPA_MAX_CODED_FRAME_SIZE + BACKSTEP_SIZE];	/* input buffer */
+    uint8_t inbuf1[2][MPA_MAX_CODED_FRAME_SIZE + BACKSTEP_SIZE];	/* input buffer */
     int inbuf_index;
-    UINT8 *inbuf_ptr, *inbuf;
+    uint8_t *inbuf_ptr, *inbuf;
     int frame_size;
     int free_format_frame_size; /* frame size in case of free format
                                    (zero if currently unknown) */
     /* next header (used in free format parsing) */
-    UINT32 free_format_next_header; 
+    uint32_t free_format_next_header; 
     int error_protection;
     int layer;
     int sample_rate;
@@ -82,8 +82,8 @@ typedef struct MPADecodeContext {
     int lsf;
     MPA_INT synth_buf[MPA_MAX_CHANNELS][512 * 2];
     int synth_buf_offset[MPA_MAX_CHANNELS];
-    INT32 sb_samples[MPA_MAX_CHANNELS][36][SBLIMIT];
-    INT32 mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
+    int32_t sb_samples[MPA_MAX_CHANNELS][36][SBLIMIT];
+    int32_t mdct_buf[MPA_MAX_CHANNELS][SBLIMIT * 18]; /* previous samples, for layer 3 MDCT */
 #ifdef DEBUG
     int frame_count;
 #endif
@@ -91,22 +91,22 @@ typedef struct MPADecodeContext {
 
 /* layer 3 "granule" */
 typedef struct GranuleDef {
-    UINT8 scfsi;
+    uint8_t scfsi;
     int part2_3_length;
     int big_values;
     int global_gain;
     int scalefac_compress;
-    UINT8 block_type;
-    UINT8 switch_point;
+    uint8_t block_type;
+    uint8_t switch_point;
     int table_select[3];
     int subblock_gain[3];
-    UINT8 scalefac_scale;
-    UINT8 count1table_select;
+    uint8_t scalefac_scale;
+    uint8_t count1table_select;
     int region_size[3]; /* number of huffman codes in each region */
     int preflag;
     int short_start, long_end; /* long/short band indexes */
-    UINT8 scale_factors[40];
-    INT32 sb_hybrid[SBLIMIT * 18]; /* 576 samples */
+    uint8_t scale_factors[40];
+    int32_t sb_hybrid[SBLIMIT * 18]; /* 576 samples */
 } GranuleDef;
 
 #define MODE_EXT_MS_STEREO 2
@@ -115,49 +115,49 @@ typedef struct GranuleDef {
 /* layer 3 huffman tables */
 typedef struct HuffTable {
     int xsize;
-    const UINT8 *bits;
-    const UINT16 *codes;
+    const uint8_t *bits;
+    const uint16_t *codes;
 } HuffTable;
 
 #include "mpegaudiodectab.h"
 
 /* vlc structure for decoding layer 3 huffman tables */
 static VLC huff_vlc[16]; 
-static UINT8 *huff_code_table[16];
+static uint8_t *huff_code_table[16];
 static VLC huff_quad_vlc[2];
 /* computed from band_size_long */
-static UINT16 band_index_long[9][23];
+static uint16_t band_index_long[9][23];
 /* XXX: free when all decoders are closed */
 #define TABLE_4_3_SIZE (8191 + 16)
-static INT8  *table_4_3_exp;
+static int8_t  *table_4_3_exp;
 #if FRAC_BITS <= 15
-static UINT16 *table_4_3_value;
+static uint16_t *table_4_3_value;
 #else
-static UINT32 *table_4_3_value;
+static uint32_t *table_4_3_value;
 #endif
 /* intensity stereo coef table */
-static INT32 is_table[2][16];
-static INT32 is_table_lsf[2][2][16];
-static INT32 csa_table[8][2];
-static INT32 mdct_win[8][36];
+static int32_t is_table[2][16];
+static int32_t is_table_lsf[2][2][16];
+static int32_t csa_table[8][2];
+static int32_t mdct_win[8][36];
 
 /* lower 2 bits: modulo 3, higher bits: shift */
-static UINT16 scale_factor_modshift[64];
+static uint16_t scale_factor_modshift[64];
 /* [i][j]:  2^(-j/3) * FRAC_ONE * 2^(i+2) / (2^(i+2) - 1) */
-static INT32 scale_factor_mult[15][3];
+static int32_t scale_factor_mult[15][3];
 /* mult table for layer 2 group quantization */
 
 #define SCALE_GEN(v) \
 { FIXR(1.0 * (v)), FIXR(0.7937005259 * (v)), FIXR(0.6299605249 * (v)) }
 
-static INT32 scale_factor_mult2[3][3] = {
+static int32_t scale_factor_mult2[3][3] = {
     SCALE_GEN(4.0 / 3.0), /* 3 steps */
     SCALE_GEN(4.0 / 5.0), /* 5 steps */
     SCALE_GEN(4.0 / 9.0), /* 9 steps */
 };
 
 /* 2^(n/4) */
-static UINT32 scale_factor_mult3[4] = {
+static uint32_t scale_factor_mult3[4] = {
     FIXR(1.0),
     FIXR(1.18920711500272106671),
     FIXR(1.41421356237309504880),
@@ -171,7 +171,7 @@ static MPA_INT window[512];
 static inline int l1_unscale(int n, int mant, int scale_factor)
 {
     int shift, mod;
-    INT64 val;
+    int64_t val;
 
     shift = scale_factor_modshift[scale_factor];
     mod = shift & 3;
@@ -203,7 +203,7 @@ static inline int l3_unscale(int value, int exponent)
 #if FRAC_BITS <= 15    
     unsigned int m;
 #else
-    UINT64 m;
+    uint64_t m;
 #endif
     int e;
 
@@ -221,7 +221,7 @@ static inline int l3_unscale(int value, int exponent)
     return m;
 #else
     m = MUL64(m, scale_factor_mult3[exponent & 3]);
-    m = (m + (UINT64_C(1) << (e-1))) >> e;
+    m = (m + (uint64_t_C(1) << (e-1))) >> e;
     return m;
 #endif
 }
@@ -232,7 +232,7 @@ static inline int l3_unscale(int value, int exponent)
 #define POW_FRAC_BITS 24
 #define POW_FRAC_ONE    (1 << POW_FRAC_BITS)
 #define POW_FIX(a)   ((int)((a) * POW_FRAC_ONE))
-#define POW_MULL(a,b) (((INT64)(a) * (INT64)(b)) >> POW_FRAC_BITS)
+#define POW_MULL(a,b) (((int64_t)(a) * (int64_t)(b)) >> POW_FRAC_BITS)
 
 static int dev_4_3_coefs[DEV_ORDER];
 
@@ -318,7 +318,7 @@ static int decode_init(AVCodecContext * avctx)
         for(i=0;i<15;i++) {
             int n, norm;
             n = i + 2;
-            norm = ((INT64_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
+            norm = ((int64_t_C(1) << n) * FRAC_ONE) / ((1 << n) - 1);
             scale_factor_mult[i][0] = MULL(FIXR(1.0 * 2.0), norm);
             scale_factor_mult[i][1] = MULL(FIXR(0.7937005259 * 2.0), norm);
             scale_factor_mult[i][2] = MULL(FIXR(0.6299605249 * 2.0), norm);
@@ -350,7 +350,7 @@ static int decode_init(AVCodecContext * avctx)
             const HuffTable *h = &mpa_huff_tables[i];
 	    int xsize, x, y;
             unsigned int n;
-            UINT8 *code_table;
+            uint8_t *code_table;
 
             xsize = h->xsize;
             n = xsize * xsize;
@@ -577,7 +577,7 @@ static int decode_init(AVCodecContext * avctx)
 #define ADD(a, b) tab[a] += tab[b]
 
 /* DCT32 without 1/sqrt(2) coef zero scaling. */
-static void dct32(INT32 *out, INT32 *tab)
+static void dct32(int32_t *out, int32_t *tab)
 {
     int tmp0, tmp1;
 
@@ -760,7 +760,7 @@ static void dct32(INT32 *out, INT32 *tab)
 #define OUT_SAMPLE(sum)\
 {\
     int sum1;\
-    sum1 = (int)((sum + (INT64_C(1) << (OUT_SHIFT - 1))) >> OUT_SHIFT);\
+    sum1 = (int)((sum + (int64_t_C(1) << (OUT_SHIFT - 1))) >> OUT_SHIFT);\
     if (sum1 < -32768)\
         sum1 = -32768;\
     else if (sum1 > 32767)\
@@ -787,17 +787,17 @@ static void dct32(INT32 *out, INT32 *tab)
    32 samples. */
 /* XXX: optimize by avoiding ring buffer usage */
 static void synth_filter(MPADecodeContext *s1,
-                         int ch, INT16 *samples, int incr, 
-                         INT32 sb_samples[SBLIMIT])
+                         int ch, int16_t *samples, int incr, 
+                         int32_t sb_samples[SBLIMIT])
 {
-    INT32 tmp[32];
+    int32_t tmp[32];
     register MPA_INT *synth_buf, *p;
     register MPA_INT *w;
     int j, offset, v;
 #if FRAC_BITS <= 15
     int sum;
 #else
-    INT64 sum;
+    int64_t sum;
 #endif
 
     dct32(tmp, sb_samples);
@@ -863,7 +863,7 @@ static void synth_filter(MPADecodeContext *s1,
 static void imdct12(int *out, int *in)
 {
     int tmp;
-    INT64 in1_3, in1_9, in4_3, in4_9;
+    int64_t in1_3, in1_9, in4_3, in4_9;
 
     in1_3 = MUL64(in[1], C3);
     in1_9 = MUL64(in[1], C9);
@@ -955,7 +955,7 @@ static void imdct36(int *out, int *in)
 {
     int i, j, t0, t1, t2, t3, s0, s1, s2, s3;
     int tmp[18], *tmp1, *in1;
-    INT64 in3_3, in6_6;
+    int64_t in3_3, in6_6;
 
     for(i=17;i>=1;i--)
         in[i] += in[i-1];
@@ -1030,7 +1030,7 @@ static void imdct36(int *out, int *in)
 }
 
 /* fast header check for resync */
-static int check_header(UINT32 header)
+static int check_header(uint32_t header)
 {
     /* header */
     if ((header & 0xffe00000) != 0xffe00000)
@@ -1054,7 +1054,7 @@ static int check_header(UINT32 header)
 /* header decoding. MUST check the header before because no
    consistency check is done there. Return 1 if free format found and
    that the frame size must be computed externally */
-static int decode_header(MPADecodeContext *s, UINT32 header)
+static int decode_header(MPADecodeContext *s, uint32_t header)
 {
     int sample_rate, frame_size, mpeg25, padding;
     int sample_rate_index, bitrate_index;
@@ -1155,8 +1155,8 @@ static int decode_header(MPADecodeContext *s, UINT32 header)
 static int mp_decode_layer1(MPADecodeContext *s)
 {
     int bound, i, v, n, ch, j, mant;
-    UINT8 allocation[MPA_MAX_CHANNELS][SBLIMIT];
-    UINT8 scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
+    uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];
+    uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];
 
     if (s->mode == MPA_JSTEREO) 
         bound = (s->mode_ext + 1) * 4;
@@ -1451,7 +1451,7 @@ static int mp_decode_layer2(MPADecodeContext *s)
  */
 static void seek_to_maindata(MPADecodeContext *s, unsigned int backstep)
 {
-    UINT8 *ptr;
+    uint8_t *ptr;
 
     /* compute current position in stream */
     ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
@@ -1491,11 +1491,11 @@ static inline void lsf_sf_expand(int *slen,
 
 static void exponents_from_scale_factors(MPADecodeContext *s, 
                                          GranuleDef *g,
-                                         INT16 *exponents)
+                                         int16_t *exponents)
 {
-    const UINT8 *bstab, *pretab;
+    const uint8_t *bstab, *pretab;
     int len, i, j, k, l, v0, shift, gain, gains[3];
-    INT16 *exp_ptr;
+    int16_t *exp_ptr;
 
     exp_ptr = exponents;
     gain = g->global_gain - 210;
@@ -1537,13 +1537,13 @@ static inline int get_bitsz(GetBitContext *s, int n)
 }
 
 static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
-                          INT16 *exponents, int end_pos)
+                          int16_t *exponents, int end_pos)
 {
     int s_index;
     int linbits, code, x, y, l, v, i, j, k, pos;
     GetBitContext last_gb;
     VLC *vlc;
-    UINT8 *code_table;
+    uint8_t *code_table;
 
     /* low frequencies (called big values) */
     s_index = 0;
@@ -1642,8 +1642,8 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
 static void reorder_block(MPADecodeContext *s, GranuleDef *g)
 {
     int i, j, k, len;
-    INT32 *ptr, *dst, *ptr1;
-    INT32 tmp[576];
+    int32_t *ptr, *dst, *ptr1;
+    int32_t tmp[576];
 
     if (g->block_type != 2)
         return;
@@ -1668,7 +1668,7 @@ static void reorder_block(MPADecodeContext *s, GranuleDef *g)
                 dst += 3;
             }
         }
-        memcpy(ptr1, tmp, len * 3 * sizeof(INT32));
+        memcpy(ptr1, tmp, len * 3 * sizeof(int32_t));
     }
 }
 
@@ -1678,10 +1678,10 @@ static void compute_stereo(MPADecodeContext *s,
                            GranuleDef *g0, GranuleDef *g1)
 {
     int i, j, k, l;
-    INT32 v1, v2;
+    int32_t v1, v2;
     int sf_max, tmp0, tmp1, sf, len, non_zero_found;
-    INT32 (*is_tab)[16];
-    INT32 *tab0, *tab1;
+    int32_t (*is_tab)[16];
+    int32_t *tab0, *tab1;
     int non_zero_found_short[3];
 
     /* intensity stereo */
@@ -1804,7 +1804,7 @@ static void compute_stereo(MPADecodeContext *s,
 static void compute_antialias(MPADecodeContext *s,
                               GranuleDef *g)
 {
-    INT32 *ptr, *p0, *p1, *csa;
+    int32_t *ptr, *p0, *p1, *csa;
     int n, tmp0, tmp1, i, j;
 
     /* we antialias only "long" bands */
@@ -1837,13 +1837,13 @@ static void compute_antialias(MPADecodeContext *s,
 
 static void compute_imdct(MPADecodeContext *s,
                           GranuleDef *g, 
-                          INT32 *sb_samples,
-                          INT32 *mdct_buf)
+                          int32_t *sb_samples,
+                          int32_t *mdct_buf)
 {
-    INT32 *ptr, *win, *win1, *buf, *buf2, *out_ptr, *ptr1;
-    INT32 in[6];
-    INT32 out[36];
-    INT32 out2[12];
+    int32_t *ptr, *win, *win1, *buf, *buf2, *out_ptr, *ptr1;
+    int32_t in[6];
+    int32_t out[36];
+    int32_t out2[12];
     int i, j, k, mdct_long_end, v, sblimit;
 
     /* find last non zero block */
@@ -1936,12 +1936,12 @@ static void compute_imdct(MPADecodeContext *s,
 }
 
 #if defined(DEBUG)
-void sample_dump(int fnum, INT32 *tab, int n)
+void sample_dump(int fnum, int32_t *tab, int n)
 {
     static FILE *files[16], *f;
     char buf[512];
     int i;
-    INT32 v;
+    int32_t v;
     
     f = files[fnum];
     if (!f) {
@@ -1972,7 +1972,7 @@ void sample_dump(int fnum, INT32 *tab, int n)
     for(i=0;i<n;i++) {
         /* normalize to 23 frac bits */
         v = tab[i] << (23 - FRAC_BITS);
-        fwrite(&v, 1, sizeof(INT32), f);
+        fwrite(&v, 1, sizeof(int32_t), f);
     }
 }
 #endif
@@ -1984,7 +1984,7 @@ static int mp_decode_layer3(MPADecodeContext *s)
     int nb_granules, main_data_begin, private_bits;
     int gr, ch, blocksplit_flag, i, j, k, n, bits_pos, bits_left;
     GranuleDef granules[2][2], *g;
-    INT16 exponents[576];
+    int16_t exponents[576];
 
     /* read side info */
     if (s->lsf) {
@@ -2124,7 +2124,7 @@ static int mp_decode_layer3(MPADecodeContext *s)
             bits_pos = get_bits_count(&s->gb);
             
             if (!s->lsf) {
-                UINT8 *sc;
+                uint8_t *sc;
                 int slen, slen1, slen2;
 
                 /* MPEG1 scale factors */
@@ -2328,11 +2328,11 @@ static int mp_decode_frame(MPADecodeContext *s,
 
 static int decode_frame(AVCodecContext * avctx,
 			void *data, int *data_size,
-			UINT8 * buf, int buf_size)
+			uint8_t * buf, int buf_size)
 {
     MPADecodeContext *s = avctx->priv_data;
-    UINT32 header;
-    UINT8 *buf_ptr;
+    uint32_t header;
+    uint8_t *buf_ptr;
     int len, out_size;
     short *out_samples = data;
 
@@ -2399,8 +2399,8 @@ static int decode_frame(AVCodecContext * avctx,
 		memcpy(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 		s->inbuf_ptr--;
             } else {
-                UINT8 *p, *pend;
-                UINT32 header1;
+                uint8_t *p, *pend;
+                uint32_t header1;
                 int padding;
 
                 memcpy(s->inbuf_ptr, buf_ptr, len);

libavcodec/mpegaudiodectab.h

@@ -1,5 +1,5 @@
 
-const UINT16 mpa_bitrate_tab[2][3][15] = {
+const uint16_t mpa_bitrate_tab[2][3][15] = {
     { {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },
       {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 },
       {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 } },
@@ -9,11 +9,11 @@ const UINT16 mpa_bitrate_tab[2][3][15] = {
     }
 };
 
-const UINT16 mpa_freq_tab[3] = { 44100, 48000, 32000 };
+const uint16_t mpa_freq_tab[3] = { 44100, 48000, 32000 };
 
 /*******************************************************/
 /* half mpeg encoding window (full precision) */
-const INT32 mpa_enwindow[257] = {
+const int32_t mpa_enwindow[257] = {
      0,    -1,    -1,    -1,    -1,    -1,    -1,    -2,
     -2,    -2,    -2,    -3,    -3,    -4,    -4,    -5,
     -5,    -6,    -7,    -7,    -8,    -9,   -10,   -11,
@@ -200,13 +200,13 @@ const unsigned char *alloc_tables[5] =
 /* layer 3 tables */
 
 /* layer3 scale factor size */
-static const UINT8 slen_table[2][16] = {
+static const uint8_t slen_table[2][16] = {
     { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
     { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 },
 };
 
 /* number of lsf scale factors for a given size */
-static const UINT8 lsf_nsf_table[6][3][4] = {
+static const uint8_t lsf_nsf_table[6][3][4] = {
     { {  6,  5,  5, 5 }, {  9,  9,  9, 9 }, {  6,  9,  9, 9 } },
     { {  6,  5,  7, 3 }, {  9,  9, 12, 6 }, {  6,  9, 12, 6 } },
     { { 11, 10,  0, 0 }, { 18, 18,  0, 0 }, { 15, 18,  0, 0 } },
@@ -217,55 +217,55 @@ static const UINT8 lsf_nsf_table[6][3][4] = {
 
 /* mpegaudio layer 3 huffman tables */
 
-const UINT16 mpa_huffcodes_1[4] = {
+const uint16_t mpa_huffcodes_1[4] = {
  0x0001, 0x0001, 0x0001, 0x0000,
 };
 
-const UINT8 mpa_huffbits_1[4] = {
+const uint8_t mpa_huffbits_1[4] = {
   1,  3,  2,  3,
 };
 
-const UINT16 mpa_huffcodes_2[9] = {
+const uint16_t mpa_huffcodes_2[9] = {
  0x0001, 0x0002, 0x0001, 0x0003, 0x0001, 0x0001, 0x0003, 0x0002,
  0x0000,
 };
 
-const UINT8 mpa_huffbits_2[9] = {
+const uint8_t mpa_huffbits_2[9] = {
   1,  3,  6,  3,  3,  5,  5,  5,
   6,
 };
 
-const UINT16 mpa_huffcodes_3[9] = {
+const uint16_t mpa_huffcodes_3[9] = {
  0x0003, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0003, 0x0002,
  0x0000,
 };
 
-const UINT8 mpa_huffbits_3[9] = {
+const uint8_t mpa_huffbits_3[9] = {
   2,  2,  6,  3,  2,  5,  5,  5,
   6,
 };
 
-const UINT16 mpa_huffcodes_5[16] = {
+const uint16_t mpa_huffcodes_5[16] = {
  0x0001, 0x0002, 0x0006, 0x0005, 0x0003, 0x0001, 0x0004, 0x0004,
  0x0007, 0x0005, 0x0007, 0x0001, 0x0006, 0x0001, 0x0001, 0x0000,
 };
 
-const UINT8 mpa_huffbits_5[16] = {
+const uint8_t mpa_huffbits_5[16] = {
   1,  3,  6,  7,  3,  3,  6,  7,
   6,  6,  7,  8,  7,  6,  7,  8,
 };
 
-const UINT16 mpa_huffcodes_6[16] = {
+const uint16_t mpa_huffcodes_6[16] = {
  0x0007, 0x0003, 0x0005, 0x0001, 0x0006, 0x0002, 0x0003, 0x0002,
  0x0005, 0x0004, 0x0004, 0x0001, 0x0003, 0x0003, 0x0002, 0x0000,
 };
 
-const UINT8 mpa_huffbits_6[16] = {
+const uint8_t mpa_huffbits_6[16] = {
   3,  3,  5,  7,  3,  2,  4,  5,
   4,  4,  5,  6,  6,  5,  6,  7,
 };
 
-const UINT16 mpa_huffcodes_7[36] = {
+const uint16_t mpa_huffcodes_7[36] = {
  0x0001, 0x0002, 0x000a, 0x0013, 0x0010, 0x000a, 0x0003, 0x0003,
  0x0007, 0x000a, 0x0005, 0x0003, 0x000b, 0x0004, 0x000d, 0x0011,
  0x0008, 0x0004, 0x000c, 0x000b, 0x0012, 0x000f, 0x000b, 0x0002,
@@ -273,7 +273,7 @@ const UINT16 mpa_huffcodes_7[36] = {
  0x0005, 0x0003, 0x0002, 0x0000,
 };
 
-const UINT8 mpa_huffbits_7[36] = {
+const uint8_t mpa_huffbits_7[36] = {
   1,  3,  6,  8,  8,  9,  3,  4,
   6,  7,  7,  8,  6,  5,  7,  8,
   8,  9,  7,  7,  8,  9,  9,  9,
@@ -281,7 +281,7 @@ const UINT8 mpa_huffbits_7[36] = {
   9, 10, 10, 10,
 };
 
-const UINT16 mpa_huffcodes_8[36] = {
+const uint16_t mpa_huffcodes_8[36] = {
  0x0003, 0x0004, 0x0006, 0x0012, 0x000c, 0x0005, 0x0005, 0x0001,
  0x0002, 0x0010, 0x0009, 0x0003, 0x0007, 0x0003, 0x0005, 0x000e,
  0x0007, 0x0003, 0x0013, 0x0011, 0x000f, 0x000d, 0x000a, 0x0004,
@@ -289,7 +289,7 @@ const UINT16 mpa_huffcodes_8[36] = {
  0x0004, 0x0001, 0x0001, 0x0000,
 };
 
-const UINT8 mpa_huffbits_8[36] = {
+const uint8_t mpa_huffbits_8[36] = {
   2,  3,  6,  8,  8,  9,  3,  2,
   4,  8,  8,  8,  6,  4,  6,  8,
   8,  9,  8,  8,  8,  9,  9, 10,
@@ -297,7 +297,7 @@ const UINT8 mpa_huffbits_8[36] = {
   9,  9, 11, 11,
 };
 
-const UINT16 mpa_huffcodes_9[36] = {
+const uint16_t mpa_huffcodes_9[36] = {
  0x0007, 0x0005, 0x0009, 0x000e, 0x000f, 0x0007, 0x0006, 0x0004,
  0x0005, 0x0005, 0x0006, 0x0007, 0x0007, 0x0006, 0x0008, 0x0008,
  0x0008, 0x0005, 0x000f, 0x0006, 0x0009, 0x000a, 0x0005, 0x0001,
@@ -305,7 +305,7 @@ const UINT16 mpa_huffcodes_9[36] = {
  0x0006, 0x0002, 0x0006, 0x0000,
 };
 
-const UINT8 mpa_huffbits_9[36] = {
+const uint8_t mpa_huffbits_9[36] = {
   3,  3,  5,  6,  8,  9,  3,  3,
   4,  5,  6,  8,  4,  4,  5,  6,
   7,  8,  6,  5,  6,  7,  7,  8,
@@ -313,7 +313,7 @@ const UINT8 mpa_huffbits_9[36] = {
   8,  8,  9,  9,
 };
 
-const UINT16 mpa_huffcodes_10[64] = {
+const uint16_t mpa_huffcodes_10[64] = {
  0x0001, 0x0002, 0x000a, 0x0017, 0x0023, 0x001e, 0x000c, 0x0011,
  0x0003, 0x0003, 0x0008, 0x000c, 0x0012, 0x0015, 0x000c, 0x0007,
  0x000b, 0x0009, 0x000f, 0x0015, 0x0020, 0x0028, 0x0013, 0x0006,
@@ -324,7 +324,7 @@ const UINT16 mpa_huffcodes_10[64] = {
  0x0009, 0x0008, 0x0007, 0x0008, 0x0004, 0x0004, 0x0002, 0x0000,
 };
 
-const UINT8 mpa_huffbits_10[64] = {
+const uint8_t mpa_huffbits_10[64] = {
   1,  3,  6,  8,  9,  9,  9, 10,
   3,  4,  6,  7,  8,  9,  8,  8,
   6,  6,  7,  8,  9, 10,  9,  9,
@@ -335,7 +335,7 @@ const UINT8 mpa_huffbits_10[64] = {
   9,  8,  9, 10, 10, 11, 11, 11,
 };
 
-const UINT16 mpa_huffcodes_11[64] = {
+const uint16_t mpa_huffcodes_11[64] = {
  0x0003, 0x0004, 0x000a, 0x0018, 0x0022, 0x0021, 0x0015, 0x000f,
  0x0005, 0x0003, 0x0004, 0x000a, 0x0020, 0x0011, 0x000b, 0x000a,
  0x000b, 0x0007, 0x000d, 0x0012, 0x001e, 0x001f, 0x0014, 0x0005,
@@ -346,7 +346,7 @@ const UINT16 mpa_huffcodes_11[64] = {
  0x000b, 0x0004, 0x0006, 0x0006, 0x0006, 0x0003, 0x0002, 0x0000,
 };
 
-const UINT8 mpa_huffbits_11[64] = {
+const uint8_t mpa_huffbits_11[64] = {
   2,  3,  5,  7,  8,  9,  8,  9,
   3,  3,  4,  6,  8,  8,  7,  8,
   5,  5,  6,  7,  8,  9,  8,  8,
@@ -357,7 +357,7 @@ const UINT8 mpa_huffbits_11[64] = {
   8,  7,  8,  9, 10, 10, 10, 10,
 };
 
-const UINT16 mpa_huffcodes_12[64] = {
+const uint16_t mpa_huffcodes_12[64] = {
  0x0009, 0x0006, 0x0010, 0x0021, 0x0029, 0x0027, 0x0026, 0x001a,
  0x0007, 0x0005, 0x0006, 0x0009, 0x0017, 0x0010, 0x001a, 0x000b,
  0x0011, 0x0007, 0x000b, 0x000e, 0x0015, 0x001e, 0x000a, 0x0007,
@@ -368,7 +368,7 @@ const UINT16 mpa_huffcodes_12[64] = {
  0x001b, 0x000c, 0x0008, 0x000c, 0x0006, 0x0003, 0x0001, 0x0000,
 };
 
-const UINT8 mpa_huffbits_12[64] = {
+const uint8_t mpa_huffbits_12[64] = {
   4,  3,  5,  7,  8,  9,  9,  9,
   3,  3,  4,  5,  7,  7,  8,  8,
   5,  4,  5,  6,  7,  8,  7,  8,
@@ -379,7 +379,7 @@ const UINT8 mpa_huffbits_12[64] = {
   9,  8,  8,  9,  9,  9,  9, 10,
 };
 
-const UINT16 mpa_huffcodes_13[256] = {
+const uint16_t mpa_huffcodes_13[256] = {
  0x0001, 0x0005, 0x000e, 0x0015, 0x0022, 0x0033, 0x002e, 0x0047,
  0x002a, 0x0034, 0x0044, 0x0034, 0x0043, 0x002c, 0x002b, 0x0013,
  0x0003, 0x0004, 0x000c, 0x0013, 0x001f, 0x001a, 0x002c, 0x0021,
@@ -414,7 +414,7 @@ const UINT16 mpa_huffcodes_13[256] = {
  0x0011, 0x000c, 0x0010, 0x0008, 0x0001, 0x0001, 0x0000, 0x0001,
 };
 
-const UINT8 mpa_huffbits_13[256] = {
+const uint8_t mpa_huffbits_13[256] = {
   1,  4,  6,  7,  8,  9,  9, 10,
   9, 10, 11, 11, 12, 12, 13, 13,
   3,  4,  6,  7,  8,  8,  9,  9,
@@ -449,7 +449,7 @@ const UINT8 mpa_huffbits_13[256] = {
  15, 15, 16, 16, 19, 18, 19, 16,
 };
 
-const UINT16 mpa_huffcodes_15[256] = {
+const uint16_t mpa_huffcodes_15[256] = {
  0x0007, 0x000c, 0x0012, 0x0035, 0x002f, 0x004c, 0x007c, 0x006c,
  0x0059, 0x007b, 0x006c, 0x0077, 0x006b, 0x0051, 0x007a, 0x003f,
  0x000d, 0x0005, 0x0010, 0x001b, 0x002e, 0x0024, 0x003d, 0x0033,
@@ -484,7 +484,7 @@ const UINT16 mpa_huffcodes_15[256] = {
  0x0015, 0x0010, 0x000a, 0x0006, 0x0008, 0x0006, 0x0002, 0x0000,
 };
 
-const UINT8 mpa_huffbits_15[256] = {
+const uint8_t mpa_huffbits_15[256] = {
   3,  4,  5,  7,  7,  8,  9,  9,
   9, 10, 10, 11, 11, 11, 12, 13,
   4,  3,  5,  6,  7,  7,  8,  8,
@@ -519,7 +519,7 @@ const UINT8 mpa_huffbits_15[256] = {
  12, 12, 12, 12, 13, 13, 13, 13,
 };
 
-const UINT16 mpa_huffcodes_16[256] = {
+const uint16_t mpa_huffcodes_16[256] = {
  0x0001, 0x0005, 0x000e, 0x002c, 0x004a, 0x003f, 0x006e, 0x005d,
  0x00ac, 0x0095, 0x008a, 0x00f2, 0x00e1, 0x00c3, 0x0178, 0x0011,
  0x0003, 0x0004, 0x000c, 0x0014, 0x0023, 0x003e, 0x0035, 0x002f,
@@ -554,7 +554,7 @@ const UINT16 mpa_huffcodes_16[256] = {
  0x000d, 0x000c, 0x000a, 0x0007, 0x0005, 0x0003, 0x0001, 0x0003,
 };
 
-const UINT8 mpa_huffbits_16[256] = {
+const uint8_t mpa_huffbits_16[256] = {
   1,  4,  6,  8,  9,  9, 10, 10,
  11, 11, 11, 12, 12, 12, 13,  9,
   3,  4,  6,  7,  8,  9,  9,  9,
@@ -589,7 +589,7 @@ const UINT8 mpa_huffbits_16[256] = {
  11, 11, 11, 11, 11, 11, 11,  8,
 };
 
-const UINT16 mpa_huffcodes_24[256] = {
+const uint16_t mpa_huffcodes_24[256] = {
  0x000f, 0x000d, 0x002e, 0x0050, 0x0092, 0x0106, 0x00f8, 0x01b2,
  0x01aa, 0x029d, 0x028d, 0x0289, 0x026d, 0x0205, 0x0408, 0x0058,
  0x000e, 0x000c, 0x0015, 0x0026, 0x0047, 0x0082, 0x007a, 0x00d8,
@@ -624,7 +624,7 @@ const UINT16 mpa_huffcodes_24[256] = {
  0x0007, 0x0006, 0x0004, 0x0007, 0x0005, 0x0003, 0x0001, 0x0003,
 };
 
-const UINT8 mpa_huffbits_24[256] = {
+const uint8_t mpa_huffbits_24[256] = {
   4,  4,  6,  7,  8,  9,  9, 10,
  10, 11, 11, 11, 11, 11, 12,  9,
   4,  4,  5,  6,  7,  8,  8,  9,
@@ -678,7 +678,7 @@ const HuffTable mpa_huff_tables[16] = {
 { 16, mpa_huffbits_24, mpa_huffcodes_24 },
 };
 
-const UINT8 mpa_huff_data[32][2] = {
+const uint8_t mpa_huff_data[32][2] = {
 { 0, 0 },
 { 1, 0 },
 { 2, 0 },
@@ -715,18 +715,18 @@ const UINT8 mpa_huff_data[32][2] = {
 
 
 /* huffman tables for quadrules */
-static UINT8 mpa_quad_codes[2][16] = {
+static uint8_t mpa_quad_codes[2][16] = {
     {  1,  5,  4,  5,  6,  5,  4,  4, 7,  3,  6,  0,  7,  2,  3,  1, },
     { 15, 14, 13, 12, 11, 10,  9,  8, 7,  6,  5,  4,  3,  2,  1,  0, },
 };
 
-static UINT8 mpa_quad_bits[2][16] = {
+static uint8_t mpa_quad_bits[2][16] = {
     { 1, 4, 4, 5, 4, 6, 5, 6, 4, 5, 5, 6, 5, 6, 6, 6, },
     { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, },
 };
 
 /* band size tables */
-const UINT8 band_size_long[9][22] = {
+const uint8_t band_size_long[9][22] = {
 { 4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10,
   12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158, }, /* 44100 */
 { 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10,
@@ -747,7 +747,7 @@ const UINT8 band_size_long[9][22] = {
   40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2, }, /* 8000 */
 };
 
-const UINT8 band_size_short[9][13] = {
+const uint8_t band_size_short[9][13] = {
 { 4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56, }, /* 44100 */
 { 4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66, }, /* 48000 */
 { 4, 4, 4, 4, 6, 8, 12, 16, 20, 26, 34, 42, 12, }, /* 32000 */
@@ -759,7 +759,7 @@ const UINT8 band_size_short[9][13] = {
 { 8, 8, 8, 12, 16, 20, 24, 28, 36, 2, 2, 2, 26, }, /* 8000 */
 };
 
-const UINT8 mpa_pretab[2][22] = {
+const uint8_t mpa_pretab[2][22] = {
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 },
 };

libavcodec/mpegaudiotab.h

@@ -54,13 +54,13 @@ static const int bitinv32[32] = {
 };
 
 
-static INT16 filter_bank[512];
+static int16_t filter_bank[512];
 
 static int scale_factor_table[64];
 #ifdef USE_FLOATS
 static float scale_factor_inv_table[64];
 #else
-static INT8 scale_factor_shift[64];
+static int8_t scale_factor_shift[64];
 static unsigned short scale_factor_mult[64];
 #endif
 static unsigned char scale_diff_table[128];

libavcodec/mpegvideo.c

@@ -40,11 +40,11 @@ static void dct_unquantize_mpeg2_c(MpegEncContext *s,
                                    DCTELEM *block, int n, int qscale);
 static void dct_unquantize_h263_c(MpegEncContext *s, 
                                   DCTELEM *block, int n, int qscale);
-static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
+static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
 
-void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
+void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
 
 
 /* enable all paranoid tests for rounding, overflows, etc... */
@@ -85,13 +85,13 @@ static const uint8_t h263_chroma_roundtab[16] = {
     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
 };
 
-static UINT16 (*default_mv_penalty)[MAX_MV*2+1]=NULL;
-static UINT8 default_fcode_tab[MAX_MV*2+1];
+static uint16_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
+static uint8_t default_fcode_tab[MAX_MV*2+1];
 
 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
 
 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
-                           const UINT16 *quant_matrix, int bias, int qmin, int qmax)
+                           const uint16_t *quant_matrix, int bias, int qmin, int qmax)
 {
     int qscale;
 
@@ -105,7 +105,7 @@ static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16
                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
                 
-                qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / 
+                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / 
                                 (qscale * quant_matrix[j]));
             }
         } else if (s->fdct == fdct_ifast) {
@@ -116,7 +116,7 @@ static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16
                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
                 
-                qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / 
+                qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) / 
                                 (aanscales[i] * qscale * quant_matrix[j]));
             }
         } else {
@@ -127,7 +127,7 @@ static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16
                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
                 */
-                qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
+                qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
 //                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
                 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
 
@@ -147,7 +147,7 @@ static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16
     }\
 }
 
-void ff_init_scantable(MpegEncContext *s, ScanTable *st, const UINT8 *src_scantable){
+void ff_init_scantable(MpegEncContext *s, ScanTable *st, const uint8_t *src_scantable){
     int i;
     int end;
     
@@ -174,14 +174,14 @@ void ff_init_scantable(MpegEncContext *s, ScanTable *st, const UINT8 *src_scanta
 /* XXX: those functions should be suppressed ASAP when all IDCTs are
  converted */
 // *FIXME* this is ugly hack using local static
-static void (*ff_put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
-static void (*ff_add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
-static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
+static void (*ff_put_pixels_clamped)(const DCTELEM *block, uint8_t *pixels, int line_size);
+static void (*ff_add_pixels_clamped)(const DCTELEM *block, uint8_t *pixels, int line_size);
+static void ff_jref_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
 {
     j_rev_dct (block);
     ff_put_pixels_clamped(block, dest, line_size);
 }
-static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
+static void ff_jref_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
 {
     j_rev_dct (block);
     ff_add_pixels_clamped(block, dest, line_size);
@@ -312,14 +312,14 @@ static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
     
     if(pic->qscale_table==NULL){
         if (s->encoding) {        
-            CHECKED_ALLOCZ(pic->mb_var   , s->mb_num * sizeof(INT16))
-            CHECKED_ALLOCZ(pic->mc_mb_var, s->mb_num * sizeof(INT16))
-            CHECKED_ALLOCZ(pic->mb_mean  , s->mb_num * sizeof(INT8))
+            CHECKED_ALLOCZ(pic->mb_var   , s->mb_num * sizeof(int16_t))
+            CHECKED_ALLOCZ(pic->mc_mb_var, s->mb_num * sizeof(int16_t))
+            CHECKED_ALLOCZ(pic->mb_mean  , s->mb_num * sizeof(int8_t))
             CHECKED_ALLOCZ(pic->mb_cmp_score, s->mb_num * sizeof(int32_t))
         }
 
-        CHECKED_ALLOCZ(pic->mbskip_table , s->mb_num * sizeof(UINT8)+1) //the +1 is for the slice end check
-        CHECKED_ALLOCZ(pic->qscale_table , s->mb_num * sizeof(UINT8))
+        CHECKED_ALLOCZ(pic->mbskip_table , s->mb_num * sizeof(uint8_t)+1) //the +1 is for the slice end check
+        CHECKED_ALLOCZ(pic->qscale_table , s->mb_num * sizeof(uint8_t))
         pic->qstride= s->mb_width;
     }
     
@@ -405,12 +405,12 @@ int MPV_common_init(MpegEncContext *s)
         int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
 
         /* Allocate MV tables */
-        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(INT16))
-        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(INT16))
-        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(INT16))
-        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
-        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
-        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(INT16))
+        CHECKED_ALLOCZ(s->p_mv_table            , mv_table_size * 2 * sizeof(int16_t))
+        CHECKED_ALLOCZ(s->b_forw_mv_table       , mv_table_size * 2 * sizeof(int16_t))
+        CHECKED_ALLOCZ(s->b_back_mv_table       , mv_table_size * 2 * sizeof(int16_t))
+        CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(int16_t))
+        CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(int16_t))
+        CHECKED_ALLOCZ(s->b_direct_mv_table     , mv_table_size * 2 * sizeof(int16_t))
 
         //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
         CHECKED_ALLOCZ(s->me.scratchpad,  s->width*2*16*3*sizeof(uint8_t)) 
@@ -429,29 +429,29 @@ int MPV_common_init(MpegEncContext *s)
         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
     }
         
-    CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(UINT8))
+    CHECKED_ALLOCZ(s->error_status_table, s->mb_num*sizeof(uint8_t))
     
     if (s->out_format == FMT_H263 || s->encoding) {
         int size;
         /* Allocate MB type table */
-        CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(UINT8))
+        CHECKED_ALLOCZ(s->mb_type  , s->mb_num * sizeof(uint8_t))
 
         /* MV prediction */
         size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
-        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
+        CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
     }
 
     if(s->codec_id==CODEC_ID_MPEG4){
         /* interlaced direct mode decoding tables */
-        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
-        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
+        CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(int16_t))
+        CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(int8_t))
     }
     /* 4mv b frame decoding table */
     //note this is needed for h263 without b frames too (segfault on damaged streams otherwise)
-    CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
+    CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(uint8_t))
     if (s->out_format == FMT_H263) {
         /* ac values */
-        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(INT16) * 16);
+        CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
         s->ac_val[1] = s->ac_val[0] + y_size;
         s->ac_val[2] = s->ac_val[1] + c_size;
         
@@ -462,14 +462,14 @@ int MPV_common_init(MpegEncContext *s)
         CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
 
         /* cbp, ac_pred, pred_dir */
-        CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(UINT8))
-        CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
+        CHECKED_ALLOCZ(s->cbp_table  , s->mb_num * sizeof(uint8_t))
+        CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(uint8_t))
     }
     
     if (s->h263_pred || s->h263_plus || !s->encoding) {
         /* dc values */
         //MN: we need these for error resilience of intra-frames
-        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(INT16));
+        CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
         s->dc_val[1] = s->dc_val[0] + y_size;
         s->dc_val[2] = s->dc_val[1] + c_size;
         for(i=0;i<yc_size;i++)
@@ -716,9 +716,9 @@ int MPV_encode_init(AVCodecContext *avctx)
             int i;
             done=1;
 
-            default_mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
-            memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
-            memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
+            default_mv_penalty= av_mallocz( sizeof(uint16_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
+            memset(default_mv_penalty, 0, sizeof(uint16_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
+            memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
 
             for(i=-16; i<16; i++){
                 default_fcode_tab[i + MAX_MV]= 1;
@@ -812,8 +812,8 @@ int MPV_encode_end(AVCodecContext *avctx)
 
 void init_rl(RLTable *rl)
 {
-    INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
-    UINT8 index_run[MAX_RUN+1];
+    int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
+    uint8_t index_run[MAX_RUN+1];
     int last, run, level, start, end, i;
 
     /* compute max_level[], max_run[] and index_run[] */
@@ -850,9 +850,9 @@ void init_rl(RLTable *rl)
 
 /* draw the edges of width 'w' of an image of size width, height */
 //FIXME check that this is ok for mpeg4 interlaced
-static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
+static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
 {
-    UINT8 *ptr, *last_line;
+    uint8_t *ptr, *last_line;
     int i;
 
     last_line = buf + (height - 1) * wrap;
@@ -1324,11 +1324,11 @@ int MPV_encode_picture(AVCodecContext *avctx,
 }
 
 static inline void gmc1_motion(MpegEncContext *s,
-                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
+                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                                int dest_offset,
-                               UINT8 **ref_picture, int src_offset)
+                               uint8_t **ref_picture, int src_offset)
 {
-    UINT8 *ptr;
+    uint8_t *ptr;
     int offset, src_x, src_y, linesize, uvlinesize;
     int motion_x, motion_y;
     int emu=0;
@@ -1412,11 +1412,11 @@ static inline void gmc1_motion(MpegEncContext *s,
 }
 
 static inline void gmc_motion(MpegEncContext *s,
-                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
+                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                                int dest_offset,
-                               UINT8 **ref_picture, int src_offset)
+                               uint8_t **ref_picture, int src_offset)
 {
-    UINT8 *ptr;
+    uint8_t *ptr;
     int linesize, uvlinesize;
     const int a= s->sprite_warping_accuracy;
     int ox, oy;
@@ -1475,11 +1475,11 @@ static inline void gmc_motion(MpegEncContext *s,
 }
 
 
-void ff_emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
+void ff_emulated_edge_mc(MpegEncContext *s, uint8_t *src, int linesize, int block_w, int block_h, 
                                     int src_x, int src_y, int w, int h){
     int x, y;
     int start_y, start_x, end_y, end_x;
-    UINT8 *buf= s->edge_emu_buffer;
+    uint8_t *buf= s->edge_emu_buffer;
 
     if(src_y>= h){
         src+= (h-1-src_y)*linesize;
@@ -1538,13 +1538,13 @@ void ff_emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_
 
 /* apply one mpeg motion vector to the three components */
 static inline void mpeg_motion(MpegEncContext *s,
-                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
+                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                                int dest_offset,
-                               UINT8 **ref_picture, int src_offset,
+                               uint8_t **ref_picture, int src_offset,
                                int field_based, op_pixels_func (*pix_op)[4],
                                int motion_x, int motion_y, int h)
 {
-    UINT8 *ptr;
+    uint8_t *ptr;
     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
     int emu=0;
 #if 0    
@@ -1628,14 +1628,14 @@ if(s->quarter_sample)
 }
 
 static inline void qpel_motion(MpegEncContext *s,
-                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
+                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                                int dest_offset,
-                               UINT8 **ref_picture, int src_offset,
+                               uint8_t **ref_picture, int src_offset,
                                int field_based, op_pixels_func (*pix_op)[4],
                                qpel_mc_func (*qpix_op)[16],
                                int motion_x, int motion_y, int h)
 {
-    UINT8 *ptr;
+    uint8_t *ptr;
     int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
     int emu=0;
 
@@ -1735,13 +1735,13 @@ inline int ff_h263_round_chroma(int x){
 }
 
 static inline void MPV_motion(MpegEncContext *s, 
-                              UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
-                              int dir, UINT8 **ref_picture, 
+                              uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
+                              int dir, uint8_t **ref_picture, 
                               op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
 {
     int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
     int mb_x, mb_y, i;
-    UINT8 *ptr, *dest;
+    uint8_t *ptr, *dest;
     int emu=0;
 
     mb_x = s->mb_x;
@@ -1916,7 +1916,7 @@ static inline void MPV_motion(MpegEncContext *s,
 
 /* put block[] to dest[] */
 static inline void put_dct(MpegEncContext *s, 
-                           DCTELEM *block, int i, UINT8 *dest, int line_size)
+                           DCTELEM *block, int i, uint8_t *dest, int line_size)
 {
     s->dct_unquantize(s, block, i, s->qscale);
     s->idct_put (dest, line_size, block);
@@ -1924,7 +1924,7 @@ static inline void put_dct(MpegEncContext *s,
 
 /* add block[] to dest[] */
 static inline void add_dct(MpegEncContext *s, 
-                           DCTELEM *block, int i, UINT8 *dest, int line_size)
+                           DCTELEM *block, int i, uint8_t *dest, int line_size)
 {
     if (s->block_last_index[i] >= 0) {
         s->idct_add (dest, line_size, block);
@@ -1932,7 +1932,7 @@ static inline void add_dct(MpegEncContext *s,
 }
 
 static inline void add_dequant_dct(MpegEncContext *s, 
-                           DCTELEM *block, int i, UINT8 *dest, int line_size)
+                           DCTELEM *block, int i, uint8_t *dest, int line_size)
 {
     if (s->block_last_index[i] >= 0) {
         s->dct_unquantize(s, block, i, s->qscale);
@@ -1954,8 +1954,8 @@ void ff_clean_intra_table_entries(MpegEncContext *s)
     s->dc_val[0][xy     + wrap] =
     s->dc_val[0][xy + 1 + wrap] = 1024;
     /* ac pred */
-    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(INT16));
-    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
+    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
+    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
     if (s->msmpeg4_version>=3) {
         s->coded_block[xy           ] =
         s->coded_block[xy + 1       ] =
@@ -1968,8 +1968,8 @@ void ff_clean_intra_table_entries(MpegEncContext *s)
     s->dc_val[1][xy] =
     s->dc_val[2][xy] = 1024;
     /* ac pred */
-    memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
-    memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
+    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
+    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
     
     s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
 }
@@ -2053,7 +2053,7 @@ void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
     }
     
     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
-        UINT8 *dest_y, *dest_cb, *dest_cr;
+        uint8_t *dest_y, *dest_cb, *dest_cr;
         int dct_linesize, dct_offset;
         op_pixels_func (*op_pix)[4];
         qpel_mc_func (*op_qpix)[16];
@@ -2065,7 +2065,7 @@ void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 
         /* skip only during decoding as we might trash the buffers during encoding a bit */
         if(!s->encoding){
-            UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
+            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
             const int age= s->current_picture.age;
 
             assert(age);
@@ -2327,7 +2327,7 @@ static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64
     s->qscale= newq;
 }
 #if 0
-static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
+static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
     int score=0;
     int x,y;
     
@@ -2342,7 +2342,7 @@ static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimiz
     return score;
 }
 
-static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
+static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
     int score=0;
     int x,y;
     
@@ -2359,7 +2359,7 @@ static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to d
 #else
 #define SQ(a) ((a)*(a))
 
-static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
+static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
     int score=0;
     int x,y;
     
@@ -2374,7 +2374,7 @@ static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimiz
     return score;
 }
 
-static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
+static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
     int score=0;
     int x,y;
     
@@ -2394,7 +2394,7 @@ static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to d
 void ff_draw_horiz_band(MpegEncContext *s){
     if (    s->avctx->draw_horiz_band 
         && (s->last_picture.data[0] || s->low_delay) ) {
-        UINT8 *src_ptr[3];
+        uint8_t *src_ptr[3];
         int y, h, offset;
         y = s->mb_y * 16;
         h = s->height - y;
@@ -2454,7 +2454,7 @@ static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
     }
 
     if (s->mb_intra) {
-        UINT8 *ptr;
+        uint8_t *ptr;
         int wrap_y;
         int emu=0;
 
@@ -2509,8 +2509,8 @@ static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
     }else{
         op_pixels_func (*op_pix)[4];
         qpel_mc_func (*op_qpix)[16];
-        UINT8 *dest_y, *dest_cb, *dest_cr;
-        UINT8 *ptr_y, *ptr_cb, *ptr_cr;
+        uint8_t *dest_y, *dest_cb, *dest_cr;
+        uint8_t *ptr_y, *ptr_cb, *ptr_cr;
         int wrap_y, wrap_c;
         int emu=0;
 
@@ -2714,7 +2714,7 @@ int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size)
     return 0;
 }
 
-void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
+void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
 {
     int bytes= length>>4;
     int bits= length&15;
@@ -2846,9 +2846,9 @@ static void encode_picture(MpegEncContext *s, int picture_number)
     int i;
     int bits;
     MpegEncContext best_s, backup_s;
-    UINT8 bit_buf[2][3000];
-    UINT8 bit_buf2[2][3000];
-    UINT8 bit_buf_tex[2][3000];
+    uint8_t bit_buf[2][3000];
+    uint8_t bit_buf2[2][3000];
+    uint8_t bit_buf_tex[2][3000];
     PutBitContext pb[2], pb2[2], tex_pb[2];
 
     for(i=0; i<2; i++){
@@ -2935,9 +2935,9 @@ static void encode_picture(MpegEncContext *s, int picture_number)
     }else /* if(s->pict_type == I_TYPE) */{
         /* I-Frame */
         //FIXME do we need to zero them?
-        memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
-        memset(s->p_mv_table   , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
-        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
+        memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
+        memset(s->p_mv_table   , 0, sizeof(int16_t)*(s->mb_width+2)*(s->mb_height+2)*2);
+        memset(s->mb_type      , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_width*s->mb_height);
         
         if(!s->fixed_qscale){
             /* finding spatial complexity for I-frame rate control */
@@ -2962,7 +2962,7 @@ static void encode_picture(MpegEncContext *s, int picture_number)
 
     if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
         s->pict_type= I_TYPE;
-        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
+        memset(s->mb_type   , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_width*s->mb_height);
 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
     }
 
@@ -3506,7 +3506,7 @@ static int dct_quantize_trellis_c(MpegEncContext *s,
                         DCTELEM *block, int n,
                         int qscale, int *overflow){
     const int *qmat;
-    const UINT8 *scantable= s->intra_scantable.scantable;
+    const uint8_t *scantable= s->intra_scantable.scantable;
     int max=0;
     unsigned int threshold1, threshold2;
     int bias=0;
@@ -3756,7 +3756,7 @@ static int dct_quantize_c(MpegEncContext *s,
 {
     int i, j, level, last_non_zero, q;
     const int *qmat;
-    const UINT8 *scantable= s->intra_scantable.scantable;
+    const uint8_t *scantable= s->intra_scantable.scantable;
     int bias;
     int max=0;
     unsigned int threshold1, threshold2;
@@ -3823,7 +3823,7 @@ static void dct_unquantize_mpeg1_c(MpegEncContext *s,
                                    DCTELEM *block, int n, int qscale)
 {
     int i, level, nCoeffs;
-    const UINT16 *quant_matrix;
+    const uint16_t *quant_matrix;
 
     nCoeffs= s->block_last_index[n];
     
@@ -3886,7 +3886,7 @@ static void dct_unquantize_mpeg2_c(MpegEncContext *s,
                                    DCTELEM *block, int n, int qscale)
 {
     int i, level, nCoeffs;
-    const UINT16 *quant_matrix;
+    const uint16_t *quant_matrix;
 
     if(s->alternate_scan) nCoeffs= 63;
     else nCoeffs= s->block_last_index[n];

libavcodec/mpegvideo.h

@@ -68,7 +68,7 @@ typedef struct RateControlEntry{
     int i_tex_bits;
     int p_tex_bits;
     int misc_bits;
-    UINT64 expected_bits;
+    uint64_t expected_bits;
     int new_pict_type;
     float new_qscale;
     int mc_mb_var_sum;
@@ -92,21 +92,21 @@ typedef struct RateControlContext{
     double last_qscale_for[5]; /* last qscale for a specific pict type, used for max_diff & ipb factor stuff */
     int last_mc_mb_var_sum;
     int last_mb_var_sum;
-    UINT64 i_cplx_sum[5];
-    UINT64 p_cplx_sum[5];
-    UINT64 mv_bits_sum[5];
-    UINT64 qscale_sum[5];
+    uint64_t i_cplx_sum[5];
+    uint64_t p_cplx_sum[5];
+    uint64_t mv_bits_sum[5];
+    uint64_t qscale_sum[5];
     int frame_count[5];
     int last_non_b_pict_type;
 }RateControlContext;
 
 typedef struct ScanTable{
-    const UINT8 *scantable;
-    UINT8 permutated[64];
-    UINT8 raster_end[64];
+    const uint8_t *scantable;
+    uint8_t permutated[64];
+    uint8_t raster_end[64];
 #ifdef ARCH_POWERPC
 		/* Used by dct_quantise_alitvec to find last-non-zero */
-    UINT8 __align8 inverse[64];
+    uint8_t __align8 inverse[64];
 #endif
 } ScanTable;
 
@@ -123,7 +123,7 @@ typedef struct Picture{
 } Picture;
 
 typedef struct ParseContext{
-    UINT8 *buffer;
+    uint8_t *buffer;
     int index;
     int last_index;
     int buffer_size;
@@ -147,7 +147,7 @@ typedef struct MotionEstContext{
     int mb_penalty_factor;
     int pre_pass;                      /* = 1 for the pre pass */
     int dia_size;
-    UINT16 (*mv_penalty)[MAX_MV*2+1];  /* amount of bits needed to encode a MV */
+    uint16_t (*mv_penalty)[MAX_MV*2+1];  /* amount of bits needed to encode a MV */
     int (*sub_motion_search)(struct MpegEncContext * s,
 				  int *mx_ptr, int *my_ptr, int dmin,
 				  int xmin, int ymin, int xmax, int ymax,
@@ -224,21 +224,21 @@ typedef struct MpegEncContext {
     Picture new_picture;        /* source picture for encoding */
     Picture current_picture;    /* buffer to store the decompressed current picture */
     int last_dc[3];              /* last DC values for MPEG1 */
-    INT16 *dc_val[3];            /* used for mpeg4 DC prediction, all 3 arrays must be continuous */
+    int16_t *dc_val[3];            /* used for mpeg4 DC prediction, all 3 arrays must be continuous */
     int y_dc_scale, c_dc_scale;
-    UINT8 *y_dc_scale_table;     /* qscale -> y_dc_scale table */
-    UINT8 *c_dc_scale_table;     /* qscale -> c_dc_scale table */
-    UINT8 *coded_block;          /* used for coded block pattern prediction (msmpeg4v3, wmv1)*/
-    INT16 (*ac_val[3])[16];      /* used for for mpeg4 AC prediction, all 3 arrays must be continuous */
+    uint8_t *y_dc_scale_table;     /* qscale -> y_dc_scale table */
+    uint8_t *c_dc_scale_table;     /* qscale -> c_dc_scale table */
+    uint8_t *coded_block;          /* used for coded block pattern prediction (msmpeg4v3, wmv1)*/
+    int16_t (*ac_val[3])[16];      /* used for for mpeg4 AC prediction, all 3 arrays must be continuous */
     int ac_pred;
     uint8_t *prev_pict_types;   /* previous picture types in bitstream order, used for mb skip */
 #define PREV_PICT_TYPES_BUFFER_SIZE 256
     int mb_skiped;              /* MUST BE SET only during DECODING */
-    UINT8 *mbskip_table;        /* used to avoid copy if macroblock skipped (for black regions for example) 
+    uint8_t *mbskip_table;        /* used to avoid copy if macroblock skipped (for black regions for example) 
                                    and used for b-frame encoding & decoding (contains skip table of next P Frame) */
-    UINT8 *mbintra_table;       /* used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding */
-    UINT8 *cbp_table;           /* used to store cbp, ac_pred for partitioned decoding */
-    UINT8 *pred_dir_table;      /* used to store pred_dir for partitioned decoding */
+    uint8_t *mbintra_table;       /* used to avoid setting {ac, dc, cbp}-pred stuff to zero on inter MB decoding */
+    uint8_t *cbp_table;           /* used to store cbp, ac_pred for partitioned decoding */
+    uint8_t *pred_dir_table;      /* used to store pred_dir for partitioned decoding */
     uint8_t *allocated_edge_emu_buffer;
     uint8_t *edge_emu_buffer;     /* points into the middle of allocated_edge_emu_buffer */ 
 
@@ -257,13 +257,13 @@ typedef struct MpegEncContext {
     DSPContext dsp;             /* pointers for accelerated dsp fucntions */
     int f_code; /* forward MV resolution */
     int b_code; /* backward MV resolution for B Frames (mpeg4) */
-    INT16 (*motion_val)[2];            /* used for MV prediction (4MV per MB) */
-    INT16 (*p_mv_table)[2];            /* MV table (1MV per MB) p-frame encoding */
-    INT16 (*b_forw_mv_table)[2];       /* MV table (1MV per MB) forward mode b-frame encoding */
-    INT16 (*b_back_mv_table)[2];       /* MV table (1MV per MB) backward mode b-frame encoding */
-    INT16 (*b_bidir_forw_mv_table)[2]; /* MV table (1MV per MB) bidir mode b-frame encoding */
-    INT16 (*b_bidir_back_mv_table)[2]; /* MV table (1MV per MB) bidir mode b-frame encoding */
-    INT16 (*b_direct_mv_table)[2];     /* MV table (1MV per MB) direct mode b-frame encoding */
+    int16_t (*motion_val)[2];            /* used for MV prediction (4MV per MB) */
+    int16_t (*p_mv_table)[2];            /* MV table (1MV per MB) p-frame encoding */
+    int16_t (*b_forw_mv_table)[2];       /* MV table (1MV per MB) forward mode b-frame encoding */
+    int16_t (*b_back_mv_table)[2];       /* MV table (1MV per MB) backward mode b-frame encoding */
+    int16_t (*b_bidir_forw_mv_table)[2]; /* MV table (1MV per MB) bidir mode b-frame encoding */
+    int16_t (*b_bidir_back_mv_table)[2]; /* MV table (1MV per MB) bidir mode b-frame encoding */
+    int16_t (*b_direct_mv_table)[2];     /* MV table (1MV per MB) direct mode b-frame encoding */
     int me_method;                     /* ME algorithm */
     int scene_change_score;
     int mv_dir;
@@ -284,7 +284,7 @@ typedef struct MpegEncContext {
     int mv[2][4][2];
     int field_select[2][2];
     int last_mv[2][2][2];             /* last MV, used for MV prediction in MPEG1 & B-frame MPEG4 */
-    UINT8 *fcode_tab; /* smallest fcode needed for each MV */
+    uint8_t *fcode_tab; /* smallest fcode needed for each MV */
     
     MotionEstContext me;
 
@@ -298,7 +298,7 @@ typedef struct MpegEncContext {
     int mb_x, mb_y;
     int mb_incr;
     int mb_intra;
-    UINT8 *mb_type;       /* Table for MB type */
+    uint8_t *mb_type;       /* Table for MB type */
 #define MB_TYPE_INTRA    0x01
 #define MB_TYPE_INTER    0x02
 #define MB_TYPE_INTER4V  0x04
@@ -314,10 +314,10 @@ typedef struct MpegEncContext {
     int block_wrap[6];
 
     /* matrix transmitted in the bitstream */
-    UINT16 intra_matrix[64];
-    UINT16 chroma_intra_matrix[64];
-    UINT16 inter_matrix[64];
-    UINT16 chroma_inter_matrix[64];
+    uint16_t intra_matrix[64];
+    uint16_t chroma_intra_matrix[64];
+    uint16_t inter_matrix[64];
+    uint16_t chroma_inter_matrix[64];
 #define QUANT_BIAS_SHIFT 4
     int intra_quant_bias;    /* bias for the quantizer */
     int inter_quant_bias;    /* bias for the quantizer */
@@ -336,17 +336,17 @@ typedef struct MpegEncContext {
     int __align8 q_intra_matrix[32][64];
     int __align8 q_inter_matrix[32][64];
     /* identical to the above but for MMX & these are not permutated */
-    UINT16 __align8 q_intra_matrix16[32][64];
-    UINT16 __align8 q_inter_matrix16[32][64];
-    UINT16 __align8 q_intra_matrix16_bias[32][64];
-    UINT16 __align8 q_inter_matrix16_bias[32][64];
+    uint16_t __align8 q_intra_matrix16[32][64];
+    uint16_t __align8 q_inter_matrix16[32][64];
+    uint16_t __align8 q_intra_matrix16_bias[32][64];
+    uint16_t __align8 q_inter_matrix16_bias[32][64];
     int block_last_index[6];  /* last non zero coefficient in block */
     /* scantables */
     ScanTable __align8 intra_scantable;
     ScanTable intra_h_scantable;
     ScanTable intra_v_scantable;
     ScanTable inter_scantable; // if inter == intra then intra should be used to reduce tha cache usage
-    UINT8 idct_permutation[64];
+    uint8_t idct_permutation[64];
     int idct_permutation_type;
 #define FF_NO_IDCT_PERM 1
 #define FF_LIBMPEG2_IDCT_PERM 2
@@ -357,8 +357,8 @@ typedef struct MpegEncContext {
 
     /* bit rate control */
     int I_frame_bits; //FIXME used in mpeg12 ...
-    INT64 wanted_bits;
-    INT64 total_bits;
+    int64_t wanted_bits;
+    int64_t total_bits;
     int frame_bits;        /* bits used for the current frame */
     RateControlContext rc_context; // contains stuff only accessed in ratecontrol.c
 
@@ -375,7 +375,7 @@ typedef struct MpegEncContext {
     int last_bits; //temp var used for calculating the above vars
     
     /* error concealment / resync */
-    UINT8 *error_status_table;       /* table of the error status of each MB */ 
+    uint8_t *error_status_table;       /* table of the error status of each MB */ 
 #define VP_START            1        /* current MB is the first after a resync marker */
 #define AC_ERROR            2
 #define DC_ERROR            4
@@ -409,12 +409,12 @@ typedef struct MpegEncContext {
     int time_increment_bits;        /* number of bits to represent the fractional part of time */
     int last_time_base;
     int time_base;                  /* time in seconds of last I,P,S Frame */
-    INT64 time;                   /* time of current frame */ 
-    INT64 last_non_b_time;
-    UINT16 pp_time;               /* time distance between the last 2 p,s,i frames */
-    UINT16 pb_time;               /* time distance between the last b and p,s,i frame */
-    UINT16 pp_field_time;
-    UINT16 pb_field_time;         /* like above, just for interlaced */
+    int64_t time;                   /* time of current frame */ 
+    int64_t last_non_b_time;
+    uint16_t pp_time;               /* time distance between the last 2 p,s,i frames */
+    uint16_t pb_time;               /* time distance between the last b and p,s,i frame */
+    uint16_t pp_field_time;
+    uint16_t pb_field_time;         /* like above, just for interlaced */
     int shape;
     int vol_sprite_usage;
     int sprite_width;
@@ -455,9 +455,9 @@ typedef struct MpegEncContext {
     int mpeg_quant;
 #define CO_LOCATED_TYPE_4MV     1
 #define CO_LOCATED_TYPE_FIELDMV 2
-    INT8 *co_located_type_table;     /* 4mv & field_mv info for next b frame */
-    INT16 (*field_mv_table)[2][2];   /* used for interlaced b frame decoding */
-    INT8 (*field_select_table)[2];   /* wtf, no really another table for interlaced b frames */
+    int8_t *co_located_type_table;     /* 4mv & field_mv info for next b frame */
+    int16_t (*field_mv_table)[2][2];   /* used for interlaced b frame decoding */
+    int8_t (*field_select_table)[2];   /* wtf, no really another table for interlaced b frames */
     int t_frame;                     /* time distance of first I -> B, used for interlaced b frames */
     int padding_bug_score;           /* used to detect the VERY common padding bug in MPEG4 */
 
@@ -465,7 +465,7 @@ typedef struct MpegEncContext {
     int divx_version;
     int divx_build;
 #define BITSTREAM_BUFFER_SIZE 1024*256
-    UINT8 *bitstream_buffer; //Divx 5.01 puts several frames in a single one, this is used to reorder them
+    uint8_t *bitstream_buffer; //Divx 5.01 puts several frames in a single one, this is used to reorder them
     int bitstream_buffer_size;
     
     int xvid_build;
@@ -541,9 +541,9 @@ typedef struct MpegEncContext {
     int rtp_mode;
     int rtp_payload_size;
     void (*rtp_callback)(void *data, int size, int packet_number);
-    UINT8 *ptr_lastgob;
-    UINT8 *ptr_last_mb_line;
-    UINT32 mb_line_avgsize;
+    uint8_t *ptr_lastgob;
+    uint8_t *ptr_last_mb_line;
+    uint32_t mb_line_avgsize;
     
     DCTELEM (*block)[64]; /* points to one of the following blocks */
     DCTELEM blocks[2][6][64] __align8; // for HQ mode we need to keep the best block
@@ -564,8 +564,8 @@ typedef struct MpegEncContext {
     int (*dct_quantize)(struct MpegEncContext *s, DCTELEM *block/*align 16*/, int n, int qscale, int *overflow);
     int (*fast_dct_quantize)(struct MpegEncContext *s, DCTELEM *block/*align 16*/, int n, int qscale, int *overflow);
     void (*fdct)(DCTELEM *block/* align 16*/);
-    void (*idct_put)(UINT8 *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
-    void (*idct_add)(UINT8 *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
+    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
+    void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
     //FIXME move above funcs into dspContext perhaps
 } MpegEncContext;
 
@@ -597,14 +597,14 @@ void MPV_common_init_armv4l(MpegEncContext *s);
 #ifdef ARCH_POWERPC
 void MPV_common_init_ppc(MpegEncContext *s);
 #endif
-extern void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w);
+extern void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w);
 void ff_conceal_past_errors(MpegEncContext *s, int conceal_all);
-void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length);
+void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length);
 void ff_clean_intra_table_entries(MpegEncContext *s);
-void ff_init_scantable(MpegEncContext *s, ScanTable *st, const UINT8 *src_scantable);
+void ff_init_scantable(MpegEncContext *s, ScanTable *st, const uint8_t *src_scantable);
 void ff_error_resilience(MpegEncContext *s);
 void ff_draw_horiz_band(MpegEncContext *s);
-void ff_emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h, 
+void ff_emulated_edge_mc(MpegEncContext *s, uint8_t *src, int linesize, int block_w, int block_h, 
                                     int src_x, int src_y, int w, int h);
 char ff_get_pict_type_char(int pict_type);
 int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size);
@@ -645,9 +645,9 @@ int ff_pre_estimate_p_frame_motion(MpegEncContext * s, int mb_x, int mb_y);
 
 
 /* mpeg12.c */
-extern const INT16 ff_mpeg1_default_intra_matrix[64];
-extern const INT16 ff_mpeg1_default_non_intra_matrix[64];
-extern UINT8 ff_mpeg1_dc_scale_table[128];
+extern const int16_t ff_mpeg1_default_intra_matrix[64];
+extern const int16_t ff_mpeg1_default_non_intra_matrix[64];
+extern uint8_t ff_mpeg1_dc_scale_table[128];
 
 void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number);
 void mpeg1_encode_mb(MpegEncContext *s,
@@ -660,12 +660,12 @@ void ff_mpeg1_encode_init(MpegEncContext *s);
 typedef struct RLTable {
     int n; /* number of entries of table_vlc minus 1 */
     int last; /* number of values for last = 0 */
-    const UINT16 (*table_vlc)[2];
-    const INT8 *table_run;
-    const INT8 *table_level;
-    UINT8 *index_run[2]; /* encoding only */
-    INT8 *max_level[2]; /* encoding & decoding */
-    INT8 *max_run[2];   /* encoding & decoding */
+    const uint16_t (*table_vlc)[2];
+    const int8_t *table_run;
+    const int8_t *table_level;
+    uint8_t *index_run[2]; /* encoding only */
+    int8_t *max_level[2]; /* encoding & decoding */
+    int8_t *max_run[2];   /* encoding & decoding */
     VLC vlc;            /* decoding only deprected FIXME remove*/
     RL_VLC_ELEM *rl_vlc[32]; /* decoding only */
 } RLTable;
@@ -684,14 +684,14 @@ static inline int get_rl_index(const RLTable *rl, int last, int run, int level)
     return index + level - 1;
 }
 
-extern UINT8 ff_mpeg4_y_dc_scale_table[32];
-extern UINT8 ff_mpeg4_c_dc_scale_table[32];
-extern const INT16 ff_mpeg4_default_intra_matrix[64];
-extern const INT16 ff_mpeg4_default_non_intra_matrix[64];
+extern uint8_t ff_mpeg4_y_dc_scale_table[32];
+extern uint8_t ff_mpeg4_c_dc_scale_table[32];
+extern const int16_t ff_mpeg4_default_intra_matrix[64];
+extern const int16_t ff_mpeg4_default_non_intra_matrix[64];
 int ff_h263_decode_init(AVCodecContext *avctx);
 int ff_h263_decode_frame(AVCodecContext *avctx, 
                              void *data, int *data_size,
-                             UINT8 *buf, int buf_size);
+                             uint8_t *buf, int buf_size);
 int ff_h263_decode_end(AVCodecContext *avctx);
 void h263_encode_mb(MpegEncContext *s, 
                     DCTELEM block[6][64],
@@ -701,7 +701,7 @@ void mpeg4_encode_mb(MpegEncContext *s,
                     int motion_x, int motion_y);
 void h263_encode_picture_header(MpegEncContext *s, int picture_number);
 int h263_encode_gob_header(MpegEncContext * s, int mb_line);
-INT16 *h263_pred_motion(MpegEncContext * s, int block, 
+int16_t *h263_pred_motion(MpegEncContext * s, int block, 
                         int *px, int *py);
 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, 
                    int dir);
@@ -751,8 +751,8 @@ void ff_msmpeg4_encode_init(MpegEncContext *s);
 int ff_wmv2_decode_picture_header(MpegEncContext * s);
 void ff_wmv2_add_mb(MpegEncContext *s, DCTELEM block[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr);
 void ff_mspel_motion(MpegEncContext *s,
-                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
-                               UINT8 **ref_picture, op_pixels_func (*pix_op)[4],
+                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
+                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
                                int motion_x, int motion_y, int h);
 int ff_wmv2_encode_picture_header(MpegEncContext * s, int picture_number);
 void ff_wmv2_encode_mb(MpegEncContext * s, 

libavcodec/msmpeg4.c

@@ -50,8 +50,8 @@
 
 #define DEFAULT_INTER_INDEX 3
 
-static UINT32 v2_dc_lum_table[512][2];
-static UINT32 v2_dc_chroma_table[512][2];
+static uint32_t v2_dc_lum_table[512][2];
+static uint32_t v2_dc_chroma_table[512][2];
 
 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
@@ -67,7 +67,7 @@ static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
 
-extern UINT32 inverse[256];
+extern uint32_t inverse[256];
 
 
 #ifdef DEBUG
@@ -77,7 +77,7 @@ int frame_count = 0;
 
 #include "msmpeg4data.h"
 
-static UINT8 rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
+static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
 
 #ifdef STATS
 
@@ -190,7 +190,7 @@ static void init_mv_table(MVTable *tab)
 {
     int i, x, y;
 
-    tab->table_mv_index = av_malloc(sizeof(UINT16) * 4096);
+    tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096);
     /* mark all entries as not used */
     for(i=0;i<4096;i++)
         tab->table_mv_index[i] = tab->n;
@@ -434,7 +434,7 @@ void msmpeg4_encode_ext_header(MpegEncContext * s)
 }
 
 /* predict coded block */
-static inline int coded_block_pred(MpegEncContext * s, int n, UINT8 **coded_block_ptr)
+static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
 {
     int xy, wrap, pred, a, b, c;
 
@@ -518,7 +518,7 @@ void msmpeg4_encode_mb(MpegEncContext * s,
 {
     int cbp, coded_cbp, i;
     int pred_x, pred_y;
-    UINT8 *coded_block;
+    uint8_t *coded_block;
 
     handle_slices(s);
     
@@ -640,7 +640,7 @@ static void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
 }
 
 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 
-                                    INT32 **dc_val_ptr)
+                                    int32_t **dc_val_ptr)
 {
     int i;
 
@@ -669,10 +669,10 @@ static int get_dc(uint8_t *src, int stride, int scale)
 
 /* dir = 0: left, dir = 1: top prediction */
 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 
-                             UINT16 **dc_val_ptr, int *dir_ptr)
+                             uint16_t **dc_val_ptr, int *dir_ptr)
 {
     int a, b, c, wrap, pred, scale;
-    INT16 *dc_val;
+    int16_t *dc_val;
 
     /* find prediction */
     if (n < 4) {
@@ -823,13 +823,13 @@ static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr
     int pred;
 
     if(s->msmpeg4_version==1){
-        INT32 *dc_val;
+        int32_t *dc_val;
         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
         
         /* update predictor */
         *dc_val= level;
     }else{
-        UINT16 *dc_val;
+        uint16_t *dc_val;
         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 
         /* update predictor */
@@ -895,7 +895,7 @@ static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int
     int last_non_zero, sign, slevel;
     int code, run_diff, dc_pred_dir;
     const RLTable *rl;
-    const UINT8 *scantable;
+    const uint8_t *scantable;
 
     if (s->mb_intra) {
         set_stat(ST_DC);
@@ -1544,7 +1544,7 @@ static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 {
     int cbp, code, i;
-    UINT8 *coded_val;
+    uint8_t *coded_val;
 
 #ifdef PRINT_MB
 if(s->mb_x==0){
@@ -1939,14 +1939,14 @@ static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
     }
 
     if(s->msmpeg4_version==1){
-        INT32 *dc_val;
+        int32_t *dc_val;
         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
         level += pred;
         
         /* update predictor */
         *dc_val= level;
     }else{
-        UINT16 *dc_val;
+        uint16_t *dc_val;
         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
         level += pred;
 

libavcodec/oggvorbis.c

@@ -179,7 +179,7 @@ static inline int conv(int samples, float **pcm, char *buf, int channels) {
 	
 static int oggvorbis_decode_frame(AVCodecContext *avccontext,
                         void *data, int *data_size,
-                        UINT8 *buf, int buf_size)
+                        uint8_t *buf, int buf_size)
 {
     OggVorbisContext *context = avccontext->priv_data ;
     ogg_packet *op = (ogg_packet*)buf ;

libavcodec/pcm.c

@@ -73,13 +73,13 @@ static int ulaw2linear(unsigned char	u_val)
 }
 
 /* 16384 entries per table */
-static UINT8 *linear_to_alaw = NULL;
+static uint8_t *linear_to_alaw = NULL;
 static int linear_to_alaw_ref = 0;
 
-static UINT8 *linear_to_ulaw = NULL;
+static uint8_t *linear_to_ulaw = NULL;
 static int linear_to_ulaw_ref = 0;
 
-static void build_xlaw_table(UINT8 *linear_to_xlaw, 
+static void build_xlaw_table(uint8_t *linear_to_xlaw, 
                              int (*xlaw2linear)(unsigned char),
                              int mask) 
 {
@@ -274,12 +274,12 @@ static int pcm_decode_init(AVCodecContext * avctx)
 
 static int pcm_decode_frame(AVCodecContext *avctx,
 			    void *data, int *data_size,
-			    UINT8 *buf, int buf_size)
+			    uint8_t *buf, int buf_size)
 {
     PCMDecode *s = avctx->priv_data;
     int n;
     short *samples;
-    UINT8 *src;
+    uint8_t *src;
 
     samples = data;
     src = buf;
@@ -339,7 +339,7 @@ static int pcm_decode_frame(AVCodecContext *avctx,
         *data_size = 0;
         return -1;
     }
-    *data_size = (UINT8 *)samples - (UINT8 *)data;
+    *data_size = (uint8_t *)samples - (uint8_t *)data;
     return src - buf;
 }
 

libavcodec/ppc/dsputil_altivec.c

@@ -480,7 +480,7 @@ int sse16_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size)
     return s;
 }
 
-int pix_sum_altivec(UINT8 * pix, int line_size)
+int pix_sum_altivec(uint8_t * pix, int line_size)
 {
     const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0);
     vector unsigned char perm, *pixv;
@@ -513,7 +513,7 @@ int pix_sum_altivec(UINT8 * pix, int line_size)
     return s;
 }
 
-void get_pixels_altivec(DCTELEM *restrict block, const UINT8 *pixels, int line_size)
+void get_pixels_altivec(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
 {
     int i;
     vector unsigned char perm, bytes, *pixv;
@@ -539,8 +539,8 @@ void get_pixels_altivec(DCTELEM *restrict block, const UINT8 *pixels, int line_s
     }
 }
 
-void diff_pixels_altivec(DCTELEM *restrict block, const UINT8 *s1,
-        const UINT8 *s2, int stride)
+void diff_pixels_altivec(DCTELEM *restrict block, const uint8_t *s1,
+        const uint8_t *s2, int stride)
 {
     int i;
     vector unsigned char perm, bytes, *pixv;

libavcodec/ppc/dsputil_altivec.h

@@ -34,12 +34,12 @@ extern int sad8x8_altivec(void *s, uint8_t *a, uint8_t *b, int stride);
 extern int pix_norm1_altivec(uint8_t *pix, int line_size);
 extern int sse8_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size);
 extern int sse16_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size);
-extern int pix_sum_altivec(UINT8 * pix, int line_size);
-extern void diff_pixels_altivec(DCTELEM* block, const UINT8* s1, const UINT8* s2, int stride);
-extern void get_pixels_altivec(DCTELEM* block, const UINT8 * pixels, int line_size);
+extern int pix_sum_altivec(uint8_t * pix, int line_size);
+extern void diff_pixels_altivec(DCTELEM* block, const uint8_t* s1, const uint8_t* s2, int stride);
+extern void get_pixels_altivec(DCTELEM* block, const uint8_t * pixels, int line_size);
 
 extern void add_bytes_altivec(uint8_t *dst, uint8_t *src, int w);
-extern void put_pixels_clamped_altivec(const DCTELEM *block, UINT8 *restrict pixels, int line_size);
+extern void put_pixels_clamped_altivec(const DCTELEM *block, uint8_t *restrict pixels, int line_size);
 extern void put_pixels16_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h);
 extern void avg_pixels16_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h);
 extern void avg_pixels8_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h);
@@ -48,7 +48,7 @@ extern void put_no_rnd_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels
 extern void put_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h);
 extern void put_no_rnd_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h);
 
-extern void gmc1_altivec(UINT8 *dst, UINT8 *src, int stride, int h, int x16, int y16, int rounder);
+extern void gmc1_altivec(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder);
 
 extern int has_altivec(void);
 

libavcodec/ppc/gmc_altivec.c

@@ -26,7 +26,7 @@
   altivec-enhanced gmc1. ATM this code assume stride is a multiple of 8,
   to preserve proper dst alignement.
 */
-void gmc1_altivec(UINT8 *dst /* align 8 */, UINT8 *src /* align1 */, int stride, int h, int x16, int y16, int rounder)
+void gmc1_altivec(uint8_t *dst /* align 8 */, uint8_t *src /* align1 */, int stride, int h, int x16, int y16, int rounder)
 {
 POWERPC_TBL_DECLARE(altivec_gmc1_num, h == 8);
 #ifdef ALTIVEC_USE_REFERENCE_C_CODE

libavcodec/ppc/idct_altivec.c

@@ -176,8 +176,8 @@ void idct_put_altivec(uint8_t* dest, int stride, vector_s16_t* block)
 POWERPC_TBL_DECLARE(altivec_idct_put_num, 1);
 #ifdef ALTIVEC_USE_REFERENCE_C_CODE
 POWERPC_TBL_START_COUNT(altivec_idct_put_num, 1);
-    void simple_idct_put(UINT8 *dest, int line_size, INT16 *block);
-    simple_idct_put(dest, stride, (INT16*)block);
+    void simple_idct_put(uint8_t *dest, int line_size, int16_t *block);
+    simple_idct_put(dest, stride, (int16_t*)block);
 POWERPC_TBL_STOP_COUNT(altivec_idct_put_num, 1);
 #else /* ALTIVEC_USE_REFERENCE_C_CODE */
     vector_u8_t tmp;
@@ -209,8 +209,8 @@ void idct_add_altivec(uint8_t* dest, int stride, vector_s16_t* block)
 POWERPC_TBL_DECLARE(altivec_idct_add_num, 1);
 #ifdef ALTIVEC_USE_REFERENCE_C_CODE
 POWERPC_TBL_START_COUNT(altivec_idct_add_num, 1);
-    void simple_idct_add(UINT8 *dest, int line_size, INT16 *block);
-    simple_idct_add(dest, stride, (INT16*)block);
+    void simple_idct_add(uint8_t *dest, int line_size, int16_t *block);
+    simple_idct_add(dest, stride, (int16_t*)block);
 POWERPC_TBL_STOP_COUNT(altivec_idct_add_num, 1);
 #else /* ALTIVEC_USE_REFERENCE_C_CODE */
     vector_u8_t tmp;

libavcodec/ppc/mpegvideo_ppc.c

@@ -30,8 +30,8 @@ extern int dct_quantize_altivec(MpegEncContext *s,
 extern void dct_unquantize_h263_altivec(MpegEncContext *s,
                                         DCTELEM *block, int n, int qscale);
 
-extern void idct_put_altivec(UINT8 *dest, int line_size, INT16 *block);
-extern void idct_add_altivec(UINT8 *dest, int line_size, INT16 *block);
+extern void idct_put_altivec(uint8_t *dest, int line_size, int16_t *block);
+extern void idct_add_altivec(uint8_t *dest, int line_size, int16_t *block);
 
 
 void MPV_common_init_ppc(MpegEncContext *s)

libavcodec/ps2/dsputil_mmi.c

@@ -41,7 +41,7 @@ static void clear_blocks_mmi(DCTELEM * blocks)
 }
 
 
-static void get_pixels_mmi(DCTELEM *block, const UINT8 *pixels, int line_size)
+static void get_pixels_mmi(DCTELEM *block, const uint8_t *pixels, int line_size)
 {
     int i;
     for(i=0;i<8;i++) {

libavcodec/ps2/idct_mmi.c

@@ -299,7 +299,7 @@ void ff_mmi_idct(int16_t * block)
 }
 
 
-void ff_mmi_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
+void ff_mmi_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
 {
     /* $4 = dest, $5 = line_size, $6 = block */
     __asm__ __volatile__("la $24, %0"::"m"(consttable[0]));
@@ -323,7 +323,7 @@ void ff_mmi_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
 }
 
 
-void ff_mmi_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
+void ff_mmi_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
 {
     /* $4 = dest, $5 = line_size, $6 = block */
     __asm__ __volatile__("la $24, %0"::"m"(consttable[0]));

libavcodec/ps2/mpegvideo_mmi.c

@@ -22,8 +22,8 @@
 #include "../mpegvideo.h"
 #include "../avcodec.h"
 
-void ff_mmi_idct_put(UINT8 *dest, int line_size, DCTELEM *block);
-void ff_mmi_idct_add(UINT8 *dest, int line_size, DCTELEM *block);
+void ff_mmi_idct_put(uint8_t *dest, int line_size, DCTELEM *block);
+void ff_mmi_idct_add(uint8_t *dest, int line_size, DCTELEM *block);
 
 
 static void dct_unquantize_h263_mmi(MpegEncContext *s, 

libavcodec/resample.c

@@ -20,8 +20,8 @@
 
 typedef struct {
     /* fractional resampling */
-    UINT32 incr; /* fractional increment */
-    UINT32 frac;
+    uint32_t incr; /* fractional increment */
+    uint32_t frac;
     int last_sample;
     /* integer down sample */
     int iratio;  /* integer divison ratio */

libavcodec/rv10.c

@@ -24,7 +24,7 @@
 
 #define DC_VLC_BITS 14 //FIXME find a better solution
 
-static const UINT16 rv_lum_code[256] =
+static const uint16_t rv_lum_code[256] =
 {
  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
@@ -60,7 +60,7 @@ static const UINT16 rv_lum_code[256] =
  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
 };
 
-static const UINT8 rv_lum_bits[256] = 
+static const uint8_t rv_lum_bits[256] = 
 {
  14, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12,
@@ -96,7 +96,7 @@ static const UINT8 rv_lum_bits[256] =
  12, 12, 12, 12, 12, 12, 12, 12,
 };
 
-static const UINT16 rv_chrom_code[256] =
+static const uint16_t rv_chrom_code[256] =
 {
  0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
  0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
@@ -132,7 +132,7 @@ static const UINT16 rv_chrom_code[256] =
  0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
 };
 
-static const UINT8 rv_chrom_bits[256] =
+static const uint8_t rv_chrom_bits[256] =
 {
  16, 14, 14, 14, 14, 14, 14, 14,
  14, 14, 14, 14, 14, 14, 14, 14,
@@ -182,14 +182,14 @@ int rv_decode_dc(MpegEncContext *s, int n)
                if they had thought about it !!! */
             code = get_bits(&s->gb, 7);
             if (code == 0x7c) {
-                code = (INT8)(get_bits(&s->gb, 7) + 1);
+                code = (int8_t)(get_bits(&s->gb, 7) + 1);
             } else if (code == 0x7d) {
                 code = -128 + get_bits(&s->gb, 7);
             } else if (code == 0x7e) {
                 if (get_bits(&s->gb, 1) == 0)
-                    code = (INT8)(get_bits(&s->gb, 8) + 1);
+                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
                 else
-                    code = (INT8)(get_bits(&s->gb, 8));
+                    code = (int8_t)(get_bits(&s->gb, 8));
             } else if (code == 0x7f) {
                 get_bits(&s->gb, 11);
                 code = 1;
@@ -203,7 +203,7 @@ int rv_decode_dc(MpegEncContext *s, int n)
         if (code < 0) {
             code = get_bits(&s->gb, 9);
             if (code == 0x1fc) {
-                code = (INT8)(get_bits(&s->gb, 7) + 1);
+                code = (int8_t)(get_bits(&s->gb, 7) + 1);
             } else if (code == 0x1fd) {
                 code = -128 + get_bits(&s->gb, 7);
             } else if (code == 0x1fe) {
@@ -390,7 +390,7 @@ static int rv10_decode_end(AVCodecContext *avctx)
 }
 
 static int rv10_decode_packet(AVCodecContext *avctx, 
-                             UINT8 *buf, int buf_size)
+                             uint8_t *buf, int buf_size)
 {
     MpegEncContext *s = avctx->priv_data;
     int i, mb_count, mb_pos, left;
@@ -468,7 +468,7 @@ static int rv10_decode_packet(AVCodecContext *avctx,
 
 static int rv10_decode_frame(AVCodecContext *avctx, 
                              void *data, int *data_size,
-                             UINT8 *buf, int buf_size)
+                             uint8_t *buf, int buf_size)
 {
     MpegEncContext *s = avctx->priv_data;
     int i;

libavcodec/simple_idct.c

@@ -172,11 +172,11 @@ static inline void idctRowCondDC (DCTELEM * row)
 	row[4] = (a3 - b3) >> ROW_SHIFT;
 }
 
-static inline void idctSparseColPut (UINT8 *dest, int line_size, 
+static inline void idctSparseColPut (uint8_t *dest, int line_size, 
                                      DCTELEM * col)
 {
 	int a0, a1, a2, a3, b0, b1, b2, b3;
-        UINT8 *cm = cropTbl + MAX_NEG_CROP;
+        uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
         /* XXX: I did that only to give same values as previous code */
 	a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
@@ -244,11 +244,11 @@ static inline void idctSparseColPut (UINT8 *dest, int line_size,
         dest[0] = cm[(a0 - b0) >> COL_SHIFT];
 }
 
-static inline void idctSparseColAdd (UINT8 *dest, int line_size, 
+static inline void idctSparseColAdd (uint8_t *dest, int line_size, 
                                      DCTELEM * col)
 {
 	int a0, a1, a2, a3, b0, b1, b2, b3;
-        UINT8 *cm = cropTbl + MAX_NEG_CROP;
+        uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
         /* XXX: I did that only to give same values as previous code */
 	a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
@@ -379,7 +379,7 @@ static inline void idctSparseCol (DCTELEM * col)
         col[56] = ((a0 - b0) >> COL_SHIFT);
 }
 
-void simple_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
+void simple_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
 {
     int i;
     for(i=0; i<8; i++)
@@ -389,7 +389,7 @@ void simple_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
         idctSparseColPut(dest + i, line_size, block + i);
 }
 
-void simple_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
+void simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
 {
     int i;
     for(i=0; i<8; i++)
@@ -420,10 +420,10 @@ void simple_idct(DCTELEM *block)
    and the butterfly must be multiplied by 0.5 * sqrt(2.0) */
 #define C_SHIFT (4+1+12)
 
-static inline void idct4col(UINT8 *dest, int line_size, const DCTELEM *col)
+static inline void idct4col(uint8_t *dest, int line_size, const DCTELEM *col)
 {
     int c0, c1, c2, c3, a0, a1, a2, a3;
-    const UINT8 *cm = cropTbl + MAX_NEG_CROP;
+    const uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
     a0 = col[8*0];
     a1 = col[8*2];
@@ -457,7 +457,7 @@ static inline void idct4col(UINT8 *dest, int line_size, const DCTELEM *col)
 /* XXX: I think a 1.0/sqrt(2) normalization should be needed to
    compensate the extra butterfly stage - I don't have the full DV
    specification */
-void simple_idct248_put(UINT8 *dest, int line_size, DCTELEM *block)
+void simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block)
 {
     int i;
     DCTELEM *ptr;
@@ -500,10 +500,10 @@ void simple_idct248_put(UINT8 *dest, int line_size, DCTELEM *block)
 #define C2 C_FIX(0.2705980501)
 #define C3 C_FIX(0.5)
 #define C_SHIFT (4+1+12)
-static inline void idct4col_add(UINT8 *dest, int line_size, const DCTELEM *col)
+static inline void idct4col_add(uint8_t *dest, int line_size, const DCTELEM *col)
 {
     int c0, c1, c2, c3, a0, a1, a2, a3;
-    const UINT8 *cm = cropTbl + MAX_NEG_CROP;
+    const uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
     a0 = col[8*0];
     a1 = col[8*1];
@@ -531,7 +531,7 @@ static inline void idct4col_add(UINT8 *dest, int line_size, const DCTELEM *col)
 static inline void idct4row(DCTELEM *row)
 {
     int c0, c1, c2, c3, a0, a1, a2, a3;
-    const UINT8 *cm = cropTbl + MAX_NEG_CROP;
+    //const uint8_t *cm = cropTbl + MAX_NEG_CROP;
 
     a0 = row[0];
     a1 = row[1];
@@ -547,7 +547,7 @@ static inline void idct4row(DCTELEM *row)
     row[3]= (c0 - c1) >> R_SHIFT;
 }
 
-void simple_idct84_add(UINT8 *dest, int line_size, DCTELEM *block)
+void simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block)
 {
     int i;
 
@@ -562,7 +562,7 @@ void simple_idct84_add(UINT8 *dest, int line_size, DCTELEM *block)
     }
 }
 
-void simple_idct48_add(UINT8 *dest, int line_size, DCTELEM *block)
+void simple_idct48_add(uint8_t *dest, int line_size, DCTELEM *block)
 {
     int i;
 

libavcodec/simple_idct.h

@@ -18,14 +18,14 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-void simple_idct_put(UINT8 *dest, int line_size, DCTELEM *block);
-void simple_idct_add(UINT8 *dest, int line_size, DCTELEM *block);
+void simple_idct_put(uint8_t *dest, int line_size, DCTELEM *block);
+void simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block);
 void ff_simple_idct_mmx(int16_t *block);
-void ff_simple_idct_add_mmx(UINT8 *dest, int line_size, int16_t *block);
-void ff_simple_idct_put_mmx(UINT8 *dest, int line_size, int16_t *block);
+void ff_simple_idct_add_mmx(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct_put_mmx(uint8_t *dest, int line_size, int16_t *block);
 void simple_idct(DCTELEM *block);
 
-void simple_idct248_put(UINT8 *dest, int line_size, DCTELEM *block);
+void simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block);
 
-void simple_idct84_add(UINT8 *dest, int line_size, DCTELEM *block);
-void simple_idct48_add(UINT8 *dest, int line_size, DCTELEM *block);
+void simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block);
+void simple_idct48_add(uint8_t *dest, int line_size, DCTELEM *block);

libavcodec/svq1.c

@@ -1083,7 +1083,7 @@ static int svq1_decode_frame_header (bit_buffer_t *bitbuf,MpegEncContext *s) {
 
 static int svq1_decode_frame(AVCodecContext *avctx, 
                              void *data, int *data_size,
-                             UINT8 *buf, int buf_size)
+                             uint8_t *buf, int buf_size)
 {
   MpegEncContext *s=avctx->priv_data;
   uint8_t      *current, *previous;

libavcodec/utils.c

@@ -285,7 +285,7 @@ int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
     return 0;
 }
 
-int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
+int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
                          const short *samples)
 {
     int ret;
@@ -295,7 +295,7 @@ int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size,
     return ret;
 }
 
-int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
+int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, 
                          const AVFrame *pict)
 {
     int ret;
@@ -313,7 +313,7 @@ int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size,
    zero. Otherwise, it is non zero */
 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, 
                          int *got_picture_ptr,
-                         UINT8 *buf, int buf_size)
+                         uint8_t *buf, int buf_size)
 {
     int ret;
     
@@ -331,9 +331,9 @@ int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
    *number of bytes used. If no frame could be decompressed,
    *frame_size_ptr is zero. Otherwise, it is the decompressed frame
    *size in BYTES. */
-int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, 
+int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples, 
                          int *frame_size_ptr,
-                         UINT8 *buf, int buf_size)
+                         uint8_t *buf, int buf_size)
 {
     int ret;
 
@@ -589,7 +589,7 @@ static int raw_encode_init(AVCodecContext *s)
 
 static int raw_decode_frame(AVCodecContext *avctx,
 			    void *data, int *data_size,
-			    UINT8 *buf, int buf_size)
+			    uint8_t *buf, int buf_size)
 {
     return -1;
 }

libavcodec/wmadec.c

@@ -1215,7 +1215,7 @@ static int wma_decode_frame(WMADecodeContext *s, int16_t *samples)
 
 static int wma_decode_superframe(AVCodecContext *avctx, 
                                  void *data, int *data_size,
-                                 UINT8 *buf, int buf_size)
+                                 uint8_t *buf, int buf_size)
 {
     WMADecodeContext *s = avctx->priv_data;
     int nb_frames, bit_offset, i, pos, len;

libavcodec/wmv2.c

@@ -192,7 +192,7 @@ void ff_wmv2_encode_mb(MpegEncContext * s,
     Wmv2Context * const w= (Wmv2Context*)s;
     int cbp, coded_cbp, i;
     int pred_x, pred_y;
-    UINT8 *coded_block;
+    uint8_t *coded_block;
 
     handle_slices(s);
     
@@ -491,7 +491,7 @@ static inline int wmv2_decode_motion(Wmv2Context *w, int *mx_ptr, int *my_ptr){
 static int16_t *wmv2_pred_motion(Wmv2Context *w, int *px, int *py){
     MpegEncContext * const s= &w->s;
     int xy, wrap, diff, type;
-    INT16 *A, *B, *C, *mot_val;
+    int16_t *A, *B, *C, *mot_val;
 
     wrap = s->block_wrap[0];
     xy = s->block_index[0];
@@ -576,8 +576,7 @@ static inline int wmv2_decode_inter_block(Wmv2Context *w, DCTELEM *block, int n,
 static void wmv2_add_block(Wmv2Context *w, DCTELEM *block1, uint8_t *dst, int stride, int n){
     MpegEncContext * const s= &w->s;
     uint8_t temp[2][64];
-    int i;
-        
+
     switch(w->abt_type_table[n]){
     case 0:
         if (s->block_last_index[n] >= 0) {
@@ -614,12 +613,12 @@ void ff_wmv2_add_mb(MpegEncContext *s, DCTELEM block1[6][64], uint8_t *dest_y, u
 }
 
 void ff_mspel_motion(MpegEncContext *s,
-                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
-                               UINT8 **ref_picture, op_pixels_func (*pix_op)[4],
+                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
+                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
                                int motion_x, int motion_y, int h)
 {
     Wmv2Context * const w= (Wmv2Context*)s;
-    UINT8 *ptr;
+    uint8_t *ptr;
     int dxy, offset, mx, my, src_x, src_y, v_edge_pos, linesize, uvlinesize;
     int emu=0;
     
@@ -700,7 +699,7 @@ static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 {
     Wmv2Context * const w= (Wmv2Context*)s;
     int cbp, code, i;
-    UINT8 *coded_val;
+    uint8_t *coded_val;
 
     if(w->j_type) return 0;
     

libavformat/asf.c

@@ -31,7 +31,7 @@ typedef struct {
     AVPacket pkt;
     int frag_offset;
     int timestamp;
-    INT64 duration;
+    int64_t duration;
 
     int ds_span;		/* descrambling  */
     int ds_packet_size;
@@ -42,10 +42,10 @@ typedef struct {
 } ASFStream;
 
 typedef struct {
-    UINT32 v1;
-    UINT16 v2;
-    UINT16 v3;
-    UINT8 v4[8];
+    uint32_t v1;
+    uint16_t v2;
+    uint16_t v3;
+    uint8_t v4[8];
 } GUID;
 
 typedef struct __attribute__((packed)) {
@@ -83,14 +83,14 @@ typedef struct {
     int asfid2avid[128];        /* conversion table from asf ID 2 AVStream ID */
     ASFStream streams[128];	/* it's max number and it's not that big */
     /* non streamed additonnal info */
-    INT64 nb_packets;
-    INT64 duration; /* in 100ns units */
+    int64_t nb_packets;
+    int64_t duration; /* in 100ns units */
     /* packet filling */
     int packet_size_left;
     int packet_timestamp_start;
     int packet_timestamp_end;
     int packet_nb_frames;
-    UINT8 packet_buf[PACKET_SIZE];
+    uint8_t packet_buf[PACKET_SIZE];
     ByteIOContext pb;
     /* only for reading */
     uint64_t data_offset; /* begining of the first data packet */
@@ -199,7 +199,7 @@ static void put_str16(ByteIOContext *s, const char *tag)
 
     put_le16(s,strlen(tag) + 1);
     for(;;) {
-        c = (UINT8)*tag++;
+        c = (uint8_t)*tag++;
         put_le16(s, c);
         if (c == '\0')
             break;
@@ -211,16 +211,16 @@ static void put_str16_nolen(ByteIOContext *s, const char *tag)
     int c;
 
     for(;;) {
-        c = (UINT8)*tag++;
+        c = (uint8_t)*tag++;
         put_le16(s, c);
         if (c == '\0')
             break;
     }
 }
 
-static INT64 put_header(ByteIOContext *pb, const GUID *g)
+static int64_t put_header(ByteIOContext *pb, const GUID *g)
 {
-    INT64 pos;
+    int64_t pos;
 
     pos = url_ftell(pb);
     put_guid(pb, g);
@@ -229,9 +229,9 @@ static INT64 put_header(ByteIOContext *pb, const GUID *g)
 }
 
 /* update header size */
-static void end_header(ByteIOContext *pb, INT64 pos)
+static void end_header(ByteIOContext *pb, int64_t pos)
 {
-    INT64 pos1;
+    int64_t pos1;
 
     pos1 = url_ftell(pb);
     url_fseek(pb, pos + 16, SEEK_SET);
@@ -256,24 +256,24 @@ static void put_chunk(AVFormatContext *s, int type, int payload_length, int flag
 }
 
 /* convert from unix to windows time */
-static INT64 unix_to_file_time(int ti)
+static int64_t unix_to_file_time(int ti)
 {
-    INT64 t;
+    int64_t t;
 
-    t = ti * INT64_C(10000000);
-    t += INT64_C(116444736000000000);
+    t = ti * int64_t_C(10000000);
+    t += int64_t_C(116444736000000000);
     return t;
 }
 
 /* write the header (used two times if non streamed) */
-static int asf_write_header1(AVFormatContext *s, INT64 file_size, INT64 data_chunk_size)
+static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data_chunk_size)
 {
     ASFContext *asf = s->priv_data;
     ByteIOContext *pb = &s->pb;
     int header_size, n, extra_size, extra_size2, wav_extra_size, file_time;
     int has_title;
     AVCodecContext *enc;
-    INT64 header_offset, cur_pos, hpos;
+    int64_t header_offset, cur_pos, hpos;
     int bit_rate;
 
     has_title = (s->title[0] || s->author[0] || s->copyright[0] || s->comment[0]);
@@ -337,7 +337,7 @@ static int asf_write_header1(AVFormatContext *s, INT64 file_size, INT64 data_chu
 
     /* stream headers */
     for(n=0;n<s->nb_streams;n++) {
-        INT64 es_pos;
+        int64_t es_pos;
         //        ASFStream *stream = &asf->streams[n];
 
         enc = &s->streams[n]->codec;
@@ -574,7 +574,7 @@ static void put_frame_header(AVFormatContext *s, ASFStream *stream, int timestam
    crap. They have misread the MPEG Systems spec !
  */
 static void put_frame(AVFormatContext *s, ASFStream *stream, int timestamp,
-                      UINT8 *buf, int payload_size)
+                      uint8_t *buf, int payload_size)
 {
     ASFContext *asf = s->priv_data;
     int frag_pos, frag_len, frag_len1;
@@ -607,22 +607,22 @@ static void put_frame(AVFormatContext *s, ASFStream *stream, int timestamp,
 
 
 static int asf_write_packet(AVFormatContext *s, int stream_index,
-                            UINT8 *buf, int size, int timestamp)
+                            uint8_t *buf, int size, int timestamp)
 {
     ASFContext *asf = s->priv_data;
     ASFStream *stream;
-    INT64 duration;
+    int64_t duration;
     AVCodecContext *codec;
 
     codec = &s->streams[stream_index]->codec;
     stream = &asf->streams[stream_index];
 
     if (codec->codec_type == CODEC_TYPE_AUDIO) {
-        duration = (codec->frame_number * codec->frame_size * INT64_C(10000000)) /
+        duration = (codec->frame_number * codec->frame_size * int64_t_C(10000000)) /
             codec->sample_rate;
     } else {
         duration = codec->frame_number *
-            ((INT64_C(10000000) * FRAME_RATE_BASE) / codec->frame_rate);
+            ((int64_t_C(10000000) * FRAME_RATE_BASE) / codec->frame_rate);
     }
     if (duration > asf->duration)
         asf->duration = duration;
@@ -634,7 +634,7 @@ static int asf_write_packet(AVFormatContext *s, int stream_index,
 static int asf_write_trailer(AVFormatContext *s)
 {
     ASFContext *asf = s->priv_data;
-    INT64 file_size;
+    int64_t file_size;
 
     /* flush the current packet */
     if (asf->pb.buf_ptr > asf->pb.buffer)
@@ -746,7 +746,7 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
     AVStream *st;
     ASFStream *asf_st;
     int size, i;
-    INT64 gsize;
+    int64_t gsize;
 
     av_set_pts_info(s, 32, 1, 1000); /* 32 bit pts in ms */
 
@@ -786,7 +786,7 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
         } else if (!memcmp(&g, &stream_header, sizeof(GUID))) {
             int type, total_size;
             unsigned int tag1;
-            INT64 pos1, pos2;
+            int64_t pos1, pos2;
 
             pos1 = url_ftell(pb);
 

libavformat/au.c

@@ -29,7 +29,7 @@
 #include "avi.h"
 
 /* if we don't know the size in advance */
-#define AU_UNKOWN_SIZE ((UINT32)(~0))
+#define AU_UNKOWN_SIZE ((uint32_t)(~0))
 
 /* The ffmpeg codecs we support, and the IDs they have in the file */
 static const CodecTag codec_au_tags[] = {
@@ -50,9 +50,9 @@ static int put_au_header(ByteIOContext *pb, AVCodecContext *enc)
     put_tag(pb, ".snd");       /* magic number */
     put_be32(pb, 24);           /* header size */
     put_be32(pb, AU_UNKOWN_SIZE); /* data size */
-    put_be32(pb, (UINT32)tag);     /* codec ID */
+    put_be32(pb, (uint32_t)tag);     /* codec ID */
     put_be32(pb, enc->sample_rate);
-    put_be32(pb, (UINT32)enc->channels);
+    put_be32(pb, (uint32_t)enc->channels);
     return 0;
 }
 
@@ -73,7 +73,7 @@ static int au_write_header(AVFormatContext *s)
 }
 
 static int au_write_packet(AVFormatContext *s, int stream_index_ptr,
-                           UINT8 *buf, int size, int force_pts)
+                           uint8_t *buf, int size, int force_pts)
 {
     ByteIOContext *pb = &s->pb;
     put_buffer(pb, buf, size);
@@ -90,7 +90,7 @@ static int au_write_trailer(AVFormatContext *s)
         /* update file size */
         file_size = url_ftell(pb);
         url_fseek(pb, 8, SEEK_SET);
-        put_be32(pb, (UINT32)(file_size - 24));
+        put_be32(pb, (uint32_t)(file_size - 24));
         url_fseek(pb, file_size, SEEK_SET);
 
         put_flush_packet(pb);

libavformat/audio.c

@@ -37,7 +37,7 @@ typedef struct {
     int frame_size; /* in bytes ! */
     int codec_id;
     int flip_left : 1;
-    UINT8 buffer[AUDIO_BLOCK_SIZE];
+    uint8_t buffer[AUDIO_BLOCK_SIZE];
     int buffer_ptr;
 } AudioData;
 
@@ -165,7 +165,7 @@ static int audio_write_header(AVFormatContext *s1)
 }
 
 static int audio_write_packet(AVFormatContext *s1, int stream_index,
-                              UINT8 *buf, int size, int force_pts)
+                              uint8_t *buf, int size, int force_pts)
 {
     AudioData *s = s1->priv_data;
     int len, ret;

libavformat/avformat.h

@@ -18,8 +18,8 @@ extern "C" {
 #define AV_NOPTS_VALUE 0
 
 typedef struct AVPacket {
-    INT64 pts; /* presentation time stamp in stream units (set av_set_pts_info) */
-    UINT8 *data;
+    int64_t pts; /* presentation time stamp in stream units (set av_set_pts_info) */
+    uint8_t *data;
     int   size;
     int   stream_index;
     int   flags;
@@ -54,12 +54,12 @@ static inline void av_free_packet(AVPacket *pkt)
 /* the exact value of the fractional number is: 'val + num / den'. num
    is assumed to be such as 0 <= num < den */
 typedef struct AVFrac {
-    INT64 val, num, den; 
+    int64_t val, num, den; 
 } AVFrac;
 
-void av_frac_init(AVFrac *f, INT64 val, INT64 num, INT64 den);
-void av_frac_add(AVFrac *f, INT64 incr);
-void av_frac_set(AVFrac *f, INT64 val);
+void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
+void av_frac_add(AVFrac *f, int64_t incr);
+void av_frac_set(AVFrac *f, int64_t val);
 
 /*************************************************/
 /* input/output formats */
@@ -141,7 +141,7 @@ typedef struct AVInputFormat {
     int (*read_close)(struct AVFormatContext *);
     /* seek at or before a given pts (given in microsecond). The pts
        origin is defined by the stream */
-    int (*read_seek)(struct AVFormatContext *, INT64 pts);
+    int (*read_seek)(struct AVFormatContext *, int64_t pts);
     /* can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_NOHEADER */
     int flags;
     /* if extensions are defined, then no probe is done. You should
@@ -337,20 +337,20 @@ AVOutputFormat *guess_stream_format(const char *short_name,
 AVOutputFormat *guess_format(const char *short_name, 
                              const char *filename, const char *mime_type);
 
-void av_hex_dump(UINT8 *buf, int size);
+void av_hex_dump(uint8_t *buf, int size);
 
 void av_register_all(void);
 
 typedef struct FifoBuffer {
-    UINT8 *buffer;
-    UINT8 *rptr, *wptr, *end;
+    uint8_t *buffer;
+    uint8_t *rptr, *wptr, *end;
 } FifoBuffer;
 
 int fifo_init(FifoBuffer *f, int size);
 void fifo_free(FifoBuffer *f);
-int fifo_size(FifoBuffer *f, UINT8 *rptr);
-int fifo_read(FifoBuffer *f, UINT8 *buf, int buf_size, UINT8 **rptr_ptr);
-void fifo_write(FifoBuffer *f, UINT8 *buf, int size, UINT8 **wptr_ptr);
+int fifo_size(FifoBuffer *f, uint8_t *rptr);
+int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr);
+void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr);
 
 /* media file input */
 AVInputFormat *av_find_input_format(const char *short_name);
@@ -386,9 +386,9 @@ void dump_format(AVFormatContext *ic,
                  const char *url,
                  int is_output);
 int parse_image_size(int *width_ptr, int *height_ptr, const char *str);
-INT64 parse_date(const char *datestr, int duration);
+int64_t parse_date(const char *datestr, int duration);
 
-INT64 av_gettime(void);
+int64_t av_gettime(void);
 
 /* ffm specific for ffserver */
 #define FFM_PACKET_SIZE 4096

libavformat/avidec.c

@@ -28,7 +28,7 @@ typedef struct AVIIndex {
 } AVIIndex;
 
 typedef struct {
-    INT64 movi_end;
+    int64_t movi_end;
     offset_t movi_list;
     AVIIndex *first, *last;
 } AVIContext;
@@ -49,7 +49,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
 {
     AVIContext *avi = s->priv_data;
     ByteIOContext *pb = &s->pb;
-    UINT32 tag, tag1;
+    uint32_t tag, tag1;
     int codec_type, stream_index, frame_period, bit_rate;
     unsigned int size;
     int i;
@@ -144,7 +144,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
                     st->codec.width = get_le32(pb);
                     st->codec.height = get_le32(pb);
                     if (frame_period)
-                        st->codec.frame_rate = (INT64_C(1000000) * FRAME_RATE_BASE) / frame_period;
+                        st->codec.frame_rate = (int64_t_C(1000000) * FRAME_RATE_BASE) / frame_period;
                     else
                         st->codec.frame_rate = 25 * FRAME_RATE_BASE;
                     get_le16(pb); /* panes */

libavformat/avienc.c

@@ -49,7 +49,7 @@ void end_tag(ByteIOContext *pb, offset_t start)
 
     pos = url_ftell(pb);
     url_fseek(pb, start - 4, SEEK_SET);
-    put_le32(pb, (UINT32)(pos - start));
+    put_le32(pb, (uint32_t)(pos - start));
     url_fseek(pb, pos, SEEK_SET);
 }
 
@@ -211,7 +211,7 @@ static int avi_write_header(AVFormatContext *s)
     nb_frames = 0;
 
     if(video_enc){
-    put_le32(pb, (UINT32)(INT64_C(1000000) * FRAME_RATE_BASE / video_enc->frame_rate));
+    put_le32(pb, (uint32_t)(int64_t_C(1000000) * FRAME_RATE_BASE / video_enc->frame_rate));
     } else {
 	put_le32(pb, 0);
     }
@@ -320,7 +320,7 @@ static int avi_write_header(AVFormatContext *s)
 }
 
 static int avi_write_packet(AVFormatContext *s, int stream_index,
-                            UINT8 *buf, int size, int force_pts)
+                            uint8_t *buf, int size, int force_pts)
 {
     AVIContext *avi = s->priv_data;
     ByteIOContext *pb = &s->pb;
@@ -395,7 +395,7 @@ static int avi_write_trailer(AVFormatContext *s)
         /* update file size */
         file_size = url_ftell(pb);
         url_fseek(pb, 4, SEEK_SET);
-        put_le32(pb, (UINT32)(file_size - 8));
+        put_le32(pb, (uint32_t)(file_size - 8));
 
         /* Fill in frame/sample counters */
         nb_frames = 0;

libavformat/avio.h

@@ -3,7 +3,7 @@
 
 /* output byte stream handling */
 
-typedef INT64 offset_t;
+typedef int64_t offset_t;
 
 /* unbuffered I/O */
 
@@ -60,8 +60,8 @@ typedef struct {
     int buffer_size;
     unsigned char *buf_ptr, *buf_end;
     void *opaque;
-    int (*read_packet)(void *opaque, UINT8 *buf, int buf_size);
-    void (*write_packet)(void *opaque, UINT8 *buf, int buf_size);
+    int (*read_packet)(void *opaque, uint8_t *buf, int buf_size);
+    void (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
     int (*seek)(void *opaque, offset_t offset, int whence);
     offset_t pos; /* position in the file of the current buffer */
     int must_flush; /* true if the next seek should flush */
@@ -76,14 +76,14 @@ int init_put_byte(ByteIOContext *s,
                   int buffer_size,
                   int write_flag,
                   void *opaque,
-                  int (*read_packet)(void *opaque, UINT8 *buf, int buf_size),
-                  void (*write_packet)(void *opaque, UINT8 *buf, int buf_size),
+                  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
+                  void (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
                   int (*seek)(void *opaque, offset_t offset, int whence));
 
 void put_byte(ByteIOContext *s, int b);
 void put_buffer(ByteIOContext *s, const unsigned char *buf, int size);
-void put_le64(ByteIOContext *s, UINT64 val);
-void put_be64(ByteIOContext *s, UINT64 val);
+void put_le64(ByteIOContext *s, uint64_t val);
+void put_be64(ByteIOContext *s, uint64_t val);
 void put_le32(ByteIOContext *s, unsigned int val);
 void put_be32(ByteIOContext *s, unsigned int val);
 void put_le16(ByteIOContext *s, unsigned int val);
@@ -108,14 +108,14 @@ void put_flush_packet(ByteIOContext *s);
 int get_buffer(ByteIOContext *s, unsigned char *buf, int size);
 int get_byte(ByteIOContext *s);
 unsigned int get_le32(ByteIOContext *s);
-UINT64 get_le64(ByteIOContext *s);
+uint64_t get_le64(ByteIOContext *s);
 unsigned int get_le16(ByteIOContext *s);
 
 double get_be64_double(ByteIOContext *s);
 char *get_strz(ByteIOContext *s, char *buf, int maxlen);
 unsigned int get_be16(ByteIOContext *s);
 unsigned int get_be32(ByteIOContext *s);
-UINT64 get_be64(ByteIOContext *s);
+uint64_t get_be64(ByteIOContext *s);
 
 static inline int url_is_streamed(ByteIOContext *s)
 {
@@ -129,12 +129,12 @@ int url_fclose(ByteIOContext *s);
 URLContext *url_fileno(ByteIOContext *s);
 int url_fget_max_packet_size(ByteIOContext *s);
 
-int url_open_buf(ByteIOContext *s, UINT8 *buf, int buf_size, int flags);
+int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags);
 int url_close_buf(ByteIOContext *s);
 
 int url_open_dyn_buf(ByteIOContext *s);
 int url_open_dyn_packet_buf(ByteIOContext *s, int max_packet_size);
-int url_close_dyn_buf(ByteIOContext *s, UINT8 **pbuffer);
+int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer);
 
 /* file.c */
 extern URLProtocol file_protocol;

libavformat/aviobuf.c

@@ -27,8 +27,8 @@ int init_put_byte(ByteIOContext *s,
                   int buffer_size,
                   int write_flag,
                   void *opaque,
-                  int (*read_packet)(void *opaque, UINT8 *buf, int buf_size),
-                  void (*write_packet)(void *opaque, UINT8 *buf, int buf_size),
+                  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
+                  void (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
                   int (*seek)(void *opaque, offset_t offset, int whence))
 {
     s->buffer = buffer;
@@ -182,7 +182,7 @@ void put_be64_double(ByteIOContext *s, double val)
 {
     union {
         double d;
-        UINT64 ull;
+        uint64_t ull;
     } u;
     u.d = val;
     put_be64(s, u.ull);
@@ -196,16 +196,16 @@ void put_strz(ByteIOContext *s, const char *str)
         put_byte(s, 0);
 }
 
-void put_le64(ByteIOContext *s, UINT64 val)
+void put_le64(ByteIOContext *s, uint64_t val)
 {
-    put_le32(s, (UINT32)(val & 0xffffffff));
-    put_le32(s, (UINT32)(val >> 32));
+    put_le32(s, (uint32_t)(val & 0xffffffff));
+    put_le32(s, (uint32_t)(val >> 32));
 }
 
-void put_be64(ByteIOContext *s, UINT64 val)
+void put_be64(ByteIOContext *s, uint64_t val)
 {
-    put_be32(s, (UINT32)(val >> 32));
-    put_be32(s, (UINT32)(val & 0xffffffff));
+    put_be32(s, (uint32_t)(val >> 32));
+    put_be32(s, (uint32_t)(val & 0xffffffff));
 }
 
 void put_le16(ByteIOContext *s, unsigned int val)
@@ -320,11 +320,11 @@ unsigned int get_le32(ByteIOContext *s)
     return val;
 }
 
-UINT64 get_le64(ByteIOContext *s)
+uint64_t get_le64(ByteIOContext *s)
 {
-    UINT64 val;
-    val = (UINT64)get_le32(s);
-    val |= (UINT64)get_le32(s) << 32;
+    uint64_t val;
+    val = (uint64_t)get_le32(s);
+    val |= (uint64_t)get_le32(s) << 32;
     return val;
 }
 
@@ -350,7 +350,7 @@ double get_be64_double(ByteIOContext *s)
 {
     union {
         double d;
-        UINT64 ull;
+        uint64_t ull;
     } u;
 
     u.ull = get_be64(s);
@@ -372,29 +372,29 @@ char *get_strz(ByteIOContext *s, char *buf, int maxlen)
     return buf;
 }
 
-UINT64 get_be64(ByteIOContext *s)
+uint64_t get_be64(ByteIOContext *s)
 {
-    UINT64 val;
-    val = (UINT64)get_be32(s) << 32;
-    val |= (UINT64)get_be32(s);
+    uint64_t val;
+    val = (uint64_t)get_be32(s) << 32;
+    val |= (uint64_t)get_be32(s);
     return val;
 }
 
 /* link with avio functions */
 
-static void url_write_packet(void *opaque, UINT8 *buf, int buf_size)
+static void url_write_packet(void *opaque, uint8_t *buf, int buf_size)
 {
     URLContext *h = opaque;
     url_write(h, buf, buf_size);
 }
 
-static int url_read_packet(void *opaque, UINT8 *buf, int buf_size)
+static int url_read_packet(void *opaque, uint8_t *buf, int buf_size)
 {
     URLContext *h = opaque;
     return url_read(h, buf, buf_size);
 }
 
-static int url_seek_packet(void *opaque, INT64 offset, int whence)
+static int url_seek_packet(void *opaque, int64_t offset, int whence)
 {
     URLContext *h = opaque;
     url_seek(h, offset, whence);
@@ -403,7 +403,7 @@ static int url_seek_packet(void *opaque, INT64 offset, int whence)
 
 int url_fdopen(ByteIOContext *s, URLContext *h)
 {
-    UINT8 *buffer;
+    uint8_t *buffer;
     int buffer_size, max_packet_size;
 
     
@@ -431,7 +431,7 @@ int url_fdopen(ByteIOContext *s, URLContext *h)
 /* XXX: must be called before any I/O */
 int url_setbufsize(ByteIOContext *s, int buf_size)
 {
-    UINT8 *buffer;
+    uint8_t *buffer;
     buffer = av_malloc(buf_size);
     if (!buffer)
         return -ENOMEM;
@@ -530,7 +530,7 @@ int url_fget_max_packet_size(ByteIOContext *s)
 }
 
 /* buffer handling */
-int url_open_buf(ByteIOContext *s, UINT8 *buf, int buf_size, int flags)
+int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags)
 {
     return init_put_byte(s, buf, buf_size, 
                          (flags & URL_WRONLY) != 0, NULL, NULL, NULL, NULL);
@@ -547,16 +547,16 @@ int url_close_buf(ByteIOContext *s)
 
 typedef struct DynBuffer {
     int pos, size, allocated_size;
-    UINT8 *buffer;
+    uint8_t *buffer;
     int io_buffer_size;
-    UINT8 io_buffer[1];
+    uint8_t io_buffer[1];
 } DynBuffer;
 
-static void dyn_buf_write(void *opaque, UINT8 *buf, int buf_size)
+static void dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
 {
     DynBuffer *d = opaque;
     int new_size, new_allocated_size;
-    UINT8 *new_buffer;
+    uint8_t *new_buffer;
     
     /* reallocate buffer if needed */
     new_size = d->pos + buf_size;
@@ -583,7 +583,7 @@ static void dyn_buf_write(void *opaque, UINT8 *buf, int buf_size)
         d->size = d->pos;
 }
 
-static void dyn_packet_buf_write(void *opaque, UINT8 *buf, int buf_size)
+static void dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
 {
     unsigned char buf1[4];
 
@@ -674,7 +674,7 @@ int url_open_dyn_packet_buf(ByteIOContext *s, int max_packet_size)
  * @param pointer to a byte buffer
  * @return the length of the byte buffer
  */
-int url_close_dyn_buf(ByteIOContext *s, UINT8 **pbuffer)
+int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer)
 {
     DynBuffer *d = s->opaque;
     int size;

libavformat/crc.c

@@ -33,7 +33,7 @@
 #define DO8(buf)  DO4(buf); DO4(buf);
 #define DO16(buf) DO8(buf); DO8(buf);
 
-static UINT32 adler32(UINT32 adler, UINT8 *buf, unsigned int len)
+static uint32_t adler32(uint32_t adler, uint8_t *buf, unsigned int len)
 {
     unsigned long s1 = adler & 0xffff;
     unsigned long s2 = (adler >> 16) & 0xffff;
@@ -58,7 +58,7 @@ static UINT32 adler32(UINT32 adler, UINT8 *buf, unsigned int len)
 }
 
 typedef struct CRCState {
-    UINT32 crcval;
+    uint32_t crcval;
 } CRCState;
 
 static int crc_write_header(struct AVFormatContext *s)

libavformat/dv1394.c

@@ -46,7 +46,7 @@ struct dv1394_data {
     int done;   /* Number of completed frames */
 
     int stream; /* Current stream. 0 - video, 1 - audio */
-    INT64 pts;  /* Current timestamp */
+    int64_t pts;  /* Current timestamp */
 };
 
 static int dv1394_reset(struct dv1394_data *dv)

libavformat/ffm.c

@@ -28,7 +28,7 @@
 #define FLAG_KEY_FRAME       0x01
 
 typedef struct FFMStream {
-    INT64 pts;
+    int64_t pts;
 } FFMStream;
 
 enum {
@@ -40,15 +40,15 @@ typedef struct FFMContext {
     /* only reading mode */
     offset_t write_index, file_size;
     int read_state;
-    UINT8 header[FRAME_HEADER_SIZE];
+    uint8_t header[FRAME_HEADER_SIZE];
 
     /* read and write */
     int first_packet; /* true if first packet, needed to set the discontinuity tag */
     int packet_size;
     int frame_offset;
-    INT64 pts;
-    UINT8 *packet_ptr, *packet_end;
-    UINT8 packet[FFM_PACKET_SIZE];
+    int64_t pts;
+    uint8_t *packet_ptr, *packet_end;
+    uint8_t packet[FFM_PACKET_SIZE];
 } FFMContext;
 
 /* disable pts hack for testing */
@@ -82,8 +82,8 @@ static void flush_packet(AVFormatContext *s)
 
 /* 'first' is true if first data of a frame */
 static void ffm_write_data(AVFormatContext *s,
-                           UINT8 *buf, int size,
-                           INT64 pts, int first)
+                           uint8_t *buf, int size,
+                           int64_t pts, int first)
 {
     FFMContext *ffm = s->priv_data;
     int len;
@@ -214,12 +214,12 @@ static int ffm_write_header(AVFormatContext *s)
 }
 
 static int ffm_write_packet(AVFormatContext *s, int stream_index,
-                            UINT8 *buf, int size, int force_pts)
+                            uint8_t *buf, int size, int force_pts)
 {
     AVStream *st = s->streams[stream_index];
     FFMStream *fst = st->priv_data;
-    INT64 pts;
-    UINT8 header[FRAME_HEADER_SIZE];
+    int64_t pts;
+    uint8_t header[FRAME_HEADER_SIZE];
     int duration;
 
     if (st->codec.codec_type == CODEC_TYPE_AUDIO) {
@@ -260,7 +260,7 @@ static int ffm_write_trailer(AVFormatContext *s)
     put_flush_packet(pb);
 
     if (!url_is_streamed(pb)) {
-        INT64 size;
+        int64_t size;
         /* update the write offset */
         size = url_ftell(pb);
         url_fseek(pb, 8, SEEK_SET);
@@ -305,7 +305,7 @@ static int ffm_is_avail_data(AVFormatContext *s, int size)
 
 /* first is true if we read the frame header */
 static int ffm_read_data(AVFormatContext *s,
-                         UINT8 *buf, int size, int first)
+                         uint8_t *buf, int size, int first)
 {
     FFMContext *ffm = s->priv_data;
     ByteIOContext *pb = &s->pb;
@@ -368,7 +368,7 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
     ByteIOContext *pb = &s->pb;
     AVCodecContext *codec;
     int i;
-    UINT32 tag;
+    uint32_t tag;
 
     /* header */
     tag = get_le32(pb);
@@ -382,7 +382,7 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
     if (!url_is_streamed(pb)) {
         ffm->file_size = url_filesize(url_fileno(pb));
     } else {
-        ffm->file_size = (UINT64_C(1) << 63) - 1;
+        ffm->file_size = (uint64_t_C(1) << 63) - 1;
     }
 
     s->nb_streams = get_be32(pb);
@@ -411,7 +411,7 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
         /* specific info */
         switch(codec->codec_type) {
         case CODEC_TYPE_VIDEO:
-            codec->frame_rate = ((INT64)get_be32(pb) * FRAME_RATE_BASE) / 1000;
+            codec->frame_rate = ((int64_t)get_be32(pb) * FRAME_RATE_BASE) / 1000;
             codec->width = get_be16(pb);
             codec->height = get_be16(pb);
             codec->gop_size = get_be16(pb);
@@ -539,10 +539,10 @@ static void ffm_seek1(AVFormatContext *s, offset_t pos1)
     url_fseek(pb, pos, SEEK_SET);
 }
 
-static INT64 get_pts(AVFormatContext *s, offset_t pos)
+static int64_t get_pts(AVFormatContext *s, offset_t pos)
 {
     ByteIOContext *pb = &s->pb;
-    INT64 pts;
+    int64_t pts;
 
     ffm_seek1(s, pos);
     url_fskip(pb, 4);
@@ -556,11 +556,11 @@ static INT64 get_pts(AVFormatContext *s, offset_t pos)
 /* seek to a given time in the file. The file read pointer is
    positionned at or before pts. XXX: the following code is quite
    approximative */
-static int ffm_seek(AVFormatContext *s, INT64 wanted_pts)
+static int ffm_seek(AVFormatContext *s, int64_t wanted_pts)
 {
     FFMContext *ffm = s->priv_data;
     offset_t pos_min, pos_max, pos;
-    INT64 pts_min, pts_max, pts;
+    int64_t pts_min, pts_max, pts;
     double pos1;
 
 #ifdef DEBUG_SEEK
@@ -576,7 +576,7 @@ static int ffm_seek(AVFormatContext *s, INT64 wanted_pts)
         /* linear interpolation */
         pos1 = (double)(pos_max - pos_min) * (double)(wanted_pts - pts_min) /
             (double)(pts_max - pts_min);
-        pos = (((INT64)pos1) / FFM_PACKET_SIZE) * FFM_PACKET_SIZE;
+        pos = (((int64_t)pos1) / FFM_PACKET_SIZE) * FFM_PACKET_SIZE;
         if (pos <= pos_min)
             pos = pos_min;
         else if (pos >= pos_max)
@@ -601,7 +601,7 @@ static int ffm_seek(AVFormatContext *s, INT64 wanted_pts)
 
 offset_t ffm_read_write_index(int fd)
 {
-    UINT8 buf[8];
+    uint8_t buf[8];
     offset_t pos;
     int i;
 
@@ -615,7 +615,7 @@ offset_t ffm_read_write_index(int fd)
 
 void ffm_write_write_index(int fd, offset_t pos)
 {
-    UINT8 buf[8];
+    uint8_t buf[8];
     int i;
 
     for(i=0;i<8;i++)

libavformat/framehook.c

@@ -95,7 +95,7 @@ void frame_hook_process(AVPicture *pict, enum PixelFormat pix_fmt, int width, in
 {
     if (first_hook) {
         FrameHookEntry *fhe;
-        INT64 pts = av_gettime();
+        int64_t pts = av_gettime();
 
         for (fhe = first_hook; fhe; fhe = fhe->next) {
             fhe->Process(fhe->ctx, pict, pix_fmt, width, height, pts);

libavformat/framehook.h

@@ -13,7 +13,7 @@ typedef FrameHookConfigure *FrameHookConfigureFn;
 extern FrameHookConfigure Configure;
 
 /* Function must be called 'Process' */
-typedef void (FrameHookProcess)(void *ctx, struct AVPicture *pict, enum PixelFormat pix_fmt, int width, int height, INT64 pts);
+typedef void (FrameHookProcess)(void *ctx, struct AVPicture *pict, enum PixelFormat pix_fmt, int width, int height, int64_t pts);
 typedef FrameHookProcess *FrameHookProcessFn;
 extern FrameHookProcess Process;
 

libavformat/gif.c

@@ -212,7 +212,7 @@ static int gif_image_write_header(ByteIOContext *pb,
 }
 
 /* this is maybe slow, but allows for extensions */
-static inline unsigned char gif_clut_index(UINT8 r, UINT8 g, UINT8 b)
+static inline unsigned char gif_clut_index(uint8_t r, uint8_t g, uint8_t b)
 {
     return ((((r)/47)%6)*6*6+(((g)/47)%6)*6+(((b)/47)%6));
 }
@@ -223,7 +223,7 @@ static int gif_image_write_image(ByteIOContext *pb,
                                  uint8_t *buf, int linesize, int pix_fmt)
 {
     PutBitContext p;
-    UINT8 buffer[200]; /* 100 * 9 / 8 = 113 */
+    uint8_t buffer[200]; /* 100 * 9 / 8 = 113 */
     int i, left, w, v;
     uint8_t *ptr;
     /* image block */
@@ -287,8 +287,8 @@ static int gif_image_write_image(ByteIOContext *pb,
 }
 
 typedef struct {
-    INT64 time, file_time;
-    UINT8 buffer[100]; /* data chunks */
+    int64_t time, file_time;
+    uint8_t buffer[100]; /* data chunks */
 } GIFContext;
 
 static int gif_write_header(AVFormatContext *s)
@@ -331,12 +331,12 @@ static int gif_write_header(AVFormatContext *s)
 }
 
 static int gif_write_video(AVFormatContext *s, 
-                           AVCodecContext *enc, UINT8 *buf, int size)
+                           AVCodecContext *enc, uint8_t *buf, int size)
 {
     ByteIOContext *pb = &s->pb;
     GIFContext *gif = s->priv_data;
     int jiffies;
-    INT64 delay;
+    int64_t delay;
 
     /* graphic control extension block */
     put_byte(pb, 0x21);
@@ -366,7 +366,7 @@ static int gif_write_video(AVFormatContext *s,
 }
 
 static int gif_write_packet(AVFormatContext *s, int stream_index, 
-                           UINT8 *buf, int size, int force_pts)
+                           uint8_t *buf, int size, int force_pts)
 {
     AVCodecContext *codec = &s->streams[stream_index]->codec;
     if (codec->codec_type == CODEC_TYPE_AUDIO)

libavformat/grab.c

@@ -31,11 +31,11 @@ typedef struct {
     int use_mmap;
     int width, height;
     int frame_rate;
-    INT64 time_frame;
+    int64_t time_frame;
     int frame_size;
     struct video_capability video_cap;
     struct video_audio audio_saved;
-    UINT8 *video_buf;
+    uint8_t *video_buf;
     struct video_mbuf gb_buffers;
     struct video_mmap gb_buf;
     int gb_frame;
@@ -45,8 +45,8 @@ typedef struct {
     int aiw_enabled;
     int deint;
     int halfw;
-    UINT8 *src_mem;
-    UINT8 *lum_m4_mem;
+    uint8_t *src_mem;
+    uint8_t *lum_m4_mem;
 } VideoData;
 
 static int aiw_init(VideoData *s);
@@ -252,9 +252,9 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
     return -EIO;
 }
 
-static int v4l_mm_read_picture(VideoData *s, UINT8 *buf)
+static int v4l_mm_read_picture(VideoData *s, uint8_t *buf)
 {
-    UINT8 *ptr;
+    uint8_t *ptr;
 
     /* Setup to capture the next frame */
     s->gb_buf.frame = (s->gb_frame + 1) % s->gb_buffers.frames;
@@ -281,9 +281,9 @@ static int v4l_mm_read_picture(VideoData *s, UINT8 *buf)
 static int grab_read_packet(AVFormatContext *s1, AVPacket *pkt)
 {
     VideoData *s = s1->priv_data;
-    INT64 curtime, delay;
+    int64_t curtime, delay;
     struct timespec ts;
-    INT64 per_frame = (INT64_C(1000000) * FRAME_RATE_BASE) / s->frame_rate;
+    int64_t per_frame = (int64_t_C(1000000) * FRAME_RATE_BASE) / s->frame_rate;
 
     /* Calculate the time of the next frame */
     s->time_frame += per_frame;
@@ -617,13 +617,13 @@ static int aiw_init(VideoData *s)
 /* Read two fields separately. */
 static int aiw_read_picture(VideoData *s, uint8_t *data)
 {
-    UINT8 *ptr, *lum, *cb, *cr;
+    uint8_t *ptr, *lum, *cb, *cr;
     int h;
 #ifndef HAVE_MMX
     int sum;
 #endif
-    UINT8* src = s->src_mem;
-    UINT8 *ptrend = &src[s->width*2];
+    uint8_t* src = s->src_mem;
+    uint8_t *ptrend = &src[s->width*2];
     lum=data;
     cb=&lum[s->width*s->height];
     cr=&cb[(s->width*s->height)/4];
@@ -715,7 +715,7 @@ static int aiw_read_picture(VideoData *s, uint8_t *data)
             read(s->fd,src,s->width*4);
         }
     } else {
-        UINT8 *lum_m1, *lum_m2, *lum_m3, *lum_m4;
+        uint8_t *lum_m1, *lum_m2, *lum_m3, *lum_m4;
 #ifdef HAVE_MMX
         mmx_t rounder;
         rounder.uw[0]=4;
@@ -725,7 +725,7 @@ static int aiw_read_picture(VideoData *s, uint8_t *data)
         movq_m2r(rounder,mm6);
         pxor_r2r(mm7,mm7);
 #else
-        UINT8 *cm = cropTbl + MAX_NEG_CROP;
+        uint8_t *cm = cropTbl + MAX_NEG_CROP;
 #endif
 
         /* read two fields and deinterlace them */

libavformat/http.c

@@ -48,7 +48,7 @@ typedef struct {
 } HTTPContext;
 
 static int http_connect(URLContext *h, const char *path, const char *hoststr);
-static int http_write(URLContext *h, UINT8 *buf, int size);
+static int http_write(URLContext *h, uint8_t *buf, int size);
 
 
 /* return non zero if error */
@@ -236,7 +236,7 @@ static int http_connect(URLContext *h, const char *path, const char *hoststr)
 }
 
 
-static int http_read(URLContext *h, UINT8 *buf, int size)
+static int http_read(URLContext *h, uint8_t *buf, int size)
 {
     HTTPContext *s = h->priv_data;
     int size1, len;
@@ -265,7 +265,7 @@ static int http_read(URLContext *h, UINT8 *buf, int size)
 }
 
 /* used only when posting data */
-static int http_write(URLContext *h, UINT8 *buf, int size)
+static int http_write(URLContext *h, uint8_t *buf, int size)
 {
     HTTPContext *s = h->priv_data;
     return url_write(s->hd, buf, size);

libavformat/img.c

@@ -157,18 +157,18 @@ static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
     char filename[1024];
     int ret;
     ByteIOContext f1, *f;
-    static INT64 first_frame; // BUG -> to context FIXME
+    static int64_t first_frame; // BUG -> to context FIXME
 
     if (emulate_frame_rate) {
         if (!first_frame) {
             first_frame = av_gettime();
         } else {
-            INT64 pts;
-            INT64 nowus;
+            int64_t pts;
+            int64_t nowus;
 
             nowus = av_gettime() - first_frame;
 
-            pts = ((INT64)s->img_number * FRAME_RATE_BASE * 1000000) / (s1->streams[0]->codec.frame_rate);
+            pts = ((int64_t)s->img_number * FRAME_RATE_BASE * 1000000) / (s1->streams[0]->codec.frame_rate);
 
             if (pts > nowus)
                 usleep(pts - nowus);
@@ -201,7 +201,7 @@ static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
         av_free_packet(pkt);
         return -EIO; /* signal EOF */
     } else {
-        pkt->pts = ((INT64)s->img_number * s1->pts_den * FRAME_RATE_BASE) / (s1->streams[0]->codec.frame_rate * s1->pts_num);
+        pkt->pts = ((int64_t)s->img_number * s1->pts_den * FRAME_RATE_BASE) / (s1->streams[0]->codec.frame_rate * s1->pts_num);
         s->img_number++;
         return 0;
     }
@@ -265,7 +265,7 @@ static int img_write_header(AVFormatContext *s)
 }
 
 static int img_write_packet(AVFormatContext *s, int stream_index,
-                            UINT8 *buf, int size, int force_pts)
+                            uint8_t *buf, int size, int force_pts)
 {
     VideoData *img = s->priv_data;
     AVStream *st = s->streams[stream_index];

libavformat/jpeg.c

@@ -56,8 +56,8 @@ static int jpeg_get_buffer(AVCodecContext *c, AVFrame *picture)
     }
 }
 
-static void img_copy(UINT8 *dst, int dst_wrap, 
-                     UINT8 *src, int src_wrap,
+static void img_copy(uint8_t *dst, int dst_wrap, 
+                     uint8_t *src, int src_wrap,
                      int width, int height)
 {
     for(;height > 0; height--) {

libavformat/mov.c

@@ -61,7 +61,7 @@
  * Avoid them. This is here just to help debugging.
  */
 static int debug_indent = 0;
-void print_atom(const char *str, UINT32 type, UINT64 offset, UINT64 size)
+void print_atom(const char *str, uint32_t type, uint64_t offset, uint64_t size)
 {
     unsigned int tag, i;
     tag = (unsigned int) type;
@@ -149,7 +149,7 @@ typedef struct MOVStreamContext {
     int is_ff_stream; /* Is this stream presented to ffmpeg ? i.e. is this an audio or video stream ? */
     long next_chunk;
     long chunk_count;
-    INT64 *chunk_offsets;
+    int64_t *chunk_offsets;
     long sample_to_chunk_sz;
     MOV_sample_to_chunk_tbl *sample_to_chunk;
     long sample_to_chunk_index;
@@ -170,15 +170,15 @@ typedef struct MOVContext {
     long time_scale;
     int found_moov; /* when both 'moov' and 'mdat' sections has been found */
     int found_mdat; /* we suppose we have enough data to read the file */
-    INT64 mdat_size;
-    INT64 mdat_offset;
+    int64_t mdat_size;
+    int64_t mdat_offset;
     int total_streams;
     /* some streams listed here aren't presented to the ffmpeg API, since they aren't either video nor audio
      * but we need the info to be able to skip data from those streams in the 'mdat' section
      */
     MOVStreamContext *streams[MAX_STREAMS];
     
-    INT64 next_chunk_offset;
+    int64_t next_chunk_offset;
     int partial; /* != 0 : there is still to read in the current chunk (=id of the stream + 1) */
 } MOVContext;
 
@@ -195,18 +195,18 @@ struct MOVParseTableEntry;
  */
 typedef int (*mov_parse_function)(const struct MOVParseTableEntry *parse_table,
                                   ByteIOContext *pb,
-                                  UINT32 atom_type,
-                                  INT64 atom_offset, /* after the size and type field (and eventually the extended size) */
-                                  INT64 atom_size, /* total size (excluding the size and type fields) */
+                                  uint32_t atom_type,
+                                  int64_t atom_offset, /* after the size and type field (and eventually the extended size) */
+                                  int64_t atom_size, /* total size (excluding the size and type fields) */
                                   void *param);
 
 /* links atom IDs to parse functions */
 typedef struct MOVParseTableEntry {
-    UINT32 type;
+    uint32_t type;
     mov_parse_function func;
 } MOVParseTableEntry;
 
-static int parse_leaf(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_leaf(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
 #ifdef DEBUG
     print_atom("leaf", atom_type, atom_offset, atom_size);
@@ -218,11 +218,11 @@ static int parse_leaf(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
 }
 
 
-static int parse_default(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_default(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
-    UINT32 type, foo=0;
-    UINT64 offset, size;
-    UINT64 total_size = 0;
+    uint32_t type, foo=0;
+    uint64_t offset, size;
+    uint64_t total_size = 0;
     int i;
     int err = 0;
     foo=0;
@@ -276,7 +276,7 @@ static int parse_default(const MOVParseTableEntry *parse_table, ByteIOContext *p
     return err;
 }
 
-static int parse_mvhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_mvhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
 #ifdef DEBUG
@@ -314,7 +314,7 @@ static int parse_mvhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
 }
 
 /* this atom should contain all header atoms */
-static int parse_moov(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_moov(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     int err;
     MOVContext *c;
@@ -333,7 +333,7 @@ static int parse_moov(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
 }
 
 /* this atom contains actual media data */
-static int parse_mdat(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_mdat(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
 #ifdef DEBUG
@@ -355,10 +355,10 @@ static int parse_mdat(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
 /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
 /* like the files created with Adobe Premiere 5.0, for samples see */
 /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
-static int parse_wide(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_wide(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     int err;
-    UINT32 type;
+    uint32_t type;
 #ifdef DEBUG
     print_atom("wide", atom_type, atom_offset, atom_size);
     debug_indent++;
@@ -381,7 +381,7 @@ static int parse_wide(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
     return err;
 }
 
-static int parse_trak(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_trak(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     AVStream *st;
@@ -401,7 +401,7 @@ static int parse_trak(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
     return parse_default(parse_table, pb, atom_type, atom_offset, atom_size, param);
 }
 
-static int parse_tkhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_tkhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     AVStream *st;
@@ -445,7 +445,7 @@ static int parse_tkhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
     return 0;
 }
 
-static int parse_mdhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_mdhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     AVStream *st;
@@ -477,14 +477,14 @@ static int parse_mdhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
     return 0;
 }
 
-static int parse_hdlr(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_hdlr(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     int len = 0;
     char *buf;
-    UINT32 type;
+    uint32_t type;
     AVStream *st;
-    UINT32 ctype;
+    uint32_t ctype;
 #ifdef DEBUG
     print_atom("hdlr", atom_type, atom_offset, atom_size);
 #endif
@@ -612,11 +612,11 @@ static int mp4_read_descr(ByteIOContext *pb, int *tag)
     return len;
 }
 
-static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     int entries, size, samp_sz, frames_per_sample, id;
-    UINT32 format;
+    uint32_t format;
     AVStream *st;
     MOVStreamContext *sc;
 #ifdef DEBUG
@@ -691,7 +691,7 @@ static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
             size -= (16+8*4+2+32+2*2);
             while (size >= 8) {
                 int atom_size, atom_type;
-                INT64 start_pos;
+                int64_t start_pos;
                 
                 atom_size = get_be32(pb);
                 atom_type = get_le32(pb);
@@ -800,7 +800,7 @@ static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
     return 0;
 }
 
-static int parse_stco(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_stco(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     int entries, i;
@@ -818,7 +818,7 @@ static int parse_stco(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
 
     entries = get_be32(pb);
     sc->chunk_count = entries;
-    sc->chunk_offsets = av_malloc(entries * sizeof(INT64));
+    sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
     if(atom_type == MKTAG('s', 't', 'c', 'o')) {
         for(i=0; i<entries; i++) {
             sc->chunk_offsets[i] = get_be32(pb);
@@ -839,7 +839,7 @@ static int parse_stco(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
     return 0;
 }
 
-static int parse_stsc(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_stsc(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     int entries, i;
@@ -872,7 +872,7 @@ printf("track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
     return 0;
 }
 
-static int parse_stsz(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_stsz(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     int entries, i;
@@ -906,7 +906,7 @@ static int parse_stsz(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
     return 0;
 }
 
-static int parse_stts(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_stts(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     int entries, i;
@@ -944,12 +944,12 @@ printf("track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);
 }
 
 #ifdef CONFIG_ZLIB
-static int null_read_packet(void *opaque, UINT8 *buf, int buf_size)
+static int null_read_packet(void *opaque, uint8_t *buf, int buf_size)
 {
     return -1;
 }
 
-static int parse_cmov(const MOVParseTableEntry *parse_table, ByteIOContext *pb, UINT32 atom_type, INT64 atom_offset, INT64 atom_size, void *param)
+static int parse_cmov(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
 {
     MOVContext *c;
     ByteIOContext ctx;
@@ -1130,7 +1130,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
     MOVContext *mov = s->priv_data;
     ByteIOContext *pb = &s->pb;
     int i, j, nb, err;
-    INT64 size;
+    int64_t size;
 
     mov->fc = s;
 #if 0
@@ -1200,7 +1200,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
 {
     MOVContext *mov = s->priv_data;
     MOVStreamContext *sc;
-    INT64 offset = 0x0FFFFFFFFFFFFFFF;
+    int64_t offset = 0x0FFFFFFFFFFFFFFF;
     int i;
     int st_id = 0, size;
     size = 0x0FFFFFFF;

libavformat/mpeg.c

@@ -22,12 +22,12 @@
 #define NB_STREAMS 2
 
 typedef struct {
-    UINT8 buffer[MAX_PAYLOAD_SIZE];
+    uint8_t buffer[MAX_PAYLOAD_SIZE];
     int buffer_ptr;
-    UINT8 id;
+    uint8_t id;
     int max_buffer_size; /* in bytes */
     int packet_number;
-    INT64 start_pts;
+    int64_t start_pts;
 } StreamInfo;
 
 typedef struct {
@@ -66,7 +66,7 @@ extern AVOutputFormat mpeg1vcd_mux;
 extern AVOutputFormat mpeg2vob_mux;
 
 static int put_pack_header(AVFormatContext *ctx, 
-                           UINT8 *buf, INT64 timestamp)
+                           uint8_t *buf, int64_t timestamp)
 {
     MpegMuxContext *s = ctx->priv_data;
     PutBitContext pb;
@@ -79,11 +79,11 @@ static int put_pack_header(AVFormatContext *ctx,
     } else {
         put_bits(&pb, 4, 0x2);
     }
-    put_bits(&pb, 3, (UINT32)((timestamp >> 30) & 0x07));
+    put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
     put_bits(&pb, 1, 1);
-    put_bits(&pb, 15, (UINT32)((timestamp >> 15) & 0x7fff));
+    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
     put_bits(&pb, 1, 1);
-    put_bits(&pb, 15, (UINT32)((timestamp) & 0x7fff));
+    put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
     put_bits(&pb, 1, 1);
     if (s->is_mpeg2) {
         /* clock extension */
@@ -101,7 +101,7 @@ static int put_pack_header(AVFormatContext *ctx,
     return pbBufPtr(&pb) - pb.buf;
 }
 
-static int put_system_header(AVFormatContext *ctx, UINT8 *buf)
+static int put_system_header(AVFormatContext *ctx, uint8_t *buf)
 {
     MpegMuxContext *s = ctx->priv_data;
     int size, rate_bound, i, private_stream_coded, id;
@@ -254,10 +254,10 @@ static void flush_packet(AVFormatContext *ctx, int stream_index, int last_pkt)
 {
     MpegMuxContext *s = ctx->priv_data;
     StreamInfo *stream = ctx->streams[stream_index]->priv_data;
-    UINT8 *buf_ptr;
+    uint8_t *buf_ptr;
     int size, payload_size, startcode, id, len, stuffing_size, i, header_len;
-    INT64 timestamp;
-    UINT8 buffer[128];
+    int64_t timestamp;
+    uint8_t buffer[128];
     int last = last_pkt ? 4 : 0;
     
     id = stream->id;
@@ -314,8 +314,8 @@ static void flush_packet(AVFormatContext *ctx, int stream_index, int last_pkt)
              (0x02 << 4) | 
              (((timestamp >> 30) & 0x07) << 1) | 
              1);
-    put_be16(&ctx->pb, (UINT16)((((timestamp >> 15) & 0x7fff) << 1) | 1));
-    put_be16(&ctx->pb, (UINT16)((((timestamp) & 0x7fff) << 1) | 1));
+    put_be16(&ctx->pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
+    put_be16(&ctx->pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
 
     if (startcode == PRIVATE_STREAM_1) {
         put_byte(&ctx->pb, id);
@@ -347,7 +347,7 @@ static void flush_packet(AVFormatContext *ctx, int stream_index, int last_pkt)
 }
 
 static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,
-                                 UINT8 *buf, int size, int pts)
+                                 uint8_t *buf, int size, int pts)
 {
     MpegMuxContext *s = ctx->priv_data;
     AVStream *st = ctx->streams[stream_index];
@@ -440,7 +440,7 @@ typedef struct MpegDemuxContext {
 } MpegDemuxContext;
 
 static int find_start_code(ByteIOContext *pb, int *size_ptr, 
-                           UINT32 *header_state)
+                           uint32_t *header_state)
 {
     unsigned int state, v;
     int val, n;
@@ -475,18 +475,18 @@ static int mpegps_read_header(AVFormatContext *s,
     return 0;
 }
 
-static INT64 get_pts(ByteIOContext *pb, int c)
+static int64_t get_pts(ByteIOContext *pb, int c)
 {
-    INT64 pts;
+    int64_t pts;
     int val;
 
     if (c < 0)
         c = get_byte(pb);
-    pts = (INT64)((c >> 1) & 0x07) << 30;
+    pts = (int64_t)((c >> 1) & 0x07) << 30;
     val = get_be16(pb);
-    pts |= (INT64)(val >> 1) << 15;
+    pts |= (int64_t)(val >> 1) << 15;
     val = get_be16(pb);
-    pts |= (INT64)(val >> 1);
+    pts |= (int64_t)(val >> 1);
     return pts;
 }
 
@@ -496,7 +496,7 @@ static int mpegps_read_packet(AVFormatContext *s,
     MpegDemuxContext *m = s->priv_data;
     AVStream *st;
     int len, size, startcode, i, c, flags, header_len, type, codec_id;
-    INT64 pts, dts;
+    int64_t pts, dts;
 
     /* next start code (should be immediately after) */
  redo:

libavformat/mpegts.c

@@ -88,7 +88,7 @@ static int mpegts_read_header(AVFormatContext *s,
     ByteIOContext *pb = &s->pb;
     unsigned char buf[1024];
     int len;
-    INT64 pos;
+    int64_t pos;
 
     /* read the first 1024 bytes to get packet size */
     pos = url_ftell(pb);

libavformat/mpjpeg.c

@@ -24,7 +24,7 @@
 
 static int mpjpeg_write_header(AVFormatContext *s)
 {
-    UINT8 buf1[256];
+    uint8_t buf1[256];
 
     snprintf(buf1, sizeof(buf1), "--%s\n", BOUNDARY_TAG);
     put_buffer(&s->pb, buf1, strlen(buf1));
@@ -33,9 +33,9 @@ static int mpjpeg_write_header(AVFormatContext *s)
 }
 
 static int mpjpeg_write_packet(AVFormatContext *s, int stream_index, 
-                               UINT8 *buf, int size, int force_pts)
+                               uint8_t *buf, int size, int force_pts)
 {
-    UINT8 buf1[256];
+    uint8_t buf1[256];
 
     snprintf(buf1, sizeof(buf1), "Content-type: image/jpeg\n\n");
     put_buffer(&s->pb, buf1, strlen(buf1));
@@ -75,7 +75,7 @@ static int single_jpeg_write_header(AVFormatContext *s)
 }
 
 static int single_jpeg_write_packet(AVFormatContext *s, int stream_index,
-                            UINT8 *buf, int size, int force_pts)
+                            uint8_t *buf, int size, int force_pts)
 {
     put_buffer(&s->pb, buf, size);
     put_flush_packet(&s->pb);

libavformat/pnm.c

@@ -161,7 +161,7 @@ static int pnm_write(ByteIOContext *pb, AVImageInfo *info)
 {
     int i, h, h1, c, n, linesize;
     char buf[100];
-    UINT8 *ptr, *ptr1, *ptr2;
+    uint8_t *ptr, *ptr1, *ptr2;
 
     h = info->height;
     h1 = h;

libavformat/raw.c

@@ -38,7 +38,7 @@ static int raw_write_trailer(struct AVFormatContext *s)
 }
 
 /* raw input */
-static static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
+static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
 {
     AVStream *st;
     int id;

libavformat/rm.c

@@ -322,16 +322,16 @@ static int rm_write_header(AVFormatContext *s)
     return 0;
 }
 
-static int rm_write_audio(AVFormatContext *s, UINT8 *buf, int size)
+static int rm_write_audio(AVFormatContext *s, uint8_t *buf, int size)
 {
-    UINT8 *buf1;
+    uint8_t *buf1;
     RMContext *rm = s->priv_data;
     ByteIOContext *pb = &s->pb;
     StreamInfo *stream = rm->audio_stream;
     int i;
 
     /* XXX: suppress this malloc */
-    buf1= (UINT8*) av_malloc( size * sizeof(UINT8) );
+    buf1= (uint8_t*) av_malloc( size * sizeof(uint8_t) );
     
     write_packet_header(s, stream, size, stream->enc->coded_frame->key_frame);
     
@@ -347,7 +347,7 @@ static int rm_write_audio(AVFormatContext *s, UINT8 *buf, int size)
     return 0;
 }
 
-static int rm_write_video(AVFormatContext *s, UINT8 *buf, int size)
+static int rm_write_video(AVFormatContext *s, uint8_t *buf, int size)
 {
     RMContext *rm = s->priv_data;
     ByteIOContext *pb = &s->pb;
@@ -388,7 +388,7 @@ static int rm_write_video(AVFormatContext *s, UINT8 *buf, int size)
 }
 
 static int rm_write_packet(AVFormatContext *s, int stream_index, 
-                           UINT8 *buf, int size, int force_pts)
+                           uint8_t *buf, int size, int force_pts)
 {
     if (s->streams[stream_index]->codec.codec_type == 
         CODEC_TYPE_AUDIO)
@@ -472,7 +472,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
     ByteIOContext *pb = &s->pb;
     unsigned int tag, v;
     int tag_size, size, codec_data_size, i;
-    INT64 codec_pos;
+    int64_t codec_pos;
     unsigned int h263_hack_version;
     char buf[128];
     int flags = 0;
@@ -650,7 +650,7 @@ static int rm_read_packet(AVFormatContext *s, AVPacket *pkt)
     ByteIOContext *pb = &s->pb;
     AVStream *st;
     int len, num, timestamp, i, tmp, j;
-    UINT8 *ptr;
+    uint8_t *ptr;
     int flags;
 
  redo:

libavformat/rtp.c

@@ -90,23 +90,23 @@ enum RTPPayloadType {
 
 typedef struct RTPContext {
     int payload_type;
-    UINT32 ssrc;
-    UINT16 seq;
-    UINT32 timestamp;
-    UINT32 base_timestamp;
-    UINT32 cur_timestamp;
+    uint32_t ssrc;
+    uint16_t seq;
+    uint32_t timestamp;
+    uint32_t base_timestamp;
+    uint32_t cur_timestamp;
     int max_payload_size;
     /* rtcp sender statistics receive */
-    INT64 last_rtcp_ntp_time;
-    UINT32 last_rtcp_timestamp;
+    int64_t last_rtcp_ntp_time;
+    uint32_t last_rtcp_timestamp;
     /* rtcp sender statistics */
     unsigned int packet_count;
     unsigned int octet_count;
     unsigned int last_octet_count;
     int first_packet;
     /* buffer for output */
-    UINT8 buf[RTP_MAX_PACKET_LENGTH];
-    UINT8 *buf_ptr;
+    uint8_t buf[RTP_MAX_PACKET_LENGTH];
+    uint8_t *buf_ptr;
 } RTPContext;
 
 int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
@@ -184,14 +184,14 @@ int rtp_get_payload_type(AVCodecContext *codec)
     return payload_type;
 }
 
-static inline UINT32 decode_be32(const UINT8 *p)
+static inline uint32_t decode_be32(const uint8_t *p)
 {
     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 }
 
-static inline UINT32 decode_be64(const UINT8 *p)
+static inline uint32_t decode_be64(const uint8_t *p)
 {
-    return ((UINT64)decode_be32(p) << 32) | decode_be32(p + 4);
+    return ((uint64_t)decode_be32(p) << 32) | decode_be32(p + 4);
 }
 
 static int rtcp_parse_packet(AVFormatContext *s1, const unsigned char *buf, int len)
@@ -221,7 +221,7 @@ int rtp_parse_packet(AVFormatContext *s1, AVPacket *pkt,
     unsigned int ssrc, h;
     int payload_type, seq, delta_timestamp;
     AVStream *st;
-    UINT32 timestamp;
+    uint32_t timestamp;
     
     if (len < 12)
         return -1;
@@ -390,7 +390,7 @@ static int rtp_write_header(AVFormatContext *s1)
 }
 
 /* send an rtcp sender report packet */
-static void rtcp_send_sr(AVFormatContext *s1, INT64 ntp_time)
+static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
 {
     RTPContext *s = s1->priv_data;
 #if defined(DEBUG)
@@ -409,7 +409,7 @@ static void rtcp_send_sr(AVFormatContext *s1, INT64 ntp_time)
 
 /* send an rtp packet. sequence number is incremented, but the caller
    must update the timestamp itself */
-static void rtp_send_data(AVFormatContext *s1, UINT8 *buf1, int len)
+static void rtp_send_data(AVFormatContext *s1, uint8_t *buf1, int len)
 {
     RTPContext *s = s1->priv_data;
 
@@ -435,7 +435,7 @@ static void rtp_send_data(AVFormatContext *s1, UINT8 *buf1, int len)
 /* send an integer number of samples and compute time stamp and fill
    the rtp send buffer before sending. */
 static void rtp_send_samples(AVFormatContext *s1,
-                             UINT8 *buf1, int size, int sample_size)
+                             uint8_t *buf1, int size, int sample_size)
 {
     RTPContext *s = s1->priv_data;
     int len, max_packet_size, n;
@@ -468,7 +468,7 @@ static void rtp_send_samples(AVFormatContext *s1,
 /* NOTE: we suppose that exactly one frame is given as argument here */
 /* XXX: test it */
 static void rtp_send_mpegaudio(AVFormatContext *s1,
-                               UINT8 *buf1, int size)
+                               uint8_t *buf1, int size)
 {
     RTPContext *s = s1->priv_data;
     AVStream *st = s1->streams[0];
@@ -524,12 +524,12 @@ static void rtp_send_mpegaudio(AVFormatContext *s1,
 /* NOTE: a single frame must be passed with sequence header if
    needed. XXX: use slices. */
 static void rtp_send_mpegvideo(AVFormatContext *s1,
-                               UINT8 *buf1, int size)
+                               uint8_t *buf1, int size)
 {
     RTPContext *s = s1->priv_data;
     AVStream *st = s1->streams[0];
     int len, h, max_packet_size;
-    UINT8 *q;
+    uint8_t *q;
 
     max_packet_size = s->max_payload_size;
 
@@ -572,7 +572,7 @@ static void rtp_send_mpegvideo(AVFormatContext *s1,
 }
 
 static void rtp_send_raw(AVFormatContext *s1,
-                         UINT8 *buf1, int size)
+                         uint8_t *buf1, int size)
 {
     RTPContext *s = s1->priv_data;
     AVStream *st = s1->streams[0];
@@ -599,12 +599,12 @@ static void rtp_send_raw(AVFormatContext *s1,
 
 /* write an RTP packet. 'buf1' must contain a single specific frame. */
 static int rtp_write_packet(AVFormatContext *s1, int stream_index,
-                            UINT8 *buf1, int size, int force_pts)
+                            uint8_t *buf1, int size, int force_pts)
 {
     RTPContext *s = s1->priv_data;
     AVStream *st = s1->streams[0];
     int rtcp_bytes;
-    INT64 ntp_time;
+    int64_t ntp_time;
     
 #ifdef DEBUG
     printf("%d: write len=%d\n", stream_index, size);
@@ -615,7 +615,7 @@ static int rtp_write_packet(AVFormatContext *s1, int stream_index,
         RTCP_TX_RATIO_DEN;
     if (s->first_packet || rtcp_bytes >= 28) {
         /* compute NTP time */
-        ntp_time = force_pts; // ((INT64)force_pts << 28) / 5625
+        ntp_time = force_pts; // ((int64_t)force_pts << 28) / 5625
         rtcp_send_sr(s1, ntp_time); 
         s->last_octet_count = s->octet_count;
         s->first_packet = 0;

libavformat/rtpproto.c

@@ -171,7 +171,7 @@ static int rtp_open(URLContext *h, const char *uri, int flags)
     return -EIO;
 }
 
-static int rtp_read(URLContext *h, UINT8 *buf, int size)
+static int rtp_read(URLContext *h, uint8_t *buf, int size)
 {
     RTPContext *s = h->priv_data;
     struct sockaddr_in from;
@@ -230,7 +230,7 @@ static int rtp_read(URLContext *h, UINT8 *buf, int size)
     return len;
 }
 
-static int rtp_write(URLContext *h, UINT8 *buf, int size)
+static int rtp_write(URLContext *h, uint8_t *buf, int size)
 {
     RTPContext *s = h->priv_data;
     int ret;

libavformat/rtsp.h

@@ -41,7 +41,7 @@ typedef struct RTSPTransportField {
     int client_port_min, client_port_max; /* RTP ports */
     int server_port_min, server_port_max; /* RTP ports */
     int ttl; /* ttl value */
-    UINT32 destination; /* destination IP address */
+    uint32_t destination; /* destination IP address */
     enum RTSPProtocol protocol;
 } RTSPTransportField;
 
@@ -63,7 +63,7 @@ enum RTSPCallbackAction {
 };
 
 typedef struct RTSPActionServerSetup {
-    UINT32 ipaddr;
+    uint32_t ipaddr;
     char transport_option[512];
 } RTSPActionServerSetup;
 

libavformat/swf.c

@@ -107,7 +107,7 @@ static void put_swf_rect(ByteIOContext *pb,
                          int xmin, int xmax, int ymin, int ymax)
 {
     PutBitContext p;
-    UINT8 buf[256];
+    uint8_t buf[256];
     int nbits, mask;
 
     init_put_bits(&p, buf, sizeof(buf), NULL, NULL);
@@ -164,7 +164,7 @@ static void put_swf_matrix(ByteIOContext *pb,
                            int a, int b, int c, int d, int tx, int ty)
 {
     PutBitContext p;
-    UINT8 buf[256];
+    uint8_t buf[256];
 
     init_put_bits(&p, buf, sizeof(buf), NULL, NULL);
     
@@ -193,7 +193,7 @@ static int swf_write_header(AVFormatContext *s)
     ByteIOContext *pb = &s->pb;
     AVCodecContext *enc, *audio_enc, *video_enc;
     PutBitContext p;
-    UINT8 buf1[256];
+    uint8_t buf1[256];
     int i, width, height, rate;
 
     swf = av_malloc(sizeof(SWFContext));
@@ -230,7 +230,7 @@ static int swf_write_header(AVFormatContext *s)
     put_swf_rect(pb, 0, width, 0, height);
     put_le16(pb, (rate * 256) / FRAME_RATE_BASE); /* frame rate */
     swf->duration_pos = url_ftell(pb);
-    put_le16(pb, (UINT16)(DUMMY_DURATION * (INT64)rate / FRAME_RATE_BASE)); /* frame count */
+    put_le16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / FRAME_RATE_BASE)); /* frame count */
     
     /* define a shape with the jpeg inside */
 
@@ -316,7 +316,7 @@ static int swf_write_header(AVFormatContext *s)
 }
 
 static int swf_write_video(AVFormatContext *s, 
-                           AVCodecContext *enc, UINT8 *buf, int size)
+                           AVCodecContext *enc, uint8_t *buf, int size)
 {
     ByteIOContext *pb = &s->pb;
     static int tag_id = 0;
@@ -364,7 +364,7 @@ static int swf_write_video(AVFormatContext *s,
     return 0;
 }
 
-static int swf_write_audio(AVFormatContext *s, UINT8 *buf, int size)
+static int swf_write_audio(AVFormatContext *s, uint8_t *buf, int size)
 {
     ByteIOContext *pb = &s->pb;
 
@@ -378,7 +378,7 @@ static int swf_write_audio(AVFormatContext *s, UINT8 *buf, int size)
 }
 
 static int swf_write_packet(AVFormatContext *s, int stream_index, 
-                           UINT8 *buf, int size, int force_pts)
+                           uint8_t *buf, int size, int force_pts)
 {
     AVCodecContext *codec = &s->streams[stream_index]->codec;
     if (codec->codec_type == CODEC_TYPE_AUDIO)