Ticket #458: diff_mplayer.2.diff

codec-cfg.c

@@ -1026 +1026 @@
                         for (j = 0; j < nr[i]; j++) {
                                 printf("{");
 
-                                print_int_array(cod[i][j].fourcc, CODECS_MAX_FOURCC);
+                                print_int_array((signed int*)(cod[i][j].fourcc), CODECS_MAX_FOURCC);
                                 printf(", /* fourcc */\n");
                                 
-                                print_int_array(cod[i][j].fourccmap, CODECS_MAX_FOURCC);
+                                print_int_array((signed int*)(cod[i][j].fourccmap), CODECS_MAX_FOURCC);
                                 printf(", /* fourccmap */\n");
                                 
-                                print_int_array(cod[i][j].outfmt, CODECS_MAX_OUTFMT);
+                                print_int_array((signed int*)(cod[i][j].outfmt), CODECS_MAX_OUTFMT);
                                 printf(", /* outfmt */\n");
                                 
-                                print_char_array(cod[i][j].outflags, CODECS_MAX_OUTFMT);
+                                print_char_array((unsigned char*)(cod[i][j].outflags), CODECS_MAX_OUTFMT);
                                 printf(", /* outflags */\n");
                                 
-                                print_int_array(cod[i][j].infmt, CODECS_MAX_INFMT);
+                                print_int_array((signed int*)(cod[i][j].infmt), CODECS_MAX_INFMT);
                                 printf(", /* infmt */\n");
                                 
                                 print_char_array(cod[i][j].inflags, CODECS_MAX_INFMT);

libao2/ao_alsa.c

@@ -507 +507 @@
         }
 
       if ((err = snd_pcm_hw_params_set_channels_near(alsa_handler, alsa_hwparams,
-                                                     &ao_data.channels)) < 0)
+                                                     (unsigned int *)&ao_data.channels)) < 0)
         {
           mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set channels: %s\n",
                  snd_strerror(err));
@@ -515 +515 @@
         }
 
       if ((err = snd_pcm_hw_params_set_rate_near(alsa_handler, alsa_hwparams, 
-                                                 &ao_data.samplerate, NULL)) < 0) 
+                                                 (unsigned int *)&ao_data.samplerate, NULL)) < 0) 
         {
           mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set samplerate-2: %s\n",
                  snd_strerror(err));
@@ -565 +565 @@
           mp_msg(MSGT_AO,MSGL_V,"alsa-init: chunksize set to %li\n", chunk_size);
         }
         if ((err = snd_pcm_hw_params_set_periods_near(alsa_handler, alsa_hwparams,
-                                                      &alsa_fragcount, NULL)) < 0) {
+                                                      (unsigned int *)&alsa_fragcount, NULL)) < 0) {
           mp_msg(MSGT_AO,MSGL_ERR,"alsa-init: unable to set periods: %s\n", 
                  snd_strerror(err));
         }

libavcodec/4xm.c

@@ -633 +633 @@
         }
         cfrm= &f->cfrm[i];
 
-        cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
+        cfrm->data= av_fast_realloc(cfrm->data, (unsigned int *)&cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 
         memcpy(cfrm->data + cfrm->size, buf+20, data_size);
         cfrm->size += data_size;

libavcodec/cyuv.c

@@ -41 +41 @@
 
 typedef struct CyuvDecodeContext {
     AVCodecContext *avctx;
-    int width, height;
+    unsigned int width, height;
     AVFrame frame;
 } CyuvDecodeContext;
 
@@ -75 +75 @@
     int v_ptr;
 
     /* prediction error tables (make it clear that they are signed values) */
-    signed char *y_table = buf +  0;
-    signed char *u_table = buf + 16;
-    signed char *v_table = buf + 32;
+    unsigned char *y_table = buf +  0;
+    unsigned char *u_table = buf + 16;
+    unsigned char *v_table = buf + 32;
 
     unsigned char y_pred, u_pred, v_pred;
     int stream_ptr;

libavcodec/h263.c

@@ -2372 +2372 @@
     put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
 
     if(s->mpeg_quant){
-        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
-        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
+        ff_write_quant_matrix(&s->pb, (int16_t *)(s->avctx->intra_matrix));
+        ff_write_quant_matrix(&s->pb, (int16_t *)(s->avctx->inter_matrix));
     }
 
     if (vo_ver_id != 1)

libavcodec/h264.c

@@ -7016 +7016 @@
     }
 
     user_data[i]= 0;
-    e= sscanf(user_data+16, "x264 - core %d"/*%s - H.264/MPEG-4 AVC codec - Copyleft 2005 - http://www.videolan.org/x264.html*/, &build);
+    e= sscanf((char*)user_data+16, "x264 - core %d"/*%s - H.264/MPEG-4 AVC codec - Copyleft 2005 - http://www.videolan.org/x264.html*/, &build);
     if(e==1 && build>=0)
         h->x264_build= build;
 

libavcodec/mjpeg.c

@@ -1798 +1798 @@
                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
 
             /* buggy avid, it puts EOI only at every 10th frame */
-            if (!strcmp(cbuf, "AVID"))
+            if (!strcmp((char *)cbuf, "AVID"))
             {
                 s->buggy_avid = 1;
                 //        if (s->first_picture)
                 //            printf("mjpeg: workarounding buggy AVID\n");
             }
-            else if(!strcmp(cbuf, "CS=ITU601")){
+            else if(!strcmp((char *)cbuf, "CS=ITU601")){
                 s->cs_itu601= 1;
             }
 

libavcodec/mpeg12.c

@@ -314 +314 @@
 
             put_bits(&s->pb, 1, constraint_parameter_flag);
 
-            ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
-            ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
+            ff_write_quant_matrix(&s->pb, (int16_t*)(s->avctx->intra_matrix));
+            ff_write_quant_matrix(&s->pb, (int16_t*)(s->avctx->inter_matrix));
 
             if(s->codec_id == CODEC_ID_MPEG2VIDEO){
                 put_header(s, EXT_START_CODE);
@@ -2689 +2689 @@
             return 0;
 
         start_code= -1;
-        buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
+        buf = ff_find_start_code(buf, s->gb.buffer_end, (uint32_t *)&start_code);
         mb_y= start_code - SLICE_MIN_START_CODE;
         if(mb_y < 0 || mb_y >= s->end_mb_y)
             return -1;
@@ -3056 +3056 @@
     for(;;) {
         /* find start next code */
         start_code = -1;
-        buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
+        buf_ptr = ff_find_start_code(buf_ptr,buf_end, (uint32_t*)&start_code);
         if (start_code < 0){
             if(s2->pict_type != B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){
                 if(avctx->thread_count > 1){

libavcodec/mpegaudiodec.c

@@ -2440 +2440 @@
         samples_ptr = samples + ch;
         for(i=0;i<nb_frames;i++) {
             ff_mpa_synth_filter(s->synth_buf[ch], &(s->synth_buf_offset[ch]),
-                         window, &s->dither_state,
+                         window, (int *)&s->dither_state,
                          samples_ptr, s->nb_channels,
                          s->sb_samples[ch][i]);
             samples_ptr += 32 * s->nb_channels;

libavcodec/mpegvideo.c

@@ -2230 +2230 @@
         input[i].linesize[2]= c->width/2;
 
         if(!i || s->input_picture[i-1])
-            img_resample(resample, &input[i], &pre_input);
+            img_resample(resample, (int *)&input[i], (int *)&pre_input);
     }
 
     for(j=0; j<s->max_b_frames+1; j++){

libavcodec/parser.c

@@ -314 +314 @@
     buf_end = buf + buf_size;
     while (buf < buf_end) {
         start_code= -1;
-        buf= ff_find_start_code(buf, buf_end, &start_code);
+        buf= ff_find_start_code(buf, buf_end, (uint32_t *)&start_code);
         bytes_left = buf_end - buf;
         switch(start_code) {
         case PICTURE_START_CODE:

libavcodec/pnm.c

@@ -302 +302 @@
     default:
         return -1;
     }
-    snprintf(s->bytestream, s->bytestream_end - s->bytestream,
+    snprintf((char *)s->bytestream, s->bytestream_end - s->bytestream,
              "P%c\n%d %d\n",
              c, avctx->width, h1);
-    s->bytestream += strlen(s->bytestream);
+    s->bytestream += strlen((char *)s->bytestream);
     if (avctx->pix_fmt != PIX_FMT_MONOWHITE) {
-        snprintf(s->bytestream, s->bytestream_end - s->bytestream,
+        snprintf((char *)s->bytestream, s->bytestream_end - s->bytestream,
                  "%d\n", 255);
-        s->bytestream += strlen(s->bytestream);
+        s->bytestream += strlen((char *)s->bytestream);
     }
 
     ptr = p->data[0];
@@ -388 +388 @@
     default:
         return -1;
     }
-    snprintf(s->bytestream, s->bytestream_end - s->bytestream,
+    snprintf((char *)s->bytestream, s->bytestream_end - s->bytestream,
              "P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\nTUPLETYPE %s\nENDHDR\n",
              w, h, depth, maxval, tuple_type);
-    s->bytestream += strlen(s->bytestream);
+    s->bytestream += strlen((char *)s->bytestream);
 
     ptr = p->data[0];
     linesize = p->linesize[0];

libavcodec/ra144.c

@@ -141 +141 @@
   b=*(glob->iptr++);
   c=*(glob->iptr++);
   d=*(glob->iptr++);
-  if (a) rotate_block(glob->buffer_2,glob->buffer_a,a);
+  if (a) rotate_block((short *)glob->buffer_2,(short *)glob->buffer_a,a);
   memcpy(glob->buffer_b,etable1+b*BLOCKSIZE,BLOCKSIZE*2);
   e=((ftable1[b]>>4)*glob->gval)>>8;
   memcpy(glob->buffer_c,etable2+c*BLOCKSIZE,BLOCKSIZE*2);
   f=((ftable2[c]>>4)*glob->gval)>>8;
-  if (a) g=irms(glob->buffer_a,glob->gval)>>12;
+  if (a) g=irms((short *)glob->buffer_a,glob->gval)>>12;
   else g=0;
-  add_wav(glob,d,a,g,e,f,glob->buffer_a,glob->buffer_b,glob->buffer_c,glob->buffer_d);
+  add_wav(glob,d,a,g,e,f,(short *)glob->buffer_a,(short *)glob->buffer_b,(short *)glob->buffer_c,(short *)glob->buffer_d);
   memmove(glob->buffer_2,glob->buffer_2+BLOCKSIZE,(BUFFERSIZE-BLOCKSIZE)*2);
   memcpy(glob->buffer_2+BUFFERSIZE-BLOCKSIZE,glob->buffer_d,BLOCKSIZE*2);
-  final(glob,glob->gsp,glob->buffer_d,glob->output_buffer,glob->buffer,BLOCKSIZE);
+  final(glob,(short *)glob->gsp,(short *)glob->buffer_d,glob->output_buffer,(int *)glob->buffer,BLOCKSIZE);
 }
 
 /* rotate block */
@@ -450 +450 @@
   while (lptr<glob->swapbuf1+10)
     *(lptr++)=(*(dptr++))[(*(glob->iptr++))<<1];
 
-  do_voice(glob->swapbuf1,glob->swapbuf2);
+  do_voice((int *)glob->swapbuf1,(int *)glob->swapbuf2);
 
   a=t_sqrt(glob->val*glob->oldval)>>12;
 
   for (c=0;c<NBLOCKS;c++) {
     if (c==(NBLOCKS-1)) {
-      dec1(glob,glob->swapbuf1,glob->swapbuf2,3,glob->val);
+      dec1(glob,(int *)glob->swapbuf1,(int *)glob->swapbuf2,3,glob->val);
     } else {
       if (c*2==(NBLOCKS-2)) {
         if (glob->oldval<glob->val) {
-          dec2(glob,glob->swapbuf1,glob->swapbuf2,3,a,glob->swapbuf2alt,c);
+          dec2(glob,(int *)glob->swapbuf1,(int *)glob->swapbuf2,3,a,(int *)glob->swapbuf2alt,c);
         } else {
-          dec2(glob,glob->swapbuf1alt,glob->swapbuf2alt,3,a,glob->swapbuf2,c);
+          dec2(glob,(int *)glob->swapbuf1alt,(int *)glob->swapbuf2alt,3,a,(int *)glob->swapbuf2,c);
         }
       } else {
         if (c*2<(NBLOCKS-2)) {
-          dec2(glob,glob->swapbuf1alt,glob->swapbuf2alt,3,glob->oldval,glob->swapbuf2,c);
+          dec2(glob,(int *)glob->swapbuf1alt,(int *)glob->swapbuf2alt,3,glob->oldval,(int *)glob->swapbuf2,c);
         } else {
-          dec2(glob,glob->swapbuf1,glob->swapbuf2,3,glob->val,glob->swapbuf2alt,c);
+          dec2(glob,(int *)glob->swapbuf1,(int *)glob->swapbuf2,3,glob->val,(int *)glob->swapbuf2alt,c);
         }
       }
     }

libavcodec/svq1.c

@@ -657 +657 @@
     if ((s->f_code ^ 0x10) >= 0x50) {
       char msg[256];
 
-      svq1_parse_string (bitbuf, (char *) msg);
+      svq1_parse_string (bitbuf, (unsigned char *) msg);
 
       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
     }

libavcodec/x264.c

@@ -222 +222 @@
     x4->params.analyse.b_fast_pskip = (avctx->flags2 & CODEC_FLAG2_FASTPSKIP);
 
     x4->params.analyse.i_trellis = avctx->trellis;
-    x4->params.analyse.i_noise_reduction = avctx->noise_reduction;
 
     if(avctx->level > 0) x4->params.i_level_idc = avctx->level;
 

libavformat/avienc.c

@@ -476 +476 @@
             put_byte(pb, 0);        /* bIndexSubType (0 == frame index) */
             put_byte(pb, 0);        /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */
             put_le32(pb, 0);        /* nEntriesInUse (will fill out later on) */
-            put_tag(pb, avi_stream2fourcc(&tag[0], i, stream->codec_type));
+            put_tag(pb, (char *)avi_stream2fourcc(&tag[0], i, stream->codec_type));
                                     /* dwChunkId */
             put_le64(pb, 0);        /* dwReserved[3]
             put_le32(pb, 0);           Must be 0.    */
@@ -531 +531 @@
 
          /* Writing AVI OpenDML leaf index chunk */
          ix = url_ftell(pb);
-         put_tag(pb, &ix_tag[0]);     /* ix?? */
+         put_tag(pb, (char *)&ix_tag[0]);     /* ix?? */
          put_le32(pb, avi->indexes[i].entry * 8 + 24);
                                       /* chunk size */
          put_le16(pb, 2);             /* wLongsPerEntry */
@@ -539 +539 @@
          put_byte(pb, 1);             /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */
          put_le32(pb, avi->indexes[i].entry);
                                       /* nEntriesInUse */
-         put_tag(pb, &tag[0]);        /* dwChunkId */
+         put_tag(pb, (char *)&tag[0]);        /* dwChunkId */
          put_le64(pb, avi->movi_list);/* qwBaseOffset */
          put_le32(pb, 0);             /* dwReserved_3 (must be 0) */
 
@@ -599 +599 @@
             if (!empty) {
                 avi_stream2fourcc(&tag[0], stream_id,
                                   s->streams[stream_id]->codec->codec_type);
-                put_tag(pb, &tag[0]);
+                put_tag(pb, (char *)&tag[0]);
                 put_le32(pb, ie->flags);
                 put_le32(pb, ie->pos);
                 put_le32(pb, ie->len);

libavformat/aviobuf.c

@@ -586 +586 @@
     va_start(ap, fmt);
     ret = vsnprintf(buf, sizeof(buf), fmt, ap);
     va_end(ap);
-    put_buffer(s, buf, strlen(buf));
+    put_buffer(s, (unsigned char *)buf, strlen(buf));
     return ret;
 }
 #endif //CONFIG_MUXERS

libavformat/crc.c

@@ -85 +85 @@
     char buf[64];
 
     snprintf(buf, sizeof(buf), "CRC=0x%08x\n", crc->crcval);
-    put_buffer(&s->pb, buf, strlen(buf));
+    put_buffer(&s->pb, (unsigned char *)buf, strlen(buf));
     put_flush_packet(&s->pb);
     return 0;
 }
@@ -96 +96 @@
     char buf[256];
 
     snprintf(buf, sizeof(buf), "%d, %"PRId64", %d, 0x%08x\n", pkt->stream_index, pkt->dts, pkt->size, crc);
-    put_buffer(&s->pb, buf, strlen(buf));
+    put_buffer(&s->pb, (unsigned char *)buf, strlen(buf));
     put_flush_packet(&s->pb);
     return 0;
 }

libavformat/flvdec.c

@@ -87 +87 @@
             len= get_be16(&s->pb);
             if(len >= sizeof(tmp) || !len)
                 break;
-            get_buffer(&s->pb, tmp, len);
+            get_buffer(&s->pb, (unsigned char *)tmp, len);
             tmp[len]=0;
 
             type= get_byte(&s->pb);

libavformat/ipmovie.c

@@ -507 +507 @@
 {
     if (p->buf_size < IPMOVIE_SIGNATURE_SIZE)
         return 0;
-    if (strncmp(p->buf, IPMOVIE_SIGNATURE, IPMOVIE_SIGNATURE_SIZE) != 0)
+    if (strncmp((char *)p->buf, IPMOVIE_SIGNATURE, IPMOVIE_SIGNATURE_SIZE) != 0)
         return 0;
 
     return AVPROBE_SCORE_MAX;

libavformat/matroska.c

@@ -1656 +1656 @@
                         case MATROSKA_ID_CUETIME: {
                             int64_t time;
                             if ((res = ebml_read_uint(matroska, &id,
-                                                      &time)) < 0)
+                                                      (uint64_t *)&time)) < 0)
                                 break;
                             idx.time = time * matroska->time_scale;
                             break;

libavformat/mmf.c

@@ -59 +59 @@
     MMFContext *mmf = s->priv_data;
     ByteIOContext *pb = &s->pb;
     offset_t pos;
-    int rate;
+    unsigned int rate;
 
     rate = mmf_rate_code(s->streams[0]->codec->sample_rate);
     if(rate < 0) {
@@ -78 +78 @@
     put_tag(pb, "VN:libavcodec,"); /* metadata ("ST:songtitle,VN:version,...") */
     end_tag_be(pb, pos);
 
-    put_buffer(pb, "ATR\x00", 4);
+    put_buffer(pb, (unsigned char*)"ATR\x00", 4);
     put_be32(pb, 0);
     mmf->atrpos = url_ftell(pb);
     put_byte(pb, 0); /* format type */
@@ -92 +92 @@
     put_be32(pb, 16);
     mmf->atsqpos = url_ftell(pb);
     /* Will be filled on close */
-    put_buffer(pb, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16);
+    put_buffer(pb, (unsigned char*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16);
 
     mmf->awapos = start_tag(pb, "Awa\x01");
 
@@ -149 +149 @@
 
         /* "nop" */
         put_varlength(pb, gatetime); /* start time */
-        put_buffer(pb, "\xff\x00", 2); /* nop */
+        put_buffer(pb, (unsigned char*)"\xff\x00", 2); /* nop */
 
         /* "end of sequence" */
-        put_buffer(pb, "\x00\x00\x00\x00", 4);
+        put_buffer(pb, (unsigned char*)"\x00\x00\x00\x00", 4);
 
         url_fseek(pb, pos, SEEK_SET);
 

libavformat/movenc.c

@@ -514 +514 @@
     if (track->enc->codec && track->enc->codec->name)
         strncpy(compressor_name,track->enc->codec->name,31);
     put_byte(pb, strlen(compressor_name));
-    put_buffer(pb, compressor_name, 31);
+    put_buffer(pb, (unsigned char *)compressor_name, 31);
 
     put_be16(pb, 0x18); /* Reserved */
     put_be16(pb, 0xffff); /* Reserved */
@@ -637 +637 @@
     put_be32(pb, 0); /* size */
     put_tag(pb, "hdlr");
     put_be32(pb, 0); /* Version & flags */
-    put_buffer(pb, hdlr, 4); /* handler */
+    put_buffer(pb, (unsigned char *)hdlr, 4); /* handler */
     put_tag(pb, hdlr_type); /* handler type */
     put_be32(pb ,0); /* reserved */
     put_be32(pb ,0); /* reserved */
     put_be32(pb ,0); /* reserved */
     put_byte(pb, strlen(descr)); /* string counter */
-    put_buffer(pb, descr, strlen(descr)); /* handler description */
+    put_buffer(pb, (unsigned char *)descr, strlen(descr)); /* handler description */
     return updateSize(pb, pos);
 }
 
@@ -874 +874 @@
     put_tag(pb, "data");
     put_be32(pb, 1);
     put_be32(pb, 0);
-    put_buffer(pb, data, strlen(data));
+    put_buffer(pb, (unsigned char *)data, strlen(data));
     return updateSize(pb, pos);
 }
 
@@ -1084 +1084 @@
             put_tag(pb, "\251req");
             put_be16(pb, sizeof("QuickTime 6.0 or greater") - 1);
             put_be16(pb, 0);
-            put_buffer(pb, "QuickTime 6.0 or greater",
+            put_buffer(pb, (unsigned char *)"QuickTime 6.0 or greater",
                        sizeof("QuickTime 6.0 or greater") - 1);
             updateSize(pb, pos);
             break;
@@ -1099 +1099 @@
         put_tag(pb, "\251enc");
         put_be16(pb, sizeof(LIBAVFORMAT_IDENT) - 1); /* string length */
         put_be16(pb, 0);
-        put_buffer(pb, LIBAVFORMAT_IDENT, sizeof(LIBAVFORMAT_IDENT) - 1);
+        put_buffer(pb, (unsigned char *)LIBAVFORMAT_IDENT, sizeof(LIBAVFORMAT_IDENT) - 1);
         updateSize(pb, pos);
     }
 
@@ -1110 +1110 @@
         put_tag(pb, "\251nam");
         put_be16(pb, strlen(s->title)); /* string length */
         put_be16(pb, 0);
-        put_buffer(pb, s->title, strlen(s->title));
+        put_buffer(pb, (unsigned char *)s->title, strlen(s->title));
         updateSize(pb, pos);
     }
 
@@ -1121 +1121 @@
         put_tag(pb, /*"\251aut"*/ "\251day" );
         put_be16(pb, strlen(s->author)); /* string length */
         put_be16(pb, 0);
-        put_buffer(pb, s->author, strlen(s->author));
+        put_buffer(pb, (unsigned char *)s->author, strlen(s->author));
         updateSize(pb, pos);
     }
 
@@ -1132 +1132 @@
         put_tag(pb, "\251des");
         put_be16(pb, strlen(s->comment)); /* string length */
         put_be16(pb, 0);
-        put_buffer(pb, s->comment, strlen(s->comment));
+        put_buffer(pb, (unsigned char *)s->comment, strlen(s->comment));
         updateSize(pb, pos);
     }
 

libavformat/mp3.c

@@ -216 +216 @@
     buf[0] = 'T';
     buf[1] = 'A';
     buf[2] = 'G';
-    strncpy(buf + 3, s->title, 30);
-    strncpy(buf + 33, s->author, 30);
-    strncpy(buf + 63, s->album, 30);
+    strncpy((char *)buf + 3, s->title, 30);
+    strncpy((char *)buf + 33, s->author, 30);
+    strncpy((char *)buf + 63, s->album, 30);
     v = s->year;
     if (v > 0) {
         for(i = 0;i < 4; i++) {
@@ -226 +226 @@
             v = v / 10;
         }
     }
-    strncpy(buf + 97, s->comment, 30);
+    strncpy((char *)buf + 97, s->comment, 30);
     if (s->track != 0) {
         buf[125] = 0;
         buf[126] = s->track;

libavformat/mpeg.c

@@ -1428 +1428 @@
         /* next start code (should be immediately after) */
         m->header_state = 0xff;
         size = MAX_SYNC_SIZE;
-        startcode = find_next_start_code(&s->pb, &size, &m->header_state);
+        startcode = find_next_start_code(&s->pb, &size, (uint32_t *)(&m->header_state));
     //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
     if (startcode < 0)
         return AVERROR_IO;

libavformat/mpjpeg.c

@@ -27 +27 @@
 {
     uint8_t buf1[256];
 
-    snprintf(buf1, sizeof(buf1), "--%s\n", BOUNDARY_TAG);
-    put_buffer(&s->pb, buf1, strlen(buf1));
+    snprintf((char *)buf1, sizeof(buf1), "--%s\n", BOUNDARY_TAG);
+    put_buffer(&s->pb, buf1, strlen((char *)buf1));
     put_flush_packet(&s->pb);
     return 0;
 }
@@ -37 +37 @@
 {
     uint8_t buf1[256];
 
-    snprintf(buf1, sizeof(buf1), "Content-type: image/jpeg\n\n");
-    put_buffer(&s->pb, buf1, strlen(buf1));
+    snprintf((char *)buf1, sizeof(buf1), "Content-type: image/jpeg\n\n");
+    put_buffer(&s->pb, buf1, strlen((char *)buf1));
     put_buffer(&s->pb, pkt->data, pkt->size);
 
-    snprintf(buf1, sizeof(buf1), "\n--%s\n", BOUNDARY_TAG);
-    put_buffer(&s->pb, buf1, strlen(buf1));
+    snprintf((char *)buf1, sizeof(buf1), "\n--%s\n", BOUNDARY_TAG);
+    put_buffer(&s->pb, buf1, strlen((char *)buf1));
     put_flush_packet(&s->pb);
     return 0;
 }

libavformat/nsvdec.c

@@ -322 +322 @@
 
         p = strings = av_mallocz(strings_size + 1);
         endp = strings + strings_size;
-        get_buffer(pb, strings, strings_size);
+        get_buffer(pb, (unsigned char *)strings, strings_size);
         while (p < endp) {
             while (*p == ' ')
                 p++; /* strip out spaces */

libavformat/nut.c

@@ -260 +260 @@
     unsigned int len= get_v(bc);
 
     if(len && maxlen)
-        get_buffer(bc, string, FFMIN(len, maxlen));
+        get_buffer(bc, (unsigned char*)string, FFMIN(len, maxlen));
     while(len > maxlen){
         get_byte(bc);
         len--;
@@ -424 +424 @@
     int len= strlen(string);
 
     put_v(bc, len);
-    put_buffer(bc, string, len);
+    put_buffer(bc, (unsigned char*)string, len);
 }
 
 static void put_s(ByteIOContext *bc, int64_t val){
@@ -525 +525 @@
         av_mallocz(sizeof(StreamContext)*s->nb_streams);
 
 
-    put_buffer(bc, ID_STRING, strlen(ID_STRING));
+    put_buffer(bc, (unsigned char*)ID_STRING, strlen(ID_STRING));
     put_byte(bc, 0);
     nut->packet_start[2]= url_ftell(bc);
 

libavformat/ogg2.c

@@ -220 +220 @@
     char sync[4];
     int sp = 0;
 
-    if (get_buffer (bc, sync, 4) < 4)
+    if (get_buffer (bc, (unsigned char *)sync, 4) < 4)
         return -1;
 
     do{

libavformat/oggparseflac.c

@@ -64 +64 @@
                 FLAC_STREAMINFO_SIZE);
         st->codec->extradata_size = FLAC_STREAMINFO_SIZE;
     } else if (mdt == 4) {
-        vorbis_comment (s, os->buf + os->pstart + 4, os->psize - 4);
+        vorbis_comment (s, (char *)(os->buf + os->pstart + 4), (int)((unsigned *)os->psize - 4));
     }
 
     return 1;
 }
 
 ogg_codec_t flac_codec = {
-    .magic = "\177FLAC",
+    .magic = (unsigned char*)"\177FLAC",
     .magicsize = 5,
     .header = flac_header
 };

libavformat/oggparsetheora.c

@@ -80 +80 @@
         st->codec->codec_id = CODEC_ID_THEORA;
 
     } else if (os->buf[os->pstart] == 0x83) {
-        vorbis_comment (s, os->buf + os->pstart + 7, os->psize - 8);
+        vorbis_comment (s, (char *)os->buf + os->pstart + 7, os->psize - 8);
     }
 
     st->codec->extradata = av_realloc (st->codec->extradata, cds);

libavformat/oggparsevorbis.c

@@ -187 +187 @@
         st->codec->codec_id = CODEC_ID_VORBIS;
 
     } else if (os->buf[os->pstart] == 3) {
-        vorbis_comment (s, os->buf + os->pstart + 7, os->psize - 8);
+        vorbis_comment (s, (char *)os->buf + os->pstart + 7, os->psize - 8);
     } else {
         st->codec->extradata_size =
             fixup_vorbis_headers(s, priv, &st->codec->extradata);
@@ -197 +197 @@
 }
 
 ogg_codec_t vorbis_codec = {
-    .magic = "\001vorbis",
+    .magic = (unsigned char *)"\001vorbis",
     .magicsize = 7,
     .header = vorbis_header
 };

libavformat/pnm.c

@@ -189 +189 @@
     snprintf(buf, sizeof(buf),
              "P%c\n%d %d\n",
              c, info->width, h1);
-    put_buffer(pb, buf, strlen(buf));
+    put_buffer(pb, (unsigned char *)buf, strlen(buf));
     if (info->pix_fmt != PIX_FMT_MONOWHITE) {
         snprintf(buf, sizeof(buf),
                  "%d\n", 255);
-        put_buffer(pb, buf, strlen(buf));
+        put_buffer(pb, (unsigned char *)buf, strlen(buf));
     }
 
     ptr = info->pict.data[0];
@@ -359 +359 @@
     snprintf(buf, sizeof(buf),
              "P7\nWIDTH %d\nHEIGHT %d\nDEPTH %d\nMAXVAL %d\nTUPLETYPE %s\nENDHDR\n",
              w, h, depth, maxval, tuple_type);
-    put_buffer(pb, buf, strlen(buf));
+    put_buffer(pb, (unsigned char *)buf, strlen(buf));
 
     ptr = info->pict.data[0];
     linesize = info->pict.linesize[0];
@@ -390 +390 @@
 
 static int pnm_probe(AVProbeData *pd)
 {
-    const char *p = pd->buf;
+    const unsigned char *p = pd->buf;
     if (pd->buf_size >= 8 &&
         p[0] == 'P' &&
         p[1] >= '4' && p[1] <= '6' &&
@@ -410 +410 @@
 
 static int pam_probe(AVProbeData *pd)
 {
-    const char *p = pd->buf;
+    const unsigned char *p = pd->buf;
     if (pd->buf_size >= 8 &&
         p[0] == 'P' &&
         p[1] == '7' &&

libavformat/sgi.c

@@ -417 +417 @@
 
         for (y = si->ysize -1; y >= 0; y--) {
             offsettab[(z * si->ysize) + y] = url_ftell(pb);
-            lengthtab[(z * si->ysize) + y] = rle_row(pb, srcrow,
+            lengthtab[(z * si->ysize) + y] = rle_row(pb, (char *)srcrow,
                     si->zsize, si->xsize);
             srcrow += info->pict.linesize[0];
         }

libavformat/utils.c

@@ -1140 +1140 @@
         return -1;
 
     entries = av_fast_realloc(st->index_entries,
-                              &st->index_entries_allocated_size,
+                              (unsigned int *)&st->index_entries_allocated_size,
                               (st->nb_index_entries + 1) *
                               sizeof(AVIndexEntry));
     if(!entries)

libavformat/wc3movie.c

@@ -182 +182 @@
                 bytes_to_read = size;
             else
                 bytes_to_read = 512;
-            if ((ret = get_buffer(pb, s->title, bytes_to_read)) != bytes_to_read)
+            if ((ret = get_buffer(pb, (unsigned char*)s->title, bytes_to_read)) != bytes_to_read)
                 return AVERROR_IO;
             break;
 

libavformat/yuv4mpeg.c

@@ -105 +105 @@
             av_log(s, AV_LOG_ERROR, "Error. YUV4MPEG stream header write failed.\n");
             return AVERROR_IO;
         } else {
-            put_buffer(pb, buf2, strlen(buf2));
+            put_buffer(pb, (unsigned char *)buf2, strlen(buf2));
         }
     }
 
     /* construct frame header */
 
     m = snprintf(buf1, sizeof(buf1), "%s\n", Y4M_FRAME_MAGIC);
-    put_buffer(pb, buf1, strlen(buf1));
+    put_buffer(pb, (unsigned char *)buf1, strlen(buf1));
 
     width = st->codec->width;
     height = st->codec->height;
@@ -387 +387 @@
     /* check file header */
     if (pd->buf_size <= sizeof(Y4M_MAGIC))
         return 0;
-    if (strncmp(pd->buf, Y4M_MAGIC, sizeof(Y4M_MAGIC)-1)==0)
+    if (strncmp((char *)pd->buf, Y4M_MAGIC, sizeof(Y4M_MAGIC)-1)==0)
         return AVPROBE_SCORE_MAX;
     else
         return 0;

libmpcodecs/ad_acm.c

@@ -31 +31 @@
 
 static int init(sh_audio_t *sh_audio)
 {
-    int ret=decode_audio(sh_audio,sh_audio->a_buffer,4096,sh_audio->a_buffer_size);
+    int ret=decode_audio(sh_audio,(unsigned char *)sh_audio->a_buffer,4096,sh_audio->a_buffer_size);
     if(ret<0){
         mp_msg(MSGT_DECAUDIO,MSGL_INFO,"ACM decoding error: %d\n",ret);
         return 0;
@@ -201 +201 @@
     if(srcsize>sh_audio->a_in_buffer_size) srcsize=sh_audio->a_in_buffer_size; // !!!!!!
     if(sh_audio->a_in_buffer_len<srcsize){
       sh_audio->a_in_buffer_len+=
-        demux_read_data(sh_audio->ds,&sh_audio->a_in_buffer[sh_audio->a_in_buffer_len],
+        demux_read_data(sh_audio->ds,(unsigned char *)&sh_audio->a_in_buffer[sh_audio->a_in_buffer_len],
         srcsize-sh_audio->a_in_buffer_len);
     }
     mp_msg(MSGT_WIN32,MSGL_DBG3,"acm convert %d -> %ld bytes\n",sh_audio->a_in_buffer_len,len);

libmpcodecs/ad_dk3adpcm.c

@@ -95 +95 @@
 static int control(sh_audio_t *sh_audio,int cmd,void* arg, ...)
 {
   if(cmd==ADCTRL_SKIP_FRAME){
-    demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
+    demux_read_data(sh_audio->ds, (unsigned char *)sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
     return CONTROL_TRUE;
   }
   return CONTROL_UNKNOWN;
@@ -232 +232 @@
 
 static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
 {
-  if (demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,
+  if (demux_read_data(sh_audio->ds, (unsigned char *)sh_audio->a_in_buffer,
     sh_audio->ds->ss_mul) != 
     sh_audio->ds->ss_mul) 
       return -1; /* EOF */
@@ -242 +242 @@
     return -1;
   }
   return 2 * dk3_adpcm_decode_block(
-    (unsigned short*)buf, sh_audio->a_in_buffer,
+    (unsigned short*)buf, (unsigned char *)sh_audio->a_in_buffer,
     sh_audio->ds->ss_mul);
 }

libmpcodecs/ad_dmo.c

@@ -86 +86 @@
         if(srcsize>sh_audio->a_in_buffer_size) srcsize=sh_audio->a_in_buffer_size; // !!!!!!
         if(sh_audio->a_in_buffer_len<srcsize){
           sh_audio->a_in_buffer_len+=
-            demux_read_data(sh_audio->ds,&sh_audio->a_in_buffer[sh_audio->a_in_buffer_len],
+            demux_read_data(sh_audio->ds,(unsigned char *)&sh_audio->a_in_buffer[sh_audio->a_in_buffer_len],
             srcsize-sh_audio->a_in_buffer_len);
         }
         DMO_AudioDecoder_Convert(ds_adec, sh_audio->a_in_buffer,sh_audio->a_in_buffer_len,
-            buf,maxlen, &size_in,&size_out);
+            buf,maxlen, (unsigned int *)&size_in,(unsigned int *)&size_out);
         mp_dbg(MSGT_DECAUDIO,MSGL_DBG2,"DMO: audio %d -> %d converted  (in_buf_len=%d of %d)  %d\n",size_in,size_out,sh_audio->a_in_buffer_len,sh_audio->a_in_buffer_size,ds_tell_pts(sh_audio->ds));
         if(size_in>=sh_audio->a_in_buffer_len){
           sh_audio->a_in_buffer_len=0;

libmpcodecs/ad_dshow.c

@@ -82 +82 @@
         if(srcsize>sh_audio->a_in_buffer_size) srcsize=sh_audio->a_in_buffer_size; // !!!!!!
         if(sh_audio->a_in_buffer_len<srcsize){
           sh_audio->a_in_buffer_len+=
-            demux_read_data(sh_audio->ds,&sh_audio->a_in_buffer[sh_audio->a_in_buffer_len],
+            demux_read_data(sh_audio->ds,(unsigned char *)&sh_audio->a_in_buffer[sh_audio->a_in_buffer_len],
             srcsize-sh_audio->a_in_buffer_len);
         }
         DS_AudioDecoder_Convert(ds_adec, sh_audio->a_in_buffer,sh_audio->a_in_buffer_len,
-            buf,maxlen, &size_in,&size_out);
+            buf,maxlen, (unsigned int *)&size_in,(unsigned int *)&size_out);
         mp_dbg(MSGT_DECAUDIO,MSGL_DBG2,"DShow: audio %d -> %d converted  (in_buf_len=%d of %d)  %d\n",size_in,size_out,sh_audio->a_in_buffer_len,sh_audio->a_in_buffer_size,ds_tell_pts(sh_audio->ds));
         if(size_in>=sh_audio->a_in_buffer_len){
           sh_audio->a_in_buffer_len=0;

libmpcodecs/ad_dvdpcm.c

@@ -94 +94 @@
       // can somebody clarify?
       for (j = 0; j < minlen; j += 12) {
         char tmp[10];
-        len = demux_read_data(sh_audio->ds, tmp, 10);
+        len = demux_read_data(sh_audio->ds, (unsigned char *)tmp, 10);
         if (len < 10) break;
         // first sample
         buf[j + 0] = tmp[0];
@@ -118 +118 @@
       // 24 bit
       for (j = 0; j < minlen; j += 12) {
         char tmp[12];
-        len = demux_read_data(sh_audio->ds, tmp, 12);
+        len = demux_read_data(sh_audio->ds, (unsigned char *)tmp, 12);
         if (len < 12) break;
         // first sample
         buf[j + 0] = tmp[0];

libmpcodecs/ad_faad.c

@@ -77 +77 @@
   // If we don't get the ES descriptor, try manual config
   if(!sh->codecdata_len && sh->wf) {
     sh->codecdata_len = sh->wf->cbSize;
-    sh->codecdata = (char*)(sh->wf+1);
+    sh->codecdata = (unsigned char*)(sh->wf+1);
     mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"FAAD: codecdata extracted from WAVEFORMATEX\n");
   }
   if(!sh->codecdata_len) {
@@ -112 +112 @@
     faacDecSetConfiguration(faac_hdec, faac_conf);
 #endif
 
-    sh->a_in_buffer_len = demux_read_data(sh->ds, sh->a_in_buffer, sh->a_in_buffer_size);
-    pos = aac_probe(sh->a_in_buffer, sh->a_in_buffer_len);
+    sh->a_in_buffer_len = demux_read_data(sh->ds, (unsigned char *)sh->a_in_buffer, sh->a_in_buffer_size);
+    pos = aac_probe((unsigned char *)sh->a_in_buffer, sh->a_in_buffer_len);
     if(pos) {
       sh->a_in_buffer_len -= pos;
       memmove(sh->a_in_buffer, &(sh->a_in_buffer[pos]), sh->a_in_buffer_len);
       sh->a_in_buffer_len +=
-        demux_read_data(sh->ds,&(sh->a_in_buffer[sh->a_in_buffer_len]),
+        demux_read_data(sh->ds,(unsigned char *)&(sh->a_in_buffer[sh->a_in_buffer_len]),
         sh->a_in_buffer_size - sh->a_in_buffer_len);
       pos = 0;
     }
 
     /* init the codec */
-    faac_init = faacDecInit(faac_hdec, sh->a_in_buffer,
+    faac_init = faacDecInit(faac_hdec, (unsigned char *)sh->a_in_buffer,
        sh->a_in_buffer_len, &faac_samplerate, &faac_channels);
 
     sh->a_in_buffer_len -= (faac_init > 0)?faac_init:0; // how many bytes init consumed
@@ -178 +178 @@
   if(!sh->codecdata_len) {
     if(sh->a_in_buffer_len < sh->a_in_buffer_size){
       sh->a_in_buffer_len +=
-        demux_read_data(sh->ds,&sh->a_in_buffer[sh->a_in_buffer_len],
+        demux_read_data(sh->ds,(unsigned char *)&sh->a_in_buffer[sh->a_in_buffer_len],
         sh->a_in_buffer_size - sh->a_in_buffer_len);
     }
-    pos = aac_probe(sh->a_in_buffer, sh->a_in_buffer_len);
+    pos = aac_probe((unsigned char *)sh->a_in_buffer, sh->a_in_buffer_len);
     if(pos) {
       sh->a_in_buffer_len -= pos;
       memmove(sh->a_in_buffer, &(sh->a_in_buffer[pos]), sh->a_in_buffer_len);
@@ -218 +218 @@
   if(!sh->codecdata_len)
     if(sh->a_in_buffer_len < sh->a_in_buffer_size){
       sh->a_in_buffer_len +=
-        demux_read_data(sh->ds,&sh->a_in_buffer[sh->a_in_buffer_len],
+        demux_read_data(sh->ds,(unsigned char *)&sh->a_in_buffer[sh->a_in_buffer_len],
         sh->a_in_buffer_size - sh->a_in_buffer_len);
     }
           
@@ -232 +232 @@
   if(!sh->codecdata_len){
    // raw aac stream:
    do {
-    faac_sample_buffer = faacDecDecode(faac_hdec, &faac_finfo, sh->a_in_buffer+j, sh->a_in_buffer_len);
+    faac_sample_buffer = faacDecDecode(faac_hdec, &faac_finfo, (unsigned char *)sh->a_in_buffer+j, sh->a_in_buffer_len);
         
     /* update buffer index after faacDecDecode */
     if(faac_finfo.bytesconsumed >= sh->a_in_buffer_len) {

libmpcodecs/ad_ffmpeg.c

@@ -106 +106 @@
    }
 
    // Decode at least 1 byte:  (to get header filled)
-   x=decode_audio(sh_audio,sh_audio->a_buffer,1,sh_audio->a_buffer_size);
+   x=decode_audio(sh_audio,(unsigned char *)sh_audio->a_buffer,1,sh_audio->a_buffer_size);
    if(x>0) sh_audio->a_buffer_len=x;
 
 #if 1

libmpcodecs/ad_hwac3.c

@@ -59 +59 @@
       sh_audio->a_in_buffer[sh_audio->a_in_buffer_len++] = c;
     }
 
-    length = dts_syncinfo(sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
+    length = dts_syncinfo((uint8_t *)sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
     if(length >= 10)
     {
       if(isdts != 1)
@@ -69 +69 @@
       }
       break;
     }
-    length = a52_syncinfo(sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
+    length = a52_syncinfo((uint8_t *)sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
     if(length >= 7 && length <= 3840) 
     {
       if(isdts != 0)
@@ -87 +87 @@
 
   sh_audio->samplerate = sample_rate;
   sh_audio->i_bps = bit_rate / 8;
-  demux_read_data(sh_audio->ds, sh_audio->a_in_buffer + 10, length - 10);
+  demux_read_data(sh_audio->ds, (unsigned char *)sh_audio->a_in_buffer + 10, length - 10);
   sh_audio->a_in_buffer_len = length;
     
   // TODO: is DTS also checksummed?
-  if(isdts == 0 && crc16_block(sh_audio->a_in_buffer + 2, length - 2) != 0)
+  if(isdts == 0 && crc16_block((uint8_t *)sh_audio->a_in_buffer + 2, length - 2) != 0)
     mp_msg(MSGT_DECAUDIO, MSGL_STATUS, "a52: CRC check failed!  \n");
     
   return length;
@@ -154 +154 @@
 
   if(isdts == 1)
   {
-    return decode_audio_dts(sh_audio->a_in_buffer, len, buf);
+    return decode_audio_dts((uint8_t *)sh_audio->a_in_buffer, len, buf);
   }
   else if(isdts == 0)
   {

libmpcodecs/ad_hwmpa.c

@@ -38 +38 @@
                 {
                         if(((sh->a_in_buffer[cnt] << 8) | sh->a_in_buffer[cnt+1]) & 0xffe0 != 0xffe0)
                                 continue;
-                        x = mp_get_mp3_header(&(sh->a_in_buffer[cnt]), chans, srate, spf, mpa_layer, br);
+                        x = mp_get_mp3_header((unsigned char *)&(sh->a_in_buffer[cnt]), chans, srate, spf, mpa_layer, br);
                         if(x > 0)
                         {
                                 frames_count++;
@@ -50 +50 @@
                         }
                         cnt++;
                 }
-                len = demux_read_data(sh->ds,&sh->a_in_buffer[sh->a_in_buffer_len],sh->a_in_buffer_size-sh->a_in_buffer_len);
+                len = demux_read_data(sh->ds,(unsigned char *)&sh->a_in_buffer[sh->a_in_buffer_len],sh->a_in_buffer_size-sh->a_in_buffer_len);
                 if(len > 0)
                         sh->a_in_buffer_len += len;
         } while(len > 0);

libmpcodecs/ad_imaadpcm.c

@@ -123 +123 @@
 static int control(sh_audio_t *sh_audio,int cmd,void* arg, ...)
 {
   if(cmd==ADCTRL_SKIP_FRAME){
-    demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
+    demux_read_data(sh_audio->ds, (unsigned char *)sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
     return CONTROL_TRUE;
   }
   return CONTROL_UNKNOWN;
@@ -350 +350 @@
 
 static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
 {
-  if (demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,
+  if (demux_read_data(sh_audio->ds, (unsigned char *)sh_audio->a_in_buffer,
     sh_audio->ds->ss_mul) != 
     sh_audio->ds->ss_mul) 
     return -1;
@@ -358 +358 @@
   if ((sh_audio->format == 0x11) || (sh_audio->format == 0x1100736d))
   {
     return 2 * ms_ima_adpcm_decode_block(
-      (unsigned short*)buf, sh_audio->a_in_buffer, sh_audio->wf->nChannels,
+      (unsigned short*)buf, (unsigned char *)sh_audio->a_in_buffer, sh_audio->wf->nChannels,
       sh_audio->ds->ss_mul);
   }
   else if (sh_audio->format == 0x61)
   {
     return 2 * dk4_ima_adpcm_decode_block(
-      (unsigned short*)buf, sh_audio->a_in_buffer, sh_audio->wf->nChannels,
+      (unsigned short*)buf, (unsigned char *)sh_audio->a_in_buffer, sh_audio->wf->nChannels,
       sh_audio->ds->ss_mul);
   }
   else
   {
     return 2 * qt_ima_adpcm_decode_block(
-      (unsigned short*)buf, sh_audio->a_in_buffer, sh_audio->wf->nChannels);
+      (unsigned short*)buf, (unsigned char *)sh_audio->a_in_buffer, sh_audio->wf->nChannels);
   }
 }

libmpcodecs/ad_liba52.c

@@ -69 +69 @@
         sh_audio->a_in_buffer[sh_audio->a_in_buffer_len++]=c;
     }
     if(sh_audio->format!=0x2000) swab(sh_audio->a_in_buffer,sh_audio->a_in_buffer,8);
-    length = a52_syncinfo (sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
+    length = a52_syncinfo ((uint8_t *)sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
     if(length>=7 && length<=3840) break; /* we're done.*/
     /* bad file => resync*/
     if(sh_audio->format!=0x2000) swab(sh_audio->a_in_buffer,sh_audio->a_in_buffer,8);
@@ -80 +80 @@
     sh_audio->samplerate=sample_rate;
     sh_audio->i_bps=bit_rate/8;
     sh_audio->samplesize=sh_audio->sample_format==AF_FORMAT_FLOAT_NE ? 4 : 2;
-    demux_read_data(sh_audio->ds,sh_audio->a_in_buffer+8,length-8);
+    demux_read_data(sh_audio->ds,(unsigned char *)sh_audio->a_in_buffer+8,length-8);
     if(sh_audio->format!=0x2000)
         swab(sh_audio->a_in_buffer+8,sh_audio->a_in_buffer+8,length-8);
     
-    if(crc16_block(sh_audio->a_in_buffer+2,length-2)!=0)
+    if(crc16_block((uint8_t *)sh_audio->a_in_buffer+2,length-2)!=0)
         mp_msg(MSGT_DECAUDIO,MSGL_STATUS,"a52: CRC check failed!  \n");
     
     return length;
@@ -95 +95 @@
 int flags, sample_rate, bit_rate;
 char* mode="unknown";
 int channels=0;
-  a52_syncinfo (sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
+  a52_syncinfo ((uint8_t *)sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
   switch(flags&A52_CHANNEL_MASK){
     case A52_CHANNEL: mode="channel"; channels=2; break;
     case A52_MONO: mode="mono"; channels=1; break;
@@ -210 +210 @@
   /* test:*/
   flags=a52_flags|A52_ADJUST_LEVEL;
   mp_msg(MSGT_DECAUDIO,MSGL_V,"A52 flags before a52_frame: 0x%X\n",flags);
-  if (a52_frame (&a52_state, sh_audio->a_in_buffer, &flags, &level, bias)){
+  if (a52_frame (&a52_state, (unsigned char *)sh_audio->a_in_buffer, &flags, &level, bias)){
     mp_msg(MSGT_DECAUDIO,MSGL_ERR,"a52: error decoding frame -> nosound\n");
     return 0;
   }
@@ -297 +297 @@
         if(!sh_audio->a_in_buffer_len) 
             if(a52_fillbuff(sh_audio)<0) return len; /* EOF */
         sh_audio->a_in_buffer_len=0;
-        if (a52_frame (&a52_state, sh_audio->a_in_buffer, &flags, &level, bias)){
+        if (a52_frame (&a52_state, (unsigned char *)sh_audio->a_in_buffer, &flags, &level, bias)){
             mp_msg(MSGT_DECAUDIO,MSGL_WARN,"a52: error decoding frame\n");
             return len;
         }

libmpcodecs/ad_libvorbis.c

@@ -89 +89 @@
   }
 
   mp_msg(MSGT_DECAUDIO,MSGL_V,"ad_vorbis, extradata seems is %d bytes long\n", sh->wf->cbSize);
-  extradata = (char*) (sh->wf+1);
+  extradata = (unsigned char*) (sh->wf+1);
   if(!extradata) {
     mp_msg(MSGT_DECAUDIO,MSGL_ERR,"ad_vorbis, extradata seems to be NULL!, exit\n");
     ERROR();

libmpcodecs/ad_mp3lib.c

@@ -26 +26 @@
 
 // MP3 decoder buffer callback:
 int mplayer_audio_read(char *buf,int size){
-  return demux_read_data(dec_audio_sh->ds,buf,size);
+  return demux_read_data(dec_audio_sh->ds,(unsigned char *)buf,size);
 }
 
 static int preinit(sh_audio_t *sh)
@@ -46 +46 @@
   MP3_Init();
 #endif
   MP3_samplerate=MP3_channels=0;
-  sh->a_buffer_len=MP3_DecodeFrame(sh->a_buffer,-1);
+  sh->a_buffer_len=MP3_DecodeFrame((unsigned char *)sh->a_buffer,-1);
   if(!sh->a_buffer_len) return 0; // unsupported layer/format
   sh->channels=2; // hack
   sh->samplesize=2;

libmpcodecs/ad_msadpcm.c

@@ -90 +90 @@
 static int control(sh_audio_t *sh_audio,int cmd,void* arg, ...)
 {
   if(cmd==ADCTRL_SKIP_FRAME){
-    demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
+    demux_read_data(sh_audio->ds, (unsigned char *)sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
     return CONTROL_TRUE;
   }
   return CONTROL_UNKNOWN;
@@ -205 +205 @@
 
 static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
 {
-  if (demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,
+  if (demux_read_data(sh_audio->ds, (unsigned char *)sh_audio->a_in_buffer,
     sh_audio->ds->ss_mul) != 
     sh_audio->ds->ss_mul) 
       return -1; /* EOF */
 
   return 2 * ms_adpcm_decode_block(
-    (unsigned short*)buf, sh_audio->a_in_buffer,
+    (unsigned short*)buf, (unsigned char *)sh_audio->a_in_buffer,
     sh_audio->wf->nChannels, sh_audio->wf->nBlockAlign);
 }

libmpcodecs/ad_qtaudio.c

@@ -304 +304 @@
 //      InputBufferSize, FramesToGet*OutFrameSize);
 
     if(InputBufferSize>sh->a_in_buffer_len){
-        int x=demux_read_data(sh->ds,&sh->a_in_buffer[sh->a_in_buffer_len],
+        int x=demux_read_data(sh->ds,(unsigned char *)&sh->a_in_buffer[sh->a_in_buffer_len],
             InputBufferSize-sh->a_in_buffer_len);
         if(x>0) sh->a_in_buffer_len+=x;
         if(InputBufferSize>sh->a_in_buffer_len)

libmpcodecs/ad_realaud.c

@@ -412 +412 @@
 
   if(sh->a_in_buffer_len<=0){
       // fill the buffer!
-      demux_read_data(sh->ds, sh->a_in_buffer, sh->wf->nBlockAlign);
+      demux_read_data(sh->ds, (unsigned char *)sh->a_in_buffer, sh->wf->nBlockAlign);
       sh->a_in_buffer_size=
       sh->a_in_buffer_len=sh->wf->nBlockAlign;
   }
   
 #ifdef USE_WIN32DLL
     if (dll_type == 1)
-      result=wraDecode(sh->context, sh->a_in_buffer+sh->a_in_buffer_size-sh->a_in_buffer_len, sh->wf->nBlockAlign,
-       buf, &len, -1);
+      result=wraDecode(sh->context, (char *)sh->a_in_buffer+sh->a_in_buffer_size-sh->a_in_buffer_len, sh->wf->nBlockAlign,
+       (char *)buf, (unsigned int *)&len, -1);
     else
 #endif
-  result=raDecode(sh->context, sh->a_in_buffer+sh->a_in_buffer_size-sh->a_in_buffer_len, sh->wf->nBlockAlign,
-       buf, &len, -1);
+  result=raDecode(sh->context, (char *)sh->a_in_buffer+sh->a_in_buffer_size-sh->a_in_buffer_len, sh->wf->nBlockAlign,
+       (char *)buf, (unsigned int *)&len, -1);
   sh->a_in_buffer_len-=sh->wf->nBlockAlign;
   
 //  printf("radecode: %d bytes, res=0x%X  \n",len,result);

libmpcodecs/ad_twin.c

@@ -212 +212 @@
     mask = 0x1;
     for ( ibits=0; ibits<nbits; ibits++ ){
         if ( priv->readable == 0 ){  /* when the file data buffer is empty */
-            priv->nbuf = demux_read_data(sh->ds, priv->buf, BBUFSIZ);
+            priv->nbuf = demux_read_data(sh->ds, (unsigned char *)priv->buf, BBUFSIZ);
             priv->nbuf *= 8;
             priv->readable = 1;
         }

libmpcodecs/dec_audio.c

@@ -136 +136 @@
         // restore original fourcc:
         if(sh_audio->wf) sh_audio->wf->wFormatTag=i=orig_fourcc;
         if(!(sh_audio->codec=find_audio_codec(sh_audio->format,
-          sh_audio->wf?(&i):NULL, sh_audio->codec, force) )) break;
+          (unsigned int *)(sh_audio->wf?(&i):NULL), sh_audio->codec, force) )) break;
         if(sh_audio->wf) sh_audio->wf->wFormatTag=i;
         // ok we found one codec
         if(sh_audio->codec->flags&CODECS_FLAG_SELECTED) continue; // already tried & failed
@@ -378 +378 @@
       if(maxlen<sh_audio->audio_out_minsize) break; // don't overflow buffer!
       // not enough decoded data waiting, decode 'len' bytes more:
       len=mpadec->decode_audio(sh_audio,
-          sh_audio->a_buffer+sh_audio->a_buffer_len, len, maxlen);
+          (unsigned char *)(sh_audio->a_buffer+sh_audio->a_buffer_len), len, maxlen);
       if(len<=0) break; // EOF?
       sh_audio->a_buffer_len+=len;
   }

libmpcodecs/native/RTjpegN.c

@@ -2882 +2882 @@
    RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
    sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
 
-   RTjpeg_dctY(bp1+j, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_dctY((unsigned char *)bp1+j, RTjpeg_block, RTjpeg_Ywidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
    sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
 
-   RTjpeg_dctY(bp1+j+8, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_dctY((unsigned char *)bp1+j+8, RTjpeg_block, RTjpeg_Ywidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
    sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
 
-   RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_dctY((unsigned char *)bp2+k, RTjpeg_block, RTjpeg_Cwidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
    sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
 
-   RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_dctY((unsigned char *)bp3+k, RTjpeg_block, RTjpeg_Cwidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
    sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
 
@@ -2935 +2935 @@
    RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
    sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
 
-   RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_dctY((unsigned char *)bp2+k, RTjpeg_block, RTjpeg_Cwidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
    sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
 
-   RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_dctY((unsigned char *)bp3+k, RTjpeg_block, RTjpeg_Cwidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
    sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
 
@@ -3013 +3013 @@
    else
    { 
     sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
-    RTjpeg_idct(bp2+k, RTjpeg_block, RTjpeg_width>>1);
+    RTjpeg_idct((unsigned char *)bp2+k, RTjpeg_block, RTjpeg_width>>1);
    } 
    if(*sp==-1)sp++;
    else
    { 
     sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
-    RTjpeg_idct(bp3+k, RTjpeg_block, RTjpeg_width>>1);
+    RTjpeg_idct((unsigned char *)bp3+k, RTjpeg_block, RTjpeg_width>>1);
    } 
   }
   bp+=RTjpeg_width<<3;
@@ -3062 +3062 @@
    else
    { 
     sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
-    RTjpeg_idct(bp1+j, RTjpeg_block, RTjpeg_width);
+    RTjpeg_idct((unsigned char *)bp1+j, RTjpeg_block, RTjpeg_width);
    }
    if(*sp==-1)sp++;
    else
    { 
     sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
-    RTjpeg_idct(bp1+j+8, RTjpeg_block, RTjpeg_width);
+    RTjpeg_idct((unsigned char *)bp1+j+8, RTjpeg_block, RTjpeg_width);
    }
    if(*sp==-1)sp++;
    else
    { 
     sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
-    RTjpeg_idct(bp2+k, RTjpeg_block, RTjpeg_width>>1);
+    RTjpeg_idct((unsigned char *)bp2+k, RTjpeg_block, RTjpeg_width>>1);
    } 
    if(*sp==-1)sp++;
    else
    { 
     sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
-    RTjpeg_idct(bp3+k, RTjpeg_block, RTjpeg_width>>1);
+    RTjpeg_idct((unsigned char *)bp3+k, RTjpeg_block, RTjpeg_width>>1);
    } 
   }
   bp+=RTjpeg_width<<4;
@@ -3253 +3253 @@
         else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
    block+=64;
 
-   RTjpeg_dctY(bp1+j, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_dctY((unsigned char *)bp1+j, RTjpeg_block, RTjpeg_Ywidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
    if(RTjpeg_bcomp(block, &RTjpeg_lmask))
    {
@@ -3262 +3262 @@
         else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
    block+=64;
 
-   RTjpeg_dctY(bp1+j+8, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_dctY((unsigned char *)bp1+j+8, RTjpeg_block, RTjpeg_Ywidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
    if(RTjpeg_bcomp(block, &RTjpeg_lmask))
    {
@@ -3271 +3271 @@
         else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
    block+=64;
 
-   RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_dctY((unsigned char *)bp2+k, RTjpeg_block, RTjpeg_Cwidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
    if(RTjpeg_bcomp(block, &RTjpeg_cmask))
    {
@@ -3280 +3280 @@
         else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
    block+=64;
 
-   RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_dctY((unsigned char *)bp3+k, RTjpeg_block, RTjpeg_Cwidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
    if(RTjpeg_bcomp(block, &RTjpeg_cmask))
    {
@@ -3348 +3348 @@
         else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
    block+=64;
 
-   RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_dctY((unsigned char *)bp2+k, RTjpeg_block, RTjpeg_Cwidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
    if(RTjpeg_bcomp(block, &RTjpeg_cmask))
    {
@@ -3357 +3357 @@
         else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
    block+=64;
 
-   RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_dctY((unsigned char *)bp3+k, RTjpeg_block, RTjpeg_Cwidth);
    RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
    if(RTjpeg_bcomp(block, &RTjpeg_cmask))
    {

libmpcodecs/vd_dmo.c

@@ -81 +81 @@
         return NULL;
     }
 
-    DMO_VideoDecoder_DecodeInternal(sh->context, data, len, 1, mpi->planes[0]);
+    DMO_VideoDecoder_DecodeInternal(sh->context, data, len, 1, (char *)mpi->planes[0]);
 
     return mpi;
 }

libmpcodecs/vd_dshow.c

@@ -110 +110 @@
         return NULL;
     }
 
-    DS_VideoDecoder_DecodeInternal(sh->context, data, len, 0, mpi->planes[0]);
+    DS_VideoDecoder_DecodeInternal(sh->context, data, len, 0, (char *)mpi->planes[0]);
 
     return mpi;
 }

libmpcodecs/vd_lzo.c

@@ -119 +119 @@
             );
 
         /* decompress the frame */
-        r = lzo1x_decompress (data, len, tmp, &w, priv->wrkmem);
+        r = lzo1x_decompress (data, len, tmp, (unsigned int *)&w, priv->wrkmem);
 
         if (r != LZO_E_OK) {
             /* this should NEVER happen */
@@ -154 +154 @@
             return NULL;
     }
 
-    r = lzo1x_decompress (data, len, mpi->planes[0], &w, priv->wrkmem);
+    r = lzo1x_decompress (data, len, mpi->planes[0], (unsigned int *)&w, priv->wrkmem);
     if (r != LZO_E_OK) {
         /* this should NEVER happen */
         mp_msg (MSGT_DECVIDEO, MSGL_ERR, 

libmpcodecs/vd_mpng.c

@@ -146 +146 @@
 
  if (out_fmt==IMGFMT_BGR8) {
      png_get_PLTE( png,info,&pal,&cols );
-     mpi->planes[1] = (char*)realloc(mpi->planes[1], 4*cols);
+     mpi->planes[1] = (unsigned char*)realloc(mpi->planes[1], 4*cols);
      p = mpi->planes[1];
      for (i = 0; i < cols; i++) {
          *p++ = pal[i].blue;

libmpcodecs/vd_realvid.c

@@ -334 +334 @@
         
 #ifdef USE_WIN32DLL
         if (dll_type == 1)
-            result=(*wrvyuv_transform)(dp_data, buffer, &transform_in,
+            result=(*wrvyuv_transform)((char *)dp_data, (char *)buffer, &transform_in,
                 transform_out, sh->context);
         else
 #endif
-        result=(*rvyuv_transform)(dp_data, buffer, &transform_in,
+        result=(*rvyuv_transform)((char *)dp_data, (char *)buffer, &transform_in,
                 transform_out, sh->context);
 
         if(!inited){  // rv30 width/height now known

libmpcodecs/ve_nuv.c

@@ -129 +129 @@
     // Try lzo ???
     if(vf->priv->lzo) {
       r = lzo1x_1_compress(mpi->planes[0],mpi->width*mpi->height*3/2,
-                           zdata,&zlen,vf->priv->zmem);
+                           zdata,(unsigned int *)&zlen,vf->priv->zmem);
       if(r != LZO_E_OK) {
         mp_msg(MSGT_VFILTER,MSGL_ERR,"LZO compress error\n");
         zlen = 0;
@@ -146 +146 @@
     }
 
   } else { // RTjpeg compression
-    len = RTjpeg_mcompressYUV420(data,mpi->planes[0],vf->priv->l,
+    len = RTjpeg_mcompressYUV420((signed char *)data,mpi->planes[0],vf->priv->l,
                                  vf->priv->c);
     if(len <= 0) {
       mp_msg(MSGT_VFILTER,MSGL_ERR,"RTjpeg_mcompressYUV420 error (%d)\n",len);
@@ -154 +154 @@
     }
 
     if(vf->priv->lzo) {
-      r = lzo1x_1_compress(data,len,zdata,&zlen,vf->priv->zmem);
+      r = lzo1x_1_compress(data,len,zdata,(unsigned int *)&zlen,vf->priv->zmem);
       if(r != LZO_E_OK) {
         mp_msg(MSGT_VFILTER,MSGL_ERR,"LZO compress error\n");
         zlen = 0;

libmpcodecs/vf_fspp.c

@@ -546 +546 @@
 
         if(qp_tab || vf->priv->qp){
             filter(vf->priv, dmpi->planes[0], mpi->planes[0], dmpi->stride[0], mpi->stride[0],
-                   mpi->w, mpi->h, qp_tab, mpi->qstride, 1);
+                   mpi->w, mpi->h, (unsigned char *)qp_tab, mpi->qstride, 1);
             filter(vf->priv, dmpi->planes[1], mpi->planes[1], dmpi->stride[1], mpi->stride[1],
-                   mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, qp_tab, mpi->qstride, 0);
+                   mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, (unsigned char *)qp_tab, mpi->qstride, 0);
             filter(vf->priv, dmpi->planes[2], mpi->planes[2], dmpi->stride[2], mpi->stride[2],
-                   mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, qp_tab, mpi->qstride, 0);
+                   mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, (unsigned char *)qp_tab, mpi->qstride, 0);
         }else{
             memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h, dmpi->stride[0], mpi->stride[0]);
             memcpy_pic(dmpi->planes[1], mpi->planes[1], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, dmpi->stride[1], mpi->stride[1]);

libmpcodecs/vf_pp7.c

@@ -385 +385 @@
 
     vf->priv->mpeg2= mpi->qscale_type;
     if(mpi->qscale || vf->priv->qp){
-        filter(vf->priv, dmpi->planes[0], mpi->planes[0], dmpi->stride[0], mpi->stride[0], mpi->w, mpi->h, mpi->qscale, mpi->qstride, 1);
-        filter(vf->priv, dmpi->planes[1], mpi->planes[1], dmpi->stride[1], mpi->stride[1], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, mpi->qscale, mpi->qstride, 0);
-        filter(vf->priv, dmpi->planes[2], mpi->planes[2], dmpi->stride[2], mpi->stride[2], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, mpi->qscale, mpi->qstride, 0);
+        filter(vf->priv, dmpi->planes[0], mpi->planes[0], dmpi->stride[0], mpi->stride[0], mpi->w, mpi->h, (unsigned char *)mpi->qscale, mpi->qstride, 1);
+        filter(vf->priv, dmpi->planes[1], mpi->planes[1], dmpi->stride[1], mpi->stride[1], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, (unsigned char *)mpi->qscale, mpi->qstride, 0);
+        filter(vf->priv, dmpi->planes[2], mpi->planes[2], dmpi->stride[2], mpi->stride[2], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, (unsigned char *)mpi->qscale, mpi->qstride, 0);
     }else{
         memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h, dmpi->stride[0], mpi->stride[0]);
         memcpy_pic(dmpi->planes[1], mpi->planes[1], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, dmpi->stride[1], mpi->stride[1]);

libmpcodecs/vf_pp.c

@@ -129 +129 @@
         pp_postprocess(mpi->planes           ,mpi->stride,
                     vf->dmpi->planes,vf->dmpi->stride,
                     (mpi->w+7)&(~7),mpi->h,
-                    mpi->qscale, mpi->qstride,
+                    (signed char *)mpi->qscale, mpi->qstride,
                     vf->priv->ppMode[ vf->priv->pp ], vf->priv->context,
 #ifdef PP_PICT_TYPE_QP2
                     mpi->pict_type | (mpi->qscale_type ? PP_PICT_TYPE_QP2 : 0));

libmpcodecs/vf_remove_logo.c

@@ -357 +357 @@
                            and to get us max_mask_size later on. */
   int max_mask_size; /* This will record how large a mask the pixel that is the furthest from the edge of the logo
                            (and thus the neediest) is. */
-  char * current_pixel = mask->pixel; /* This stores the actual pixel data. */
+  unsigned char * current_pixel = mask->pixel; /* This stores the actual pixel data. */
 
   /* First pass, set all non-zero values to 1. After this loop finishes, the data should be considered numeric
      data for the filter, not color data. */
@@ -788 +788 @@
 
     switch(dmpi->imgfmt){
     case IMGFMT_YV12:
-          convert_yv12(vf, mpi->planes[0],  mpi->stride[0], mpi, mpi->w, mpi->h,
-                          dmpi->planes[0], dmpi->stride[0],
+          convert_yv12(vf, (char *)mpi->planes[0],  mpi->stride[0], mpi, mpi->w, mpi->h,
+                          (char *)dmpi->planes[0], dmpi->stride[0],
                           mpi->flags & MP_IMGFLAG_DIRECT, ((vf_priv_s *)vf->priv)->filter, 0,
                           ((vf_priv_s *)vf->priv)->bounding_rectangle_posx1, ((vf_priv_s *)vf->priv)->bounding_rectangle_posy1,
                           ((vf_priv_s *)vf->priv)->bounding_rectangle_posx2, ((vf_priv_s *)vf->priv)->bounding_rectangle_posy2);
-          convert_yv12(vf, mpi->planes[1],  mpi->stride[1], mpi, mpi->w / 2, mpi->h / 2,
-                          dmpi->planes[1], dmpi->stride[1],
+          convert_yv12(vf, (char *)mpi->planes[1],  mpi->stride[1], mpi, mpi->w / 2, mpi->h / 2,
+                          (char *)dmpi->planes[1], dmpi->stride[1],
                           mpi->flags & MP_IMGFLAG_DIRECT, ((vf_priv_s *)vf->priv)->half_size_filter, 1,
                           ((vf_priv_s *)vf->priv)->bounding_rectangle_half_size_posx1, ((vf_priv_s *)vf->priv)->bounding_rectangle_half_size_posy1,
                           ((vf_priv_s *)vf->priv)->bounding_rectangle_half_size_posx2, ((vf_priv_s *)vf->priv)->bounding_rectangle_half_size_posy2);
-          convert_yv12(vf, mpi->planes[2],  mpi->stride[2], mpi, mpi->w / 2, mpi->h / 2,
-                          dmpi->planes[2], dmpi->stride[2],
+          convert_yv12(vf, (char *)mpi->planes[2],  mpi->stride[2], mpi, mpi->w / 2, mpi->h / 2,
+                          (char *)dmpi->planes[2], dmpi->stride[2],
                           mpi->flags & MP_IMGFLAG_DIRECT, ((vf_priv_s *)vf->priv)->half_size_filter, 2,
                           ((vf_priv_s *)vf->priv)->bounding_rectangle_half_size_posx1, ((vf_priv_s *)vf->priv)->bounding_rectangle_half_size_posy1,
                           ((vf_priv_s *)vf->priv)->bounding_rectangle_half_size_posx2, ((vf_priv_s *)vf->priv)->bounding_rectangle_half_size_posy2);

libmpcodecs/vf_spp.c

@@ -491 +491 @@
                 qp_tab= mpi->qscale;
 
             if(qp_tab || vf->priv->qp){
-                filter(vf->priv, dmpi->planes[0], mpi->planes[0], dmpi->stride[0], mpi->stride[0], mpi->w, mpi->h, qp_tab, mpi->qstride, 1);
-                filter(vf->priv, dmpi->planes[1], mpi->planes[1], dmpi->stride[1], mpi->stride[1], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, qp_tab, mpi->qstride, 0);
-                filter(vf->priv, dmpi->planes[2], mpi->planes[2], dmpi->stride[2], mpi->stride[2], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, qp_tab, mpi->qstride, 0);
+                filter(vf->priv, dmpi->planes[0], mpi->planes[0], dmpi->stride[0], mpi->stride[0], mpi->w, mpi->h, (unsigned char *)qp_tab, mpi->qstride, 1);
+                filter(vf->priv, dmpi->planes[1], mpi->planes[1], dmpi->stride[1], mpi->stride[1], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, (unsigned char *)qp_tab, mpi->qstride, 0);
+                filter(vf->priv, dmpi->planes[2], mpi->planes[2], dmpi->stride[2], mpi->stride[2], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, (unsigned char *)qp_tab, mpi->qstride, 0);
             }else{
                 memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h, dmpi->stride[0], mpi->stride[0]);
                 memcpy_pic(dmpi->planes[1], mpi->planes[1], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, dmpi->stride[1], mpi->stride[1]);

libmpcodecs/vf_uspp.c

@@ -292 +292 @@
     vf->priv->mpeg2= mpi->qscale_type;
     if(vf->priv->log2_count || !(mpi->flags&MP_IMGFLAG_DIRECT)){
         if(mpi->qscale || vf->priv->qp){
-            filter(vf->priv, dmpi->planes, mpi->planes, dmpi->stride, mpi->stride, mpi->w, mpi->h, mpi->qscale, mpi->qstride);
+            filter(vf->priv, dmpi->planes, mpi->planes, dmpi->stride, mpi->stride, mpi->w, mpi->h, (unsigned char *)mpi->qscale, mpi->qstride);
         }else{
             memcpy_pic(dmpi->planes[0], mpi->planes[0], mpi->w, mpi->h, dmpi->stride[0], mpi->stride[0]);
             memcpy_pic(dmpi->planes[1], mpi->planes[1], mpi->w>>mpi->chroma_x_shift, mpi->h>>mpi->chroma_y_shift, dmpi->stride[1], mpi->stride[1]);

libmpdemux/ai_alsa1x.c

@@ -44 +44 @@
 
     err = snd_pcm_hw_params_set_channels(ai->alsa.handle, params, ai->req_channels);
     if (err < 0) {
-        snd_pcm_hw_params_get_channels(params, &ai->channels);
+        snd_pcm_hw_params_get_channels(params, (unsigned int *)(&ai->channels));
         mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA_UnavailableChanCount,
                ai->channels);
     } else {
@@ -62 +62 @@
     dir = 0;
     ai->alsa.buffer_time = 1000000;
     err = snd_pcm_hw_params_set_buffer_time_near(ai->alsa.handle, params,
-                                                 &ai->alsa.buffer_time, &dir);
+                                                 (unsigned int *)(&ai->alsa.buffer_time), &dir);
     if (err < 0) {
         mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA1X_CannotSetBufferTime);
     }
@@ -70 +70 @@
     dir = 0;
     ai->alsa.period_time = ai->alsa.buffer_time / 4;
     err = snd_pcm_hw_params_set_period_time_near(ai->alsa.handle, params,
-                                                 &ai->alsa.period_time, &dir);
+                                                 (unsigned int *)(&ai->alsa.period_time), &dir);
     if (err < 0) {
         mp_msg(MSGT_TV, MSGL_ERR, MSGTR_MPDEMUX_AIALSA1X_CannotSetPeriodTime);
     }

libmpdemux/asfheader.c

@@ -124 +124 @@
 
 int asf_check_header(demuxer_t *demuxer){
   unsigned char asfhdrguid[16]={0x30,0x26,0xB2,0x75,0x8E,0x66,0xCF,0x11,0xA6,0xD9,0x00,0xAA,0x00,0x62,0xCE,0x6C};
-  stream_read(demuxer->stream,(char*) &asfh,sizeof(asfh)); // header obj
+  stream_read(demuxer->stream,(unsigned char*) &asfh,sizeof(asfh)); // header obj
   le2me_ASF_header_t(&asfh);                    // swap to machine endian
 //  for(i=0;i<16;i++) printf(" %02X",temp[i]);printf("\n");
 //  for(i=0;i<16;i++) printf(" %02X",asfhdrguid[i]);printf("\n");
@@ -176 +176 @@
             hdr_len);
     return 0;
   }
-  stream_read(demuxer->stream, hdr, hdr_len);
+  stream_read(demuxer->stream, (unsigned char*)(hdr), hdr_len);
   if (stream_eof(demuxer->stream)) {
     mp_msg(MSGT_HEADER, MSGL_FATAL, MSGTR_MPDEMUX_ASFHDR_EOFWhileReadingHeader);
     goto err_out;
@@ -364 +364 @@
   free(hdr);
   hdr = NULL;
   start = stream_tell(demuxer->stream); // start of first data chunk
-  stream_read(demuxer->stream, guid_buffer, 16);
+  stream_read(demuxer->stream, (unsigned char*)(guid_buffer), 16);
   if (memcmp(guid_buffer, asf_data_chunk_guid, 16) != 0) {
     mp_msg(MSGT_HEADER, MSGL_FATAL, MSGTR_MPDEMUX_ASFHDR_NoDataChunkAfterHeader);
     return 0;
   }
   // read length of chunk
-  stream_read(demuxer->stream, (char *)&data_len, sizeof(data_len));
+  stream_read(demuxer->stream, (unsigned char *)&data_len, sizeof(data_len));
   data_len = le2me_64(data_len);
   demuxer->movi_start = stream_tell(demuxer->stream) + 26;
   demuxer->movi_end = start + data_len;

libmpdemux/asf_mmst_streaming.c

@@ -167 +167 @@
       return;
     }
 
-    command = get_32 (data, 36) & 0xFFFF;
+    command = get_32 ((unsigned char*)data, 36) & 0xFFFF;
 
     if (command == 0x1b) 
       send_command (s, 0x1b, 0, 0, 0, data);
@@ -209 +209 @@
   header_len = 0;
 
   while (1) {
-    if (!get_data (s, pre_header, 8)) {
+    if (!get_data (s, (char*)pre_header, 8)) {
       mp_msg(MSGT_NETWORK,MSGL_ERR,MSGTR_MPDEMUX_MMST_PreHeaderReadFailed);
       return 0;
     }
@@ -226 +226 @@
         return 0;
       }
 
-      if (!get_data (s, &header[header_len], packet_len)) {
+      if (!get_data (s, (char*)(&header[header_len]), packet_len)) {
         mp_msg(MSGT_NETWORK,MSGL_ERR,MSGTR_MPDEMUX_MMST_HeaderDataReadFailed);
         return 0;
       }
@@ -236 +236 @@
       if ( (header[header_len-1] == 1) && (header[header_len-2]==1)) {
         
 
-     if( streaming_bufferize( streaming_ctrl, header, header_len )<0 ) {
+     if( streaming_bufferize( streaming_ctrl, (char*)header, header_len )<0 ) {
                                 return -1;
          }
 
@@ -272 +272 @@
         return 0;
       }
       
-      command = get_32 (data, 24) & 0xFFFF;
+      command = get_32 ((unsigned char*)data, 24) & 0xFFFF;
       
 //      mp_msg(MSGT_NETWORK,MSGL_INFO,"command: %02x\n", command);
       
@@ -377 +377 @@
   unsigned char  pre_header[8];
   char           data[BUF_SIZE];
 
-  if (!get_data (s, pre_header, 8)) {
+  if (!get_data (s, (char*)pre_header, 8)) {
     mp_msg(MSGT_NETWORK,MSGL_ERR,MSGTR_MPDEMUX_MMST_PreHeaderReadFailed);
     return 0;
   }
@@ -435 +435 @@
       return -1;
     }
 
-    command = get_32 (data, 24) & 0xFFFF;
+    command = get_32 ((unsigned char*)data, 24) & 0xFFFF;
 
 //    mp_msg(MSGT_NETWORK,MSGL_INFO,"\ncommand packet detected, len=%d  cmd=0x%X\n", packet_len, command);
 

libmpdemux/aviheader.c

@@ -182 +182 @@
     case mmioFOURCC('I','D','I','T'): hdr="Digitization Time";break;
 
     case ckidAVIMAINHDR:          // read 'avih'
-      stream_read(demuxer->stream,(char*) &avih,MIN(size2,sizeof(avih)));
+      stream_read(demuxer->stream,(unsigned char*) &avih,MIN(size2,sizeof(avih)));
       le2me_MainAVIHeader(&avih); // swap to machine endian
       chunksize-=MIN(size2,sizeof(avih));
       if(verbose>0) print_avih(&avih); // else print_avih_flags(&avih);
       break;
     case ckidSTREAMHEADER: {      // read 'strh'
       AVIStreamHeader h;
-      stream_read(demuxer->stream,(char*) &h,MIN(size2,sizeof(h)));
+      stream_read(demuxer->stream,(unsigned char*) &h,MIN(size2,sizeof(h)));
       le2me_AVIStreamHeader(&h);  // swap to machine endian
       chunksize-=MIN(size2,sizeof(h));
       ++stream_id;
@@ -220 +220 @@
       s->bIndexType = stream_read_char(demuxer->stream);
       s->nEntriesInUse = stream_read_dword_le(demuxer->stream);
       *(uint32_t *)s->dwChunkId = stream_read_dword_le(demuxer->stream);
-      stream_read(demuxer->stream, (char *)s->dwReserved, 3*4);
+      stream_read(demuxer->stream, (unsigned char *)s->dwReserved, 3*4);
       memset(s->dwReserved, 0, 3*4);
           
       print_avisuperindex_chunk(s);
@@ -249 +249 @@
         sh_video->bih=calloc((chunksize<sizeof(BITMAPINFOHEADER))?sizeof(BITMAPINFOHEADER):chunksize,1);
 //        sh_video->bih=malloc(chunksize); memset(sh_video->bih,0,chunksize);
         mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundBitmapInfoHeader,chunksize,sizeof(BITMAPINFOHEADER));
-        stream_read(demuxer->stream,(char*) sh_video->bih,chunksize);
+        stream_read(demuxer->stream,(unsigned char*) sh_video->bih,chunksize);
         le2me_BITMAPINFOHEADER(sh_video->bih);  // swap to machine endian
         // fixup MS-RLE header (seems to be broken for <256 color files)
         if(sh_video->bih->biCompression<=1 && sh_video->bih->biSize==40)
@@ -302 +302 @@
         sh_audio->wf=calloc(wf_size,1);
 //        sh_audio->wf=malloc(chunksize); memset(sh_audio->wf,0,chunksize);
         mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundWaveFmt,chunksize,sizeof(WAVEFORMATEX));
-        stream_read(demuxer->stream,(char*) sh_audio->wf,chunksize);
+        stream_read(demuxer->stream,(unsigned char*) sh_audio->wf,chunksize);
         le2me_WAVEFORMATEX(sh_audio->wf);
         if (sh_audio->wf->cbSize != 0 &&
             wf_size < sizeof(WAVEFORMATEX)+sh_audio->wf->cbSize) {
@@ -356 +356 @@
         priv->idx_size,avih.dwTotalFrames, (int64_t)stream_tell(demuxer->stream));
       priv->idx=malloc(priv->idx_size<<4);
 //      printf("\nindex to %p !!!!! (priv=%p)\n",priv->idx,priv);
-      stream_read(demuxer->stream,(char*)priv->idx,priv->idx_size<<4);
+      stream_read(demuxer->stream,(unsigned char*)priv->idx,priv->idx_size<<4);
       for (i = 0; i < priv->idx_size; i++) {    // swap index to machine endian
         AVIINDEXENTRY *entry=(AVIINDEXENTRY*)priv->idx + i;
         le2me_AVIINDEXENTRY(entry);
@@ -376 +376 @@
         char riff_type[4];
 
         mp_msg(MSGT_HEADER, MSGL_V, MSGTR_MPDEMUX_AVIHDR_AdditionalRIFFHdr);
-        stream_read(demuxer->stream, riff_type, sizeof riff_type);
+        stream_read(demuxer->stream, (unsigned char*)(riff_type), sizeof riff_type);
         if (strncmp(riff_type, "AVIX", sizeof riff_type))
             mp_msg(MSGT_HEADER, MSGL_WARN, MSGTR_MPDEMUX_AVIHDR_WarnNotExtendedAVIHdr);
         else {
@@ -401 +401 @@
     if(size2==3)
       chunksize=1; // empty
     else {
-      char buf[256];
+      unsigned char buf[256];
       int len=(size2<250)?size2:250;
       stream_read(demuxer->stream,buf,len);
       chunksize-=len;
       buf[len]=0;
       mp_msg(MSGT_HEADER,MSGL_V,"%-10s: %s\n",hdr,buf);
-      demux_info_add(demuxer, hdr, buf);
+      demux_info_add(demuxer, hdr, (char *)buf);
     }
   }
   mp_msg(MSGT_HEADER,MSGL_DBG2,"list_end=0x%"PRIX64"  pos=0x%"PRIX64"  chunksize=0x%"PRIX64"  next=0x%"PRIX64"\n",
@@ -454 +454 @@
             int ret1, ret2;
             memset(&cx->stdidx[j], 0, 32);
             ret1 = stream_seek(demuxer->stream, (off_t)cx->aIndex[j].qwOffset);
-            ret2 = stream_read(demuxer->stream, (char *)&cx->stdidx[j], 32);
+            ret2 = stream_read(demuxer->stream, (unsigned char *)&cx->stdidx[j], 32);
             if (ret1 != 1 || ret2 != 32 || cx->stdidx[j].nEntriesInUse==0) {
                 // this is a broken file (probably incomplete) let the standard
                 // gen_index routine handle this
@@ -468 +468 @@
             print_avistdindex_chunk(&cx->stdidx[j]);
             priv->idx_size += cx->stdidx[j].nEntriesInUse;
             cx->stdidx[j].aIndex = malloc(cx->stdidx[j].nEntriesInUse*sizeof(avistdindex_entry));
-            stream_read(demuxer->stream, (char *)cx->stdidx[j].aIndex, 
+            stream_read(demuxer->stream, (unsigned char *)cx->stdidx[j].aIndex, 
                     cx->stdidx[j].nEntriesInUse*sizeof(avistdindex_entry));
             for (k=0;k<cx->stdidx[j].nEntriesInUse; k++)
                 le2me_AVISTDIDXENTRY(&cx->stdidx[j].aIndex[k]);

libmpdemux/demux_audio.c

@@ -222 +222 @@
     free(mp3_found);
     mp3_found = NULL;
     if(s->end_pos) {
-      char tag[4];
+      unsigned char tag[4];
       stream_seek(s,s->end_pos-128);
       stream_read(s,tag,3);
       tag[3] = '\0';
-      if(strcmp(tag,"TAG"))
+      if(strcmp((char *)tag,"TAG"))
         demuxer->movi_end = s->end_pos;
       else {
-        char buf[31];
+        unsigned char buf[31];
         uint8_t g;
         demuxer->movi_end = stream_tell(s)-3;
         stream_read(s,buf,30);
         buf[30] = '\0';
-        demux_info_add(demuxer,"Title",buf);
+        demux_info_add(demuxer,"Title",(char *)buf);
         stream_read(s,buf,30);
         buf[30] = '\0';
-        demux_info_add(demuxer,"Artist",buf);
+        demux_info_add(demuxer,"Artist",(char *)buf);
         stream_read(s,buf,30);
         buf[30] = '\0';
-        demux_info_add(demuxer,"Album",buf);
+        demux_info_add(demuxer,"Album",(char *)buf);
         stream_read(s,buf,4);
         buf[4] = '\0';
-        demux_info_add(demuxer,"Year",buf);
+        demux_info_add(demuxer,"Year",(char *)buf);
         stream_read(s,buf,30);
         buf[30] = '\0';
-        demux_info_add(demuxer,"Comment",buf);
+        demux_info_add(demuxer,"Comment",(char *)buf);
         if(buf[28] == 0 && buf[29] != 0) {
           uint8_t trk = (uint8_t)buf[29];
-          sprintf(buf,"%d",trk);
-          demux_info_add(demuxer,"Track",buf);
+          sprintf((char *)buf,"%d",trk);
+          demux_info_add(demuxer,"Track",(char *)buf);
         }
         g = stream_read_char(s);
         demux_info_add(demuxer,"Genre",genres[g]);
@@ -285 +285 @@
       if (l < w->cbSize) {
         mp_msg(MSGT_DEMUX,MSGL_ERR,"[demux_audio] truncated extradata (%d < %d)\n",
         l,w->cbSize);
-        stream_read(s,(char*)((char*)(w)+sizeof(WAVEFORMATEX)),l);
+        stream_read(s,(unsigned char*)((char*)(w)+sizeof(WAVEFORMATEX)),l);
         l = 0;
       } else {
-        stream_read(s,(char*)((char*)(w)+sizeof(WAVEFORMATEX)),w->cbSize);
+        stream_read(s,(unsigned char*)((char*)(w)+sizeof(WAVEFORMATEX)),w->cbSize);
         l -= w->cbSize;
       }
      }

libmpdemux/demux_gif.c

@@ -78 +78 @@
         printf("GIF comment: ");
         while (p != NULL) {
           int length = p[0];
-          char *comments = p + 1;
+          unsigned char *comments = p + 1;
           comments[length] = 0;
           printf("%s", comments);
           if (DGifGetExtensionNext(gif, &p) == GIF_ERROR) {
@@ -108 +108 @@
   memset(buf, 0, len);
   memset(dp->buffer, 0, len);
   
-  if (DGifGetLine(gif, buf, len) == GIF_ERROR) {
+  if (DGifGetLine(gif, (unsigned char *)buf, len) == GIF_ERROR) {
     PrintGifError();
     return 0; // oops
   }
@@ -129 +129 @@
 
     for (y = 0; y < gif->Image.Height; y++) {
       unsigned char *drow = dp->buffer;
-      unsigned char *gbuf = buf + (y * gif->Image.Width);
+      unsigned char *gbuf = (unsigned char *)buf + (y * gif->Image.Width);
 
       drow += gif->Image.Width * (y + gif->Image.Top);
       drow += gif->Image.Left;

libmpdemux/demux_mkv.c

@@ -594 +594 @@
           *dest = (uint8_t *) malloc (dstlen);
           while (1)
             {
-              result = lzo1x_decompress_safe (src, *size, *dest, &dstlen,
+              result = lzo1x_decompress_safe (src, *size, *dest, (unsigned int *)&dstlen,
                                               NULL);
               if (result == LZO_E_OK)
                 break;
@@ -2038 +2038 @@
         continue;
 
       size = track->private_size;
-      m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
+      m = demux_mkv_decode (track,track->private_data,&buffer,(uint32_t *)&size,2);
       if (buffer && m)
         {
           free (track->private_data);
@@ -2925 +2925 @@
         {
           sh_audio_t *sh = (sh_audio_t *) ds->sh;
 
-          if (block_duration != 0)
+         if (block_duration != 0)
             {
               sh->i_bps = length * 1000 / block_duration;
               track->fix_i_bps = 0;
@@ -2953 +2953 @@
       if (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB)
         {
           if (!mkv_d->v_skip_to_keyframe)
-            handle_subtitles (demuxer, track, block, length,
+            handle_subtitles (demuxer, track, (char *)block, length,
                               block_duration, tc);
           use_this_block = 0;
         }
@@ -2980 +2980 @@
               int modified, size = lace_size[i];
               demux_packet_t *dp;
               uint8_t *buffer;
-              modified = demux_mkv_decode (track, block, &buffer, &size, 1);
+              modified = demux_mkv_decode (track, block, &buffer, (uint32_t *)&size, 1);
               if (buffer)
                 {
                   dp = new_demux_packet (size);

libmpdemux/demux_mov.c

@@ -1251 +1251 @@
               zstrm.zalloc          = (alloc_func)0;
               zstrm.zfree           = (free_func)0;
               zstrm.opaque          = (voidpf)0;
-              zstrm.next_in         = cmov_buf;
+              zstrm.next_in         = (unsigned char *)cmov_buf;
               zstrm.avail_in        = cmov_sz;
               zstrm.next_out        = moov_buf;
               zstrm.avail_out       = moov_sz;
@@ -1325 +1325 @@
                     {
                         off_t text_len = stream_read_word(demuxer->stream);
                         char text[text_len+2+1];
-                        stream_read(demuxer->stream, (char *)&text, text_len+2);
+                        stream_read(demuxer->stream, (unsigned char *)&text, text_len+2);
                         text[text_len+2] = 0x0;
                         switch(udta_id)
                         {
@@ -1396 +1396 @@
                                 udta_len=udta_size;
                         {
                         char dump[udta_len-4];
-                        stream_read(demuxer->stream, (char *)&dump, udta_len-4-4);
+                        stream_read(demuxer->stream, (unsigned char *)&dump, udta_len-4-4);
                         udta_size -= udta_len;
                         }
                     }
@@ -1433 +1433 @@
       // read codec data
       trak->tkdata_len = len;
       trak->tkdata = malloc(trak->tkdata_len);
-      stream_read(demuxer->stream, trak->tkdata, trak->tkdata_len);
+      stream_read(demuxer->stream, (unsigned char*) trak->tkdata, trak->tkdata_len);
 /*
 0  1 Version
 1  3 Flags
@@ -1478 +1478 @@
       unsigned int comp_mask = stream_read_dword(demuxer->stream);
       int len = stream_read_char(demuxer->stream);
       char* str = malloc(len + 1);
-      stream_read(demuxer->stream, str, len);
+      stream_read(demuxer->stream, (unsigned char*)str, len);
       str[len] = 0;
       mp_msg(MSGT_DEMUX, MSGL_V,
              "MOV: %*sHandler header: %.4s/%.4s (%.4s) %s\n", level, "",
@@ -1819 +1819 @@
                         char buf2[newlen];
 
                         len-=4;
-                        stream_read(demuxer->stream, buf, len);
+                        stream_read(demuxer->stream, (unsigned char*)buf, len);
 
                         zstrm.zalloc          = (alloc_func)0;
                         zstrm.zfree           = (free_func)0;
                         zstrm.opaque          = (voidpf)0;
-                        zstrm.next_in         = buf;
+                        zstrm.next_in         = (unsigned char*)buf;
                         zstrm.avail_in        = len;
-                        zstrm.next_out        = buf2;
+                        zstrm.next_out        = (unsigned char*)buf2;
                         zstrm.avail_out       = newlen;
 
                         zret = inflateInit(&zstrm);
@@ -1842 +1842 @@
                     }
                     {
 #endif
-                        stream_read(demuxer->stream, buf, len);
+                        stream_read(demuxer->stream, (unsigned char*)buf, len);
                         write(fd, buf, len);
                     }
                     close(fd);

libmpdemux/demux_nsv.c

@@ -177 +177 @@
 
         //   bytes 8-11   audio codec fourcc
         // PCM fourcc needs extra parsing for every audio chunk, yet to implement
-        if((demuxer->audio->id != -2) && strncmp(hdr+8,"NONE", 4)){//&&strncmp(hdr+8,"VLB ", 4)){
+        if((demuxer->audio->id != -2) && strncmp((char *)hdr+8,"NONE", 4)){//&&strncmp(hdr+8,"VLB ", 4)){
             sh_audio = new_sh_audio ( demuxer, 0 );
             demuxer->audio->sh = sh_audio;
             sh_audio->format=mmioFOURCC(hdr[8],hdr[9],hdr[10],hdr[11]);
@@ -188 +188 @@
         // store hdr fps 
         priv->fps=hdr[16];
             
-        if ((demuxer->video->id != -2) && strncmp(hdr+4,"NONE", 4)) {
+        if ((demuxer->video->id != -2) && strncmp((char *)hdr+4,"NONE", 4)) {
             /* Create a new video stream header */
             sh_video = new_sh_video ( demuxer, 0 );
 

libmpdemux/demux_nuv.c

@@ -83 +83 @@
 
                 while(current_time < target_time )
                 {       
-                        if (stream_read ( demuxer->stream, (char*)& rtjpeg_frameheader, sizeof ( rtjpeg_frameheader ) ) < sizeof(rtjpeg_frameheader))
+                        if (stream_read ( demuxer->stream, (unsigned char*)& rtjpeg_frameheader, sizeof ( rtjpeg_frameheader ) ) < sizeof(rtjpeg_frameheader))
                                 return; /* EOF */
                         le2me_rtframeheader(&rtjpeg_frameheader);
 
@@ -160 +160 @@
         int want_audio = (demuxer->audio)&&(demuxer->audio->id!=-2);
 
         demuxer->filepos = orig_pos = stream_tell ( demuxer->stream );
-        if (stream_read ( demuxer->stream, (char*)& rtjpeg_frameheader, sizeof ( rtjpeg_frameheader ) ) < sizeof(rtjpeg_frameheader))
+        if (stream_read ( demuxer->stream, (unsigned char*)& rtjpeg_frameheader, sizeof ( rtjpeg_frameheader ) ) < sizeof(rtjpeg_frameheader))
             return 0; /* EOF */
         le2me_rtframeheader(&rtjpeg_frameheader);
 
@@ -234 +234 @@
   sh_audio_t* sh_audio = demuxer->audio->sh;
 
   for (i = 0; i < 2; ++i) {
-    if (stream_read(demuxer->stream, (char*)&rtjpeg_frameheader,
+    if (stream_read(demuxer->stream, (unsigned char*)&rtjpeg_frameheader,
               sizeof(rtjpeg_frameheader)) < sizeof(rtjpeg_frameheader))
       goto out;
     le2me_rtframeheader(&rtjpeg_frameheader);
@@ -252 +252 @@
     goto out;
   }
 
-  if (stream_read(demuxer->stream, (char*)&ext, sizeof(ext)) < sizeof(ext))
+  if (stream_read(demuxer->stream, (unsigned char*)&ext, sizeof(ext)) < sizeof(ext))
     goto out;
   le2me_extendeddata(&ext);
 
@@ -325 +325 @@
         stream_reset(demuxer->stream);
         stream_seek(demuxer->stream, 0);
 
-        stream_read ( demuxer->stream, (char*)& rtjpeg_fileheader, sizeof(rtjpeg_fileheader) );
+        stream_read ( demuxer->stream, (unsigned char*)& rtjpeg_fileheader, sizeof(rtjpeg_fileheader) );
         le2me_rtfileheader(&rtjpeg_fileheader);
 
         /* no video */
@@ -414 +414 @@
 
         mp_msg ( MSGT_DEMUX, MSGL_V, "Checking for NuppelVideo\n" );
 
-        if(stream_read(demuxer->stream,(char*)&ns,sizeof(ns)) != sizeof(ns))
+        if(stream_read(demuxer->stream,(unsigned char*)&ns,sizeof(ns)) != sizeof(ns))
                 return 0;
 
         if ( strncmp ( ns.finfo, "NuppelVideo", 12 ) &&

libmpdemux/demux_ogg.c

@@ -233 +233 @@
   int lcv;
   int line_pos = 0;
   int ignoring = 0;
-  char *packet = pack->packet;
+  unsigned char *packet = pack->packet;
 
   mp_msg(MSGT_DEMUX,MSGL_DBG2,"\ndemux_ogg_add_sub %02X %02X %02X '%s'\n",
       (unsigned char)packet[0],
@@ -637 +637 @@
     }
     if(np <= 0) { // We need more data
       char* buf = ogg_sync_buffer(sync,BLOCK_SIZE);
-      int len = stream_read(s,buf,BLOCK_SIZE);
+      int len = stream_read(s,(unsigned char *)buf,BLOCK_SIZE);
       if(len == 0 && s->eof)
         break;
       ogg_sync_wrote(sync,len);
@@ -692 +692 @@
     np = ogg_sync_pageout(sync,page);
     if(np <= 0) { // We need more data
       char* buf = ogg_sync_buffer(sync,BLOCK_SIZE);
-      int len = stream_read(s,buf,BLOCK_SIZE);
+      int len = stream_read(s,(unsigned char *)buf,BLOCK_SIZE);
       if(len == 0 && s->eof) {
         mp_msg(MSGT_DEMUX,MSGL_ERR,"EOF while trying to get the first page !!!!\n");
         break;
@@ -881 +881 @@
     if(np == 0) {
       int len;
       buf = ogg_sync_buffer(sync,BLOCK_SIZE);
-      len = stream_read(s,buf,BLOCK_SIZE);      
+      len = stream_read(s,(unsigned char *)buf,BLOCK_SIZE);      
       if(len == 0 && s->eof) {
         goto err_out;
       }
@@ -920 +920 @@
     demux_aid_vid_mismatch = 1; // don't identify in new_sh_* since ids don't match
 
     // Check for Vorbis
-    if(pack.bytes >= 7 && ! strncmp(&pack.packet[1],"vorbis", 6) ) {
+    if(pack.bytes >= 7 && ! strncmp((char *)&pack.packet[1],"vorbis", 6) ) {
       sh_a = new_sh_audio(demuxer,ogg_d->num_sub);
       sh_a->format = FOURCC_VORBIS;
       ogg_d->subs[ogg_d->num_sub].vorbis = 1;
@@ -929 +929 @@
       ogg_d->subs[ogg_d->num_sub].id = n_audio;
       n_audio++;
       mp_msg(MSGT_DEMUX,MSGL_INFO,"[Ogg] stream %d: audio (Vorbis), -aid %d\n",ogg_d->num_sub,n_audio-1);
-    } else if (pack.bytes >= 80 && !strncmp(pack.packet,"Speex", 5)) {
+    } else if (pack.bytes >= 80 && !strncmp((char *)pack.packet,"Speex", 5)) {
       sh_a = new_sh_audio(demuxer, ogg_d->num_sub);
       sh_a->wf = (WAVEFORMATEX*)calloc(1, sizeof(WAVEFORMATEX) + pack.bytes);
       sh_a->format = FOURCC_SPEEX;
@@ -953 +953 @@
 
       // check for Theora
 #   ifdef HAVE_OGGTHEORA
-    } else if (pack.bytes >= 7 && !strncmp (&pack.packet[1], "theora", 6)) {
+    } else if (pack.bytes >= 7 && !strncmp ((char *)&pack.packet[1], "theora", 6)) {
         int errorCode = 0;
         theora_info inf;
         theora_comment cc;
@@ -1013 +1013 @@
 #   endif /* HAVE_FLAC */
 
       /// Check for old header
-    } else if(pack.bytes >= 142 && ! strncmp(&pack.packet[1],"Direct Show Samples embedded in Ogg",35) ) {
+    } else if(pack.bytes >= 142 && ! strncmp((char *)&pack.packet[1],"Direct Show Samples embedded in Ogg",35) ) {
 
        // Old video header
       if(get_uint32 (pack.packet+96) == 0x05589f80 && pack.bytes >= 184) {
@@ -1287 +1287 @@
             }
             /// We need more data
             buf = ogg_sync_buffer(sync,BLOCK_SIZE);         
-            len = stream_read(s,buf,BLOCK_SIZE);
+            len = stream_read(s,(unsigned char *)buf,BLOCK_SIZE);
             if(len == 0 && s->eof) {
               mp_msg(MSGT_DEMUX,MSGL_DBG2,"Ogg : Stream EOF !!!!\n");
               return 0;
@@ -1531 +1531 @@
       ogg_d->pos -= np;
     if(np <= 0) { // We need more data
       char* buf = ogg_sync_buffer(sync,BLOCK_SIZE);
-      int len = stream_read(demuxer->stream,buf,BLOCK_SIZE);
+      int len = stream_read(demuxer->stream,(unsigned char *)buf,BLOCK_SIZE);
        if(len == 0 && demuxer->stream->eof) {
         mp_msg(MSGT_DEMUX,MSGL_V,"EOF while trying to seek !!!!\n");
         return;

libmpdemux/demux_realaud.c

@@ -225 +225 @@
 
         if ((i = stream_read_char(demuxer->stream)) != 0) {
                 buf = malloc(i+1);
-                stream_read(demuxer->stream, buf, i);
+                stream_read(demuxer->stream, (unsigned char*)buf, i);
                 buf[i] = 0;
                 demux_info_add(demuxer, "Title", buf);
                 free(buf);
         }
         if ((i = stream_read_char(demuxer->stream)) != 0) {
                 buf = malloc(i+1);
-                stream_read(demuxer->stream, buf, i);
+                stream_read(demuxer->stream, (unsigned char*)buf, i);
                 buf[i] = 0;
                 demux_info_add(demuxer, "Author", buf);
                 free(buf);
         }
         if ((i = stream_read_char(demuxer->stream)) != 0) {
                 buf = malloc(i+1);
-                stream_read(demuxer->stream, buf, i);
+                stream_read(demuxer->stream, (unsigned char*)buf, i);
                 buf[i] = 0;
                 demux_info_add(demuxer, "Copyright", buf);
                 free(buf);
@@ -247 +247 @@
 
         if ((i = stream_read_char(demuxer->stream)) != 0) {
                 buf = malloc(i+1);
-                stream_read(demuxer->stream, buf, i);
+                stream_read(demuxer->stream, (unsigned char*)buf, i);
                 buf[i] = 0;
                 demux_info_add(demuxer, "Comment", buf);
                 free(buf);

libmpdemux/demux_real.c

@@ -132 +132 @@
     else
         len = stream_read_word(demuxer->stream);
 
-    stream_read(demuxer->stream, buf, (len > buf_size) ? buf_size : len);
+    stream_read(demuxer->stream, (unsigned char *)buf, (len > buf_size) ? buf_size : len);
     if (len > buf_size)
         stream_skip(demuxer->stream, len-buf_size);
 
@@ -1161 +1161 @@
                 if (len > 0)
                 {
                     buf = malloc(len+1);
-                    stream_read(demuxer->stream, buf, len);
+                    stream_read(demuxer->stream, (unsigned char*)buf, len);
                     buf[len] = 0;
                     demux_info_add(demuxer, "name", buf);
                     free(buf);
@@ -1171 +1171 @@
                 if (len > 0)
                 {
                     buf = malloc(len+1);
-                    stream_read(demuxer->stream, buf, len);
+                    stream_read(demuxer->stream, (unsigned char*)buf, len);
                     buf[len] = 0;
                     demux_info_add(demuxer, "author", buf);
                     free(buf);
@@ -1181 +1181 @@
                 if (len > 0)
                 {
                     buf = malloc(len+1);
-                    stream_read(demuxer->stream, buf, len);
+                    stream_read(demuxer->stream, (unsigned char*)buf, len);
                     buf[len] = 0;
                     demux_info_add(demuxer, "copyright", buf);
                     free(buf);
@@ -1191 +1191 @@
                 if (len > 0)
                 {
                     buf = malloc(len+1);
-                    stream_read(demuxer->stream, buf, len);
+                    stream_read(demuxer->stream, (unsigned char*)buf, len);
                     buf[len] = 0;
                     demux_info_add(demuxer, "comment", buf);
                     free(buf);
@@ -1223 +1223 @@
 //              skip_str(1, demuxer);   /* stream description (name) */
                 if ((len = stream_read_char(demuxer->stream)) > 0) {
                     descr = malloc(len+1);
-                stream_read(demuxer->stream, descr, len);
+                stream_read(demuxer->stream, (unsigned char*)descr, len);
                     descr[len] = 0;
                     printf("Stream description: %s\n", descr);
                     free(descr);
@@ -1231 +1231 @@
 //              skip_str(1, demuxer);   /* mimetype */
                 if ((len = stream_read_char(demuxer->stream)) > 0) {
                     mimet = malloc(len+1);
-                stream_read(demuxer->stream, mimet, len);
+                stream_read(demuxer->stream, (unsigned char*)mimet, len);
                     mimet[len] = 0;
                     printf("Stream mimetype: %s\n", mimet);
                 }
@@ -1284 +1284 @@
                     // Name, author, (c) are also in CONT tag
                     if ((i = stream_read_char(demuxer->stream)) != 0) {
                       buft = malloc(i+1);
-                      stream_read(demuxer->stream, buft, i);
+                      stream_read(demuxer->stream, (unsigned char*)buft, i);
                       buft[i] = 0;
                       demux_info_add(demuxer, "Name", buft);
                       free(buft);
                     }
                     if ((i = stream_read_char(demuxer->stream)) != 0) {
                       buft = malloc(i+1);
-                      stream_read(demuxer->stream, buft, i);
+                      stream_read(demuxer->stream, (unsigned char*)buft, i);
                       buft[i] = 0;
                       demux_info_add(demuxer, "Author", buft);
                       free(buft);
                     }
                     if ((i = stream_read_char(demuxer->stream)) != 0) {
                       buft = malloc(i+1);
-                      stream_read(demuxer->stream, buft, i);
+                      stream_read(demuxer->stream, (unsigned char*)buft, i);
                       buft[i] = 0;
                       demux_info_add(demuxer, "Copyright", buft);
                       free(buft);
@@ -1360 +1360 @@
                     if (version == 5)
                     {
                         stream_skip(demuxer->stream, 4);  // "genr"
-                        stream_read(demuxer->stream, buf, 4); // fourcc
+                        stream_read(demuxer->stream, (unsigned char*)buf, 4); // fourcc
                         buf[4] = 0;
                     }
                     else
@@ -1411 +1411 @@
                             codecdata_length=stream_read_dword(demuxer->stream);
                             sh->wf->cbSize = codecdata_length;
                             sh->wf = realloc(sh->wf, sizeof(WAVEFORMATEX)+sh->wf->cbSize);
-                            stream_read(demuxer->stream, ((char*)(sh->wf+1)), codecdata_length); // extras
+                            stream_read(demuxer->stream, ((unsigned char*)(sh->wf+1)), codecdata_length); // extras
                 if ((sh->format == MKTAG('a', 't', 'r', 'c')) ||
                     (sh->format == MKTAG('c', 'o', 'o', 'k')))
                             sh->wf->nBlockAlign = sub_packet_size;

libmpdemux/demux_smjpeg.c

@@ -31 +31 @@
     
     if (stream_read_word(demuxer->stream) == 0xA)
     {
-        stream_read(demuxer->stream, buf, 6);
+        stream_read(demuxer->stream, (unsigned char *)buf, 6);
         buf[7] = 0;
     
         if (strncmp("SMJPEG", buf, 6)) {

libmpdemux/demux_ts.c

@@ -443 +443 @@
                                 continue;
 
                         mp_msg(MSGT_DEMUXER, MSGL_V, "CMP LANG %s AND %s, pids: %d %d\n",pmt->es[j].lang, lang, pmt->es[j].pid, pid);
-                        if(strncmp(pmt->es[j].lang, lang, 3) == 0)
+                        if(strncmp((char *)pmt->es[j].lang, lang, 3) == 0)
                         {
                                 return 1;
                         }
@@ -516 +516 @@
         {
                 if(buf[cnt] == 0x0B && buf[cnt+1] == 0x77)
                 {
-                        frame_length = mp_a52_framesize(&buf[cnt], &srate);
+                        frame_length = mp_a52_framesize((unsigned char *)(&buf[cnt]), &srate);
                         if(frame_length>=7 && frame_length<=3840)
                         {
                                 cnt += frame_length;
@@ -2151 +2151 @@
                         }
                         else
                         {
-                                char *d;
+                                unsigned char *d;
                                 memcpy(es->format_descriptor, &ptr[j+2], 4);
                                 es->format_descriptor[4] = 0;
 
@@ -2781 +2781 @@
                                                 {
                                                         lang = pid_lang_from_pmt(priv, pid);
                                                         if(lang != NULL)
-                                                                asgn = (strncmp(lang, dvdsub_lang, 3) == 0);
+                                                                asgn = (strncmp((char *)lang, dvdsub_lang, 3) == 0);
                                                         else
                                                                 asgn = 0;
                                                 }
@@ -2848 +2848 @@
                         mp_msg(MSGT_DEMUX, MSGL_DBG2, "IS_START\n");
 
                         p = &packet[base];
-                        stream_read(stream, p, buf_size);
+                        stream_read(stream, (unsigned char*)p, buf_size);
                         stream_skip(stream, junk);
 
-                        len = pes_parse2(p, buf_size, es, pid_type, pmt, pid);
+                        len = pes_parse2((unsigned char*)p, buf_size, es, pid_type, pmt, pid);
                         es->pid = tss->pid;
                         tss->is_synced |= es->is_synced || rap_flag;
                         
@@ -2872 +2872 @@
                                         if(tss->type != UNKNOWN)
                                         {
                                                 es->size = buf_size;
-                                                es->start = p;
+                                                es->start = (unsigned char*)p;
                                                 return 1;
                                         }
                                 }
@@ -2902 +2902 @@
                                         {
                                                 len = es->size = buf_size;              //push the whole packet to the fifo 
                                                                                         //(we already learned what it is during the probe phase)
-                                                es->start = p;
+                                                es->start = (unsigned char*)p;
                                         }
                                         else
                                                 continue;
@@ -3182 +3182 @@
         ES_stream_t es;
         ts_priv_t *priv = (ts_priv_t *)demuxer->priv;
         
-        return -ts_parse(demuxer, &es, priv->packet, 0);
+        return -ts_parse(demuxer, &es, (unsigned char*)priv->packet, 0);
 }
 
 

libmpdemux/demux_ty.c

@@ -193 +193 @@
          error = 1;
          break;
       }
-      count = stream_read( demux->stream, header, 512 );
+      count = stream_read( demux->stream, (unsigned char *)header, 512 );
       if ( count < 512 )
       { 
          mp_msg( MSGT_DEMUX, MSGL_DBG3, "Read bad\n" );

libmpdemux/demux_viv.c

@@ -103 +103 @@
     buf = malloc(header_len);
     opt = malloc(header_len);
     param = malloc(header_len);
-    stream_read(demux->stream, buf, header_len);
+    stream_read(demux->stream, (unsigned char*)buf, header_len);
     i=0;
     while(i<header_len && buf[i]==0x0D && buf[i+1]==0x0A) i+=2; // skip empty lines
     
@@ -267 +267 @@
     // parse header:
     i=0;
     while(i<len && buf[i]==0x0D && buf[i+1]==0x0A) i+=2; // skip empty lines
-    if(strncmp(buf+i,"Version:Vivo/",13)) return 0; // bad version/type!
+    if(strncmp((char *)buf+i,"Version:Vivo/",13)) return 0; // bad version/type!
 #endif
 
 #if 0

libmpdemux/demux_vqf.c

@@ -14 +14 @@
   char buf[KEYWORD_BYTES];
   stream_t *s;
   s = demuxer->stream;
-  if(stream_read(s,buf,KEYWORD_BYTES)!=KEYWORD_BYTES)
+  if(stream_read(s,(unsigned char *)buf,KEYWORD_BYTES)!=KEYWORD_BYTES)
     return 0;
   if(memcmp(buf,"TWIN",KEYWORD_BYTES)==0) return DEMUXER_TYPE_VQF; /*version: 97012000*/
   return 0;
@@ -42 +42 @@
   w->wBitsPerSample = 8*sh_audio->samplesize;
   w->cbSize = 0;
   strcpy(hi->ID,"TWIN");
-  stream_read(s,hi->ID+KEYWORD_BYTES,VERSION_BYTES); /* fourcc+version_id */
+  stream_read(s,(unsigned char *)hi->ID+KEYWORD_BYTES,VERSION_BYTES); /* fourcc+version_id */
   while(1)
   {
     char chunk_id[4];
     unsigned chunk_size;
     hi->size=chunk_size=stream_read_dword(s); /* include itself */
-    stream_read(s,chunk_id,4);
+    stream_read(s,(unsigned char *)chunk_id,4);
     if(*((uint32_t *)&chunk_id[0])==mmioFOURCC('C','O','M','M'))
     {
     char buf[chunk_size-8];
     unsigned i,subchunk_size;
-    if(stream_read(s,buf,chunk_size-8)!=chunk_size-8) return NULL;
+    if(stream_read(s,(unsigned char *)buf,chunk_size-8)!=chunk_size-8) return NULL;
     i=0;
     subchunk_size=be2me_32(*((uint32_t *)&buf[0]));
     hi->channelMode=be2me_32(*((uint32_t *)&buf[4]));

libmpdemux/demux_y4m.c

@@ -30 +30 @@
     
     mp_msg(MSGT_DEMUX, MSGL_V, "Checking for YUV4MPEG2\n");
     
-    if(stream_read(demuxer->stream, buf, 9)!=9)
+    if(stream_read(demuxer->stream, (unsigned char *)buf, 9)!=9)
         return 0;
 
     buf[9] = 0;
@@ -133 +133 @@
 
         stream_skip(demuxer->stream, 8); /* YUV4MPEG */
         stream_skip(demuxer->stream, 1); /* space */
-        stream_read(demuxer->stream, (char *)&buf[0], 3);
+        stream_read(demuxer->stream, (unsigned char *)&buf[0], 3);
         buf[3] = 0;
         sh->disp_w = atoi(buf);
         stream_skip(demuxer->stream, 1); /* space */
-        stream_read(demuxer->stream, (char *)&buf[0], 3);
+        stream_read(demuxer->stream, (unsigned char *)&buf[0], 3);
         buf[3] = 0;
         sh->disp_h = atoi(buf);
         stream_skip(demuxer->stream, 1); /* space */
-        stream_read(demuxer->stream, (char *)&buf[0], 1);
+        stream_read(demuxer->stream, (unsigned char *)&buf[0], 1);
         buf[1] = 0;
         frame_rate_code = atoi(buf);
         stream_skip(demuxer->stream, 1); /* new-line */

libmpdemux/ebml.c

@@ -226 +226 @@
     *length = len + l;
 
   str = (char *) malloc (len+1);
-  if (stream_read(s, str, len) != (int) len)
+  if (stream_read(s, (unsigned char *)str, len) != (int) len)
     {
       free (str);
       return NULL;

libmpdemux/http.c

@@ -76 +76 @@
   unsigned char info[6] = {0, 0, 0, 0, 0, 0};
   int info_read;
   do {
-    info_read = my_read(fd, info, 1, sc);
+    info_read = my_read(fd, (char *)info, 1, sc);
     if (info[0] == 0x00)
-      info_read = my_read(fd, info, 6, sc);
+      info_read = my_read(fd, (char *)info, 6, sc);
     else
-      info_read += my_read(fd, &info[1], 5, sc);
+      info_read += my_read(fd, (char *)(&info[1]), 5, sc);
     if (info_read != 6) // read error or eof
       return 0;
     // sync byte and reserved flags
@@ -108 +108 @@
 static void scast_meta_read(int fd, streaming_ctrl_t *sc) {
   unsigned char tmp = 0;
   unsigned metalen;
-  my_read(fd, &tmp, 1, sc);
+  my_read(fd, (char *)(&tmp), 1, sc);
   metalen = tmp * 16;
   if (metalen > 0) {
     char *info = (char *)malloc(metalen + 1);

libmpdemux/muxer_mpeg.c

@@ -524 +524 @@
         *(uint32_t *)buff = be2me_32(PACK_HEADER_START_CODE);
         if(priv->mux==MUX_MPEG1)
         {
-                write_mpeg_ts(&buff[4], priv->scr, 0x20); // 0010 and SCR
-                write_mpeg_rate(priv->mux, &buff[9], muxer->sysrate);
+                write_mpeg_ts((unsigned char *)&buff[4], priv->scr, 0x20); // 0010 and SCR
+                write_mpeg_rate(priv->mux, (unsigned char *)&buff[9], muxer->sysrate);
                 len = 12;
         }
         else
         {
-                write_mpeg2_scr(&buff[4], priv->scr); // 0010 and SCR
-                write_mpeg_rate(priv->mux, &buff[10], muxer->sysrate);
+                write_mpeg2_scr((unsigned char *)&buff[4], priv->scr); // 0010 and SCR
+                write_mpeg_rate(priv->mux, (unsigned char *)&buff[10], muxer->sysrate);
                 buff[13] = 0xf8; //5 bits reserved + 3 set to 0 to indicate 0 stuffing bytes 
                 len = 14;
         }
@@ -552 +552 @@
         len += 4;
         *(uint16_t *)(&buff[len]) = 0;  //fake length, we'll fix it later
         len += 2;
-        write_mpeg_rate(MUX_MPEG1, &buff[len], muxer->sysrate);
+        write_mpeg_rate(MUX_MPEG1, (unsigned char *)&buff[len], muxer->sysrate);
         len += 3;
                 
         buff[len++] = 0x4 | (priv->is_xvcd ? 1 : 0);    //1 audio stream bound, no fixed, CSPS only for xvcd
@@ -563 +563 @@
         for(i = 0; i < priv->sys_info.cnt; i++)
         {
                 buff[len++] = priv->sys_info.streams[i].id;
-                write_mpeg_std(&buff[len], priv->sys_info.streams[i].bufsize, priv->sys_info.streams[i].type, 
+                write_mpeg_std((unsigned char *)&buff[len], priv->sys_info.streams[i].bufsize, priv->sys_info.streams[i].type, 
                         (priv->sys_info.streams[i].type == 1 ? 0xe0: 0xc0));
                 len += 2;
         }
@@ -619 +619 @@
         
         *(uint16_t *)(&buff[4]) = be2me_16(len - 6 + 4);        // length field fixed, including size of CRC32
         
-        *(uint32_t *)(&buff[len]) = CalcCRC32(buff, len);
+        *(uint32_t *)((unsigned char *)&buff[len]) = CalcCRC32((unsigned char *)buff, len);
         
         len += 4;       //for crc
         
@@ -728 +728 @@
         muxer_priv_t *priv = (muxer_priv_t *) muxer->priv;
         uint8_t *buff = priv->buff;
         
-        offset = write_mpeg_pack_header(muxer, buff);
-        offset += write_mpeg_psm(muxer, &buff[offset]);
+        offset = write_mpeg_pack_header(muxer, (char *)buff);
+        offset += write_mpeg_psm(muxer, (char *)&buff[offset]);
         stuffing_len = priv->packet_size - offset;
         if(stuffing_len > 0)
         {
@@ -841 +841 @@
                 
         if((len == 0) || (bl == NULL))                  //PACK headers only
         {
-                offset = write_mpeg_pack_header(muxer, buff);
-                offset += write_mpeg_system_header(muxer, &buff[offset]);
+                offset = write_mpeg_pack_header(muxer, (char *)buff);
+                offset += write_mpeg_system_header(muxer, (char *)&buff[offset]);
                 
                 //priv->update_system_header = 0;
                 
@@ -875 +875 @@
                 //stuffing_len is the size of the stuffing pes stream (must be at least 7 bytes long)
                 stflen = stuffing_len = 0;
                 offset = 0;
-                offset = pack_hlen = write_mpeg_pack_header(muxer, &buff[offset]);
+                offset = pack_hlen = write_mpeg_pack_header(muxer, (char *)&buff[offset]);
                 
                 if(priv->update_system_header && (priv->is_genmpeg1 || priv->is_genmpeg2))
                 {
-                        pack_hlen += write_mpeg_system_header(muxer, &buff[offset]);
+                        pack_hlen += write_mpeg_system_header(muxer, (char *)&buff[offset]);
                         priv->update_system_header = 0;
                 }
 
@@ -1135 +1135 @@
         if((priv->is_xsvcd || priv->is_xvcd) && apriv->size == 0)
                 apriv->buffer_size = 4*1024;
         
-        len = write_mpeg_pack(muxer, as, muxer->file, priv->abuf, tlen, 0);
+        len = write_mpeg_pack(muxer, as, muxer->file, (char *)priv->abuf, tlen, 0);
 
         if((priv->is_xsvcd || priv->is_xvcd) && apriv->size == 0)
                 apriv->buffer_size = 0;
@@ -1663 +1663 @@
                                         pl_size = update = vbytes = 0;  
                                 }
                                 if(pl_size)
-                                        pl_size = write_mpeg_pack(muxer, vs, muxer->file, buf, pl_size, 0);
+                                        pl_size = write_mpeg_pack(muxer, vs, muxer->file, (char *)buf, pl_size, 0);
                                 vpriv->pes_is_aligned = 0;
                                 vpriv->pts = vpriv->dts = 0;
                                 vpriv->buffer_size = 0;
@@ -2540 +2540 @@
                 }
         }
         
-        parse_audio(s, 0, &nf, &fake_timer);
+        parse_audio(s, 0, (int *)&nf, &fake_timer);
         sz = max(len, 2 * priv->packet_size);
   }
   

libmpdemux/network.c

@@ -76 +76 @@
         { "video/x-ms-wmv", DEMUXER_TYPE_ASF },
         { "video/x-ms-wma", DEMUXER_TYPE_ASF },
         { "application/x-mms-framed", DEMUXER_TYPE_ASF },
-        { "application/vnd.ms.wms-hdr.asfv1", DEMUXER_TYPE_ASF },
-        { "application/octet-stream", DEMUXER_TYPE_ASF },
         // Playlists
         { "video/x-ms-wmx", DEMUXER_TYPE_PLAYLIST },
         { "audio/x-scpls", DEMUXER_TYPE_PLAYLIST },

libmpdemux/pnm.c

@@ -442 +442 @@
   char fixme[]={0,1};
 
   memcpy(p->buffer,pnm_header,PNM_HEADER_SIZE);
-  c+=pnm_write_chunk(PNA_CLIENT_CHALLANGE,strlen(pnm_challenge),
-          pnm_challenge,&p->buffer[c]);
+  c+=pnm_write_chunk(PNA_CLIENT_CHALLANGE,strlen((char *)pnm_challenge),
+          (char *)pnm_challenge,&p->buffer[c]);
   c+=pnm_write_chunk(PNA_CLIENT_CAPS,PNM_CLIENT_CAPS_SIZE,
-          pnm_client_caps,&p->buffer[c]);
+          (char *)pnm_client_caps,&p->buffer[c]);
   c+=pnm_write_chunk(0x0a,0,NULL,&p->buffer[c]);
   c+=pnm_write_chunk(0x0c,0,NULL,&p->buffer[c]);
   c+=pnm_write_chunk(0x0d,0,NULL,&p->buffer[c]);
   c+=pnm_write_chunk(0x16,2,fixme,&p->buffer[c]);
-  c+=pnm_write_chunk(PNA_TIMESTAMP,strlen(pnm_timestamp),
-          pnm_timestamp,&p->buffer[c]);
+  c+=pnm_write_chunk(PNA_TIMESTAMP,strlen((char *)pnm_timestamp),
+          (char *)pnm_timestamp,&p->buffer[c]);
   c+=pnm_write_chunk(PNA_BANDWIDTH,4,
           (const char *)&pnm_default_bandwidth,&p->buffer[c]);
   c+=pnm_write_chunk(0x08,0,NULL,&p->buffer[c]);
@@ -461 +461 @@
   c+=pnm_write_chunk(0x10,0,NULL,&p->buffer[c]);
   c+=pnm_write_chunk(0x15,0,NULL,&p->buffer[c]);
   c+=pnm_write_chunk(0x12,0,NULL,&p->buffer[c]);
-  c+=pnm_write_chunk(PNA_GUID,strlen(pnm_guid),
-          pnm_guid,&p->buffer[c]);
+  c+=pnm_write_chunk(PNA_GUID,strlen((char *)pnm_guid),
+          (char *)pnm_guid,&p->buffer[c]);
   c+=pnm_write_chunk(PNA_TWENTYFOUR,PNM_TWENTYFOUR_SIZE,
-          pnm_twentyfour,&p->buffer[c]);
+          (char *)pnm_twentyfour,&p->buffer[c]);
   
   /* data after chunks */
   memcpy(&p->buffer[c],after_chunks,after_chunks_length);
@@ -472 +472 @@
 
   /* client id string */
   p->buffer[c]=PNA_CLIENT_STRING;
-  i16=BE_16D((strlen(client_string)-1)); /* don't know why do we have -1 here */
+  i16=BE_16D((strlen((char *)client_string)-1)); /* don't know why do we have -1 here */
   memcpy(&p->buffer[c+1],&i16,2);
-  memcpy(&p->buffer[c+3],client_string,strlen(client_string)+1);
-  c=c+3+strlen(client_string)+1;
+  memcpy(&p->buffer[c+3],client_string,strlen((char *)client_string)+1);
+  c=c+3+strlen((char *)client_string)+1;
 
   /* file path */
   p->buffer[c]=0;
@@ -535 +535 @@
       mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: header buffer overflow. exiting\n");
       return 0;
     }
-    chunk_size=pnm_get_chunk(p,HEADER_SIZE-size,&chunk_type,ptr,&nr);
+    chunk_size=pnm_get_chunk(p,HEADER_SIZE-size,&chunk_type,(char *)ptr,&nr);
     if (chunk_size < 0) return 0;
     if (chunk_type == 0) break;
     if (chunk_type == PNA_TAG)
@@ -797 +797 @@
     return NULL;
   }
   if (need_response)
-    pnm_send_response(p, pnm_response);
+    pnm_send_response(p, (char *)pnm_response);
   p->ts_last[0]=0;
   p->ts_last[1]=0;
   
@@ -814 +814 @@
   
   int to_copy=len;
   char *dest=data;
-  char *source=this->recv + this->recv_read;
+  unsigned char *source=this->recv + this->recv_read;
   int fill=this->recv_size - this->recv_read;
   int retval;
   

libmpdemux/realrtsp/real.c

@@ -399 +399 @@
   
   if (xor_table != NULL)
   {
-    table_len = strlen(xor_table);
+    table_len = strlen((char *)xor_table);
 
     if (table_len > 56) table_len=56;
 
@@ -606 +606 @@
   static uint32_t prev_ts = -1;
   static int prev_stream_number = -1;
 
-  n=rtsp_read_data(rtsp_session, header, 8);
+  n=rtsp_read_data(rtsp_session, (char *)header, 8);
   if (n<8) return 0;
   if (header[0] != 0x24)
   {
@@ -627 +627 @@
     header[0]=header[5];
     header[1]=header[6];
     header[2]=header[7];
-    n=rtsp_read_data(rtsp_session, header+3, 5);
+    n=rtsp_read_data(rtsp_session, (char *)header+3, 5);
     if (n<5) return 0;
 #ifdef LOG
     printf("ignoring bytes:\n");
     hexdump(header, 8);
 #endif
-    n=rtsp_read_data(rtsp_session, header+4, 4);
+    n=rtsp_read_data(rtsp_session, (char *)header+4, 4);
     if (n<4) return 0;
     flags1=header[4];
     size-=9;
@@ -641 +641 @@
   flags2=header[7];
   // header[5..6] == frame number in stream
   unknown1=(header[5]<<16)+(header[6]<<8)+(header[7]);
-  n=rtsp_read_data(rtsp_session, header, 6);
+  n=rtsp_read_data(rtsp_session, (char *)header, 6);
   if (n<6) return 0;
   ts=BE_32(header);
   

libmpdemux/realrtsp/rtsp_session.c

@@ -134 +134 @@
       }
     }
         
-    rtsp_session->header_len=rmff_dump_header(h,rtsp_session->header,1024);
+    rtsp_session->header_len=rmff_dump_header(h,(char *)rtsp_session->header,1024);
 
     rtsp_session->recv = xbuffer_copyin(rtsp_session->recv, 0, rtsp_session->header, rtsp_session->header_len);
     rtsp_session->recv_size = rtsp_session->header_len;
@@ -158 +158 @@
   
   int to_copy=len;
   char *dest=data;
-  char *source=this->recv + this->recv_read;
+  unsigned char *source=this->recv + this->recv_read;
   int fill=this->recv_size - this->recv_read;
 
   if (len < 0) return 0;

libmpdemux/rtp.c

@@ -151 +151 @@
           goto err_out;
         }
                 err_len = sizeof( err );
-                getsockopt( socket_server_fd, SOL_SOCKET, SO_ERROR, &err, &err_len );
+                getsockopt( socket_server_fd, SOL_SOCKET, SO_ERROR, &err, (unsigned int *)&err_len );
                 if( err ) {
                         mp_msg(MSGT_NETWORK,MSGL_DBG2,"Socket error: %d\n", err );
                         goto err_out;

libmpdemux/stream.c

@@ -220 +220 @@
   case STREAMTYPE_STREAM:
 #ifdef MPLAYER_NETWORK
     if( s->streaming_ctrl!=NULL ) {
-            len=s->streaming_ctrl->streaming_read(s->fd,s->buffer,STREAM_BUFFER_SIZE, s->streaming_ctrl);break;
+            len=s->streaming_ctrl->streaming_read(s->fd,(char *)s->buffer,STREAM_BUFFER_SIZE, s->streaming_ctrl);break;
     } else {
       len=read(s->fd,s->buffer,STREAM_BUFFER_SIZE);break;
     }
@@ -233 +233 @@
   
     
   default: 
-    len= s->fill_buffer ? s->fill_buffer(s,s->buffer,STREAM_BUFFER_SIZE) : 0;
+    len= s->fill_buffer ? s->fill_buffer(s,(char *)s->buffer,STREAM_BUFFER_SIZE) : 0;
   }
   if(len<=0){ s->eof=1; s->buf_pos=s->buf_len=0; return 0; }
   s->buf_pos=0;

libmpdemux/stream_dvd.c

@@ -143 +143 @@
   dvd_priv_t *d=stream->priv;
   int code,i;
   if(lang) {
-    while(strlen(lang)>=2) {
+    while(strlen((char *)lang)>=2) {
       code=lang[1]|(lang[0]<<8);
       for(i=0;i<d->nr_of_channels;i++) {
         if(d->audio_streams[i].language==code) {
@@ -180 +180 @@
 int dvd_sid_from_lang(stream_t *stream, unsigned char* lang) {
   dvd_priv_t *d=stream->priv;
   int code,i;
-  while(lang && strlen(lang)>=2) {
+  while(lang && strlen((char *)lang)>=2) {
     code=lang[1]|(lang[0]<<8);
     for(i=0;i<d->nr_of_subtitles;i++) {
       if(d->subtitles[i].language==code) {

libmpdemux/stream_file.c

@@ -59 +59 @@
     return 0;
   }
   while(s->pos<newpos){
-    int len=s->fill_buffer(s,s->buffer,STREAM_BUFFER_SIZE);
+    int len=s->fill_buffer(s,(char *)s->buffer,STREAM_BUFFER_SIZE);
     if(len<=0){ s->eof=1; s->buf_pos=s->buf_len=0; break; } // EOF
     s->buf_pos=0;
     s->buf_len=len;
@@ -101 +101 @@
   m |= O_BINARY;
 #endif    
 
-  if(!strcmp(filename,"-")){
+  if(!strcmp((char *)filename,"-")){
     if(mode == STREAM_READ) {
       // read from stdin
       mp_msg(MSGT_OPEN,MSGL_INFO,MSGTR_ReadSTDIN);
@@ -117 +117 @@
 #endif
     }
   } else {
-    f=open(filename,m);
+    f=open((char *)filename,m);
     if(f<0) {
       mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_FileNotFound,filename);
       m_struct_free(&stream_opts,opts);

libmpdemux/tvi_v4l2.c

@@ -745 +745 @@
                 standard.index = i;
                 if (-1 == ioctl(priv->video_fd, VIDIOC_ENUMSTD, &standard))
                     return TVI_CONTROL_FALSE;
-                if (!strcasecmp(standard.name, (char *)arg)) {
+                if (!strcasecmp((char *)standard.name, (char *)arg)) {
                     *(int *)arg = i;
                     return TVI_CONTROL_TRUE;
                 }

libmpdemux/video.c

@@ -141 +141 @@
    }
    mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
    if(!videobuffer) {
-     videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
+     videobuffer=(unsigned char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
      if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
      else {
        mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail);
@@ -234 +234 @@
    }
    mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n");
    if(!videobuffer) {
-     videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
+     videobuffer=(unsigned char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
      if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
      else {
        mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail);
@@ -295 +295 @@
 //   mpeg2_init();
    // ========= Read & process sequence header & extension ============
    if(!videobuffer) {
-     videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
+     videobuffer=(unsigned char*)memalign(8,VIDEOBUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
      if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
      else {
        mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail);

libmpdemux/yuv4mpeg.c

@@ -63 +63 @@
    ssize_t n;
 
    while (len > 0) {
-     n = stream_read(s, buf, len);
+     n = stream_read(s, (unsigned char*)(buf), len);
      if (n <= 0) {
        /* return amount left to read */
        if (n == 0)
@@ -597 +597 @@
   /* Read frame header */
   if ((err = y4m_read_frame_header(s, fi)) != Y4M_OK) return err;
   /* Read luminance scanlines */
-  if (y4m_read(s, yuv[0], w*h)) return Y4M_ERR_SYSTEM;
+  if (y4m_read(s, (char *)yuv[0], w*h)) return Y4M_ERR_SYSTEM;
   /* Read chrominance scanlines */
-  if (y4m_read(s, yuv[1], w*h/4)) return Y4M_ERR_SYSTEM;
-  if (y4m_read(s, yuv[2], w*h/4)) return Y4M_ERR_SYSTEM;
+  if (y4m_read(s, (char *)yuv[1], w*h/4)) return Y4M_ERR_SYSTEM;
+  if (y4m_read(s, (char *)yuv[2], w*h/4)) return Y4M_ERR_SYSTEM;
 
   return Y4M_OK;
 }

libmpdvdkit2/css.c

@@ -179 +179 @@
             psz_key[KEY_SIZE * 3 - 1] = '\0';
 
             if( read( i_fd, psz_key, KEY_SIZE * 3 - 1 ) == KEY_SIZE * 3 - 1
-                 && sscanf( psz_key, "%x:%x:%x:%x:%x",
+                 && sscanf( (char *)psz_key, "%x:%x:%x:%x:%x",
                             &k0, &k1, &k2, &k3, &k4 ) == 5 )
             {
                 p_title_key[0] = k0;
@@ -224 +224 @@
         {
             unsigned char psz_key[KEY_SIZE * 3 + 2];
 
-            sprintf( psz_key, "%02x:%02x:%02x:%02x:%02x\r\n",
+            sprintf( (char *)psz_key, "%02x:%02x:%02x:%02x:%02x\r\n",
                               p_title_key[0], p_title_key[1], p_title_key[2],
                               p_title_key[3], p_title_key[4] );
 

libmpdvdkit2/libdvdcss.c

@@ -386 +386 @@
         unsigned char psz_tagfile[PATH_MAX+1+12+1];
         int i_fd;
 
-        sprintf( psz_tagfile, "%s/CACHEDIR.TAG", psz_cache );
-        i_fd = open( psz_tagfile, O_RDWR|O_CREAT, 0644 );
+        sprintf( (char *)psz_tagfile, "%s/CACHEDIR.TAG", psz_cache );
+        i_fd = open( (char *)psz_tagfile, O_RDWR|O_CREAT, 0644 );
         if( i_fd >= 0 )
         {
             write( i_fd, psz_tag, strlen(psz_tag) );
@@ -468 +468 @@
             if( psz_serial[i] < '0' || psz_serial[i] > '9' )
             {
                 unsigned char psz_tmp[16 + 1];
-                sprintf( psz_tmp,
+                sprintf( (char *)psz_tmp,
                          "%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",
                          psz_serial[0], psz_serial[1], psz_serial[2],
                          psz_serial[3], psz_serial[4], psz_serial[5],
@@ -485 +485 @@
              psz_key[0] = '-';
              for( i = 0; i < KEY_SIZE; i++ )
              {
-                 sprintf( &psz_key[1+i*2], "%.2x", dvdcss->css.p_disc_key[i] );
+                 sprintf( (char *)&psz_key[1+i*2], "%.2x", dvdcss->css.p_disc_key[i] );
              }
              psz_key[1 + KEY_SIZE * 2] = '\0';
         }
@@ -526 +526 @@
         /* Pointer to the filename we will use. */
         dvdcss->psz_block = dvdcss->psz_cachefile + i;
 
-        sprintf( psz_debug, "using CSS key cache dir: %s",
+        sprintf( (char *)psz_debug, "using CSS key cache dir: %s",
                             dvdcss->psz_cachefile );
-        print_debug( dvdcss, psz_debug );
+        print_debug(dvdcss, (char *)psz_debug );
     }
     nocache:
 

libvo/font_load.c

@@ -84 +84 @@
 
 section[0]=0;
 
-while(fgets(sor,1020,f)){
+while(fgets((char *)sor,1020,f)){
   unsigned char* p[8];
   int pdb=0;
   unsigned char *s=sor;
@@ -133 +133 @@
 //  for(i=0;i<pdb;i++) printf("  param %d = '%s'\n",i,p[i]);
 
   if(pdb==1 && p[0][0]=='['){
-      int len=strlen(p[0]);
+      int len=strlen((char *)p[0]);
       if(len && len<63 && p[0][len-1]==']'){
-        strcpy(section,p[0]);
+        strcpy(section,(char *)p[0]);
         mp_msg(MSGT_OSD, MSGL_DBG2, "font: Reading section: %s\n",section);
         if(strcmp(section,"[files]")==0){
             ++fontdb;
@@ -149 +149 @@
       if(pdb==1){
           if (desc->fpath)
              free (desc->fpath); // release previously allocated memory
-          desc->fpath=strdup(p[0]);
+          desc->fpath=strdup((char *)p[0]);
           continue;
       }
   } else    
 
   if(strcmp(section,"[files]")==0){
       char *default_dir=MPLAYER_DATADIR "/font";
-      if(pdb==2 && strcmp(p[0],"alpha")==0){
+      if(pdb==2 && strcmp((char *)p[0],"alpha")==0){
           char *cp;
-          if (!(cp=malloc(strlen(desc->fpath)+strlen(p[1])+2))) goto fail_out;
+          if (!(cp=malloc(strlen(desc->fpath)+strlen((char *)p[1])+2))) goto fail_out;
 
-          snprintf(cp,strlen(desc->fpath)+strlen(p[1])+2,"%s/%s",
+          snprintf(cp,strlen(desc->fpath)+strlen((char *)p[1])+2,"%s/%s",
                 desc->fpath,p[1]);
           if(!((desc->pic_a[fontdb]=load_raw(cp,verbose)))){
                 free(cp);
-                if (!(cp=malloc(strlen(default_dir)+strlen(p[1])+2))) 
+                if (!(cp=malloc(strlen(default_dir)+strlen((char *)p[1])+2))) 
                    goto fail_out;
-                snprintf(cp,strlen(default_dir)+strlen(p[1])+2,"%s/%s",
+                snprintf(cp,strlen(default_dir)+strlen((char *)p[1])+2,"%s/%s",
                          default_dir,p[1]);
                 if (!((desc->pic_a[fontdb]=load_raw(cp,verbose)))){
                    mp_msg(MSGT_OSD, MSGL_ERR, "Can't load font bitmap: %s\n",p[1]);
@@ -177 +177 @@
           free(cp);
           continue;
       }
-      if(pdb==2 && strcmp(p[0],"bitmap")==0){
+      if(pdb==2 && strcmp((char *)p[0],"bitmap")==0){
           char *cp;
-          if (!(cp=malloc(strlen(desc->fpath)+strlen(p[1])+2))) goto fail_out;
+          if (!(cp=malloc(strlen(desc->fpath)+strlen((char *)p[1])+2))) goto fail_out;
 
-          snprintf(cp,strlen(desc->fpath)+strlen(p[1])+2,"%s/%s",
+          snprintf(cp,strlen(desc->fpath)+strlen((char *)p[1])+2,"%s/%s",
                 desc->fpath,p[1]);
           if(!((desc->pic_b[fontdb]=load_raw(cp,verbose)))){
                 free(cp);
-                if (!(cp=malloc(strlen(default_dir)+strlen(p[1])+2))) 
+                if (!(cp=malloc(strlen(default_dir)+strlen((char *)p[1])+2))) 
                    goto fail_out;
-                snprintf(cp,strlen(default_dir)+strlen(p[1])+2,"%s/%s",
+                snprintf(cp,strlen(default_dir)+strlen((char *)p[1])+2,"%s/%s",
                          default_dir,p[1]);
                 if (!((desc->pic_b[fontdb]=load_raw(cp,verbose)))){
                    mp_msg(MSGT_OSD, MSGL_ERR, "Can't load font bitmap: %s\n",p[1]);
@@ -201 +201 @@
   } else
 
   if(strcmp(section,"[info]")==0){
-      if(pdb==2 && strcmp(p[0],"name")==0){
-          desc->name=strdup(p[1]);
+      if(pdb==2 && strcmp((char *)p[0],"name")==0){
+          desc->name=strdup((char *)p[1]);
           continue;
       }
-      if(pdb==2 && strcmp(p[0],"descversion")==0){
-          version=atoi(p[1]);
+      if(pdb==2 && strcmp((char *)p[0],"descversion")==0){
+          version=atoi((char *)p[1]);
           continue;
       }
-      if(pdb==2 && strcmp(p[0],"spacewidth")==0){
-          desc->spacewidth=atoi(p[1]);
+      if(pdb==2 && strcmp((char *)p[0],"spacewidth")==0){
+          desc->spacewidth=atoi((char *)p[1]);
           continue;
       }
-      if(pdb==2 && strcmp(p[0],"charspace")==0){
-          desc->charspace=atoi(p[1]);
+      if(pdb==2 && strcmp((char *)p[0],"charspace")==0){
+          desc->charspace=atoi((char *)p[1]);
           continue;
       }
-      if(pdb==2 && strcmp(p[0],"height")==0){
-          desc->height=atoi(p[1]);
+      if(pdb==2 && strcmp((char *)p[0],"height")==0){
+          desc->height=atoi((char *)p[1]);
           continue;
       }
   } else
@@ -226 +226 @@
   if(strcmp(section,"[characters]")==0){
       if(pdb==3){
           int chr=p[0][0];
-          int start=atoi(p[1]);
-          int end=atoi(p[2]);
+          int start=atoi((char *)p[1]);
+          int end=atoi((char *)p[2]);
           if(sub_unicode && (chr>=0x80)) chr=(chr<<8)+p[0][1];
-          else if(strlen(p[0])!=1) chr=strtol(p[0],NULL,0);
+          else if(strlen((char *)p[0])!=1) chr=strtol((char *)p[0],NULL,0);
           if(end<start) {
               mp_msg(MSGT_OSD, MSGL_WARN, "error in font desc: end<start for char '%c'\n",chr);
           } else {

libvo/font_load_ft.c

@@ -598 +598 @@
     
     if (desc->tables.g_r) {
         blur(abuffer+off, desc->tables.tmp, width, height, stride,
-             desc->tables.gt2, desc->tables.g_r,
+             (int *)desc->tables.gt2, desc->tables.g_r,
              desc->tables.g_w);
 //      fprintf(stderr, "fg: blur t = %lf\n", GetTimer()-t);
     }
@@ -740 +740 @@
     int inbytesleft = 1;
     int outbytesleft = sizeof(FT_ULong);
 
-    iconv(*cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+    iconv(*cd, &inbuf, (unsigned int *)&inbytesleft, &outbuf, (unsigned int *)&outbytesleft);
 
     /* convert unicode BigEndian -> MachineEndian */
     o = be2me_32(o);
@@ -1142 +1142 @@
         if (!font_name)
             font_name = "sans-serif";
         FcInit();
-        fc_pattern = FcNameParse(font_name);
+        fc_pattern = FcNameParse((unsigned char *)font_name);
         FcConfigSubstitute(0, fc_pattern, FcMatchPattern);
         FcDefaultSubstitute(fc_pattern);
         fc_pattern = FcFontMatch(0, fc_pattern, 0);
         FcPatternGetBool(fc_pattern, FC_SCALABLE, 0, &scalable);
         if (scalable != FcTrue) {
-            fc_pattern = FcNameParse("sans-serif");
+            fc_pattern = FcNameParse((unsigned char *)"sans-serif");
             FcConfigSubstitute(0, fc_pattern, FcMatchPattern);
             FcDefaultSubstitute(fc_pattern);
             fc_pattern = FcFontMatch(0, fc_pattern, 0);
         }
         // s doesn't need to be freed according to fontconfig docs
         FcPatternGetString(fc_pattern, FC_FILE, 0, &s);
-        vo_font=read_font_desc_ft(s, width, height);
+        vo_font=read_font_desc_ft((char *)s, width, height);
         free(fc_pattern);
     }
     else

libvo/sub.c

@@ -367 +367 @@
             xsize = -vo_font->charspace;
           l--;
           t=vo_sub->text[i++];    
-          len=strlen(t)-1;
+          len=strlen((char *)t)-1;
             char_position = 0;
             char_seq = (int *) malloc((len + 1) * sizeof(int));
 

libvo/vo_dga.c

@@ -243 +243 @@
     {
 
         case 32:
-            vo_draw_alpha_rgb32(w, h, src, srca, stride, d + 4 * offset,
+            vo_draw_alpha_rgb32(w, h, src, srca, stride, (unsigned char *)d + 4 * offset,
                                 4 * buffer_stride);
             break;
         case 24:
-            vo_draw_alpha_rgb24(w, h, src, srca, stride, d + 3 * offset,
+            vo_draw_alpha_rgb24(w, h, src, srca, stride, (unsigned char *)d + 3 * offset,
                                 3 * buffer_stride);
             break;
         case 15:
-            vo_draw_alpha_rgb15(w, h, src, srca, stride, d + 2 * offset,
+            vo_draw_alpha_rgb15(w, h, src, srca, stride, (unsigned char *)d + 2 * offset,
                                 2 * buffer_stride);
             break;
         case 16:
-            vo_draw_alpha_rgb16(w, h, src, srca, stride, d + 2 * offset,
+            vo_draw_alpha_rgb16(w, h, src, srca, stride, (unsigned char *)d + 2 * offset,
                                 2 * buffer_stride);
             break;
     }
@@ -637 +637 @@
         aspect_save_orig(scale_srcW, scale_srcH);
         aspect_save_prescale(scale_dstW, scale_dstH);
         if (flags & VOFLAG_FULLSCREEN)       /* -fs */
-            aspect(&scale_dstW, &scale_dstH, A_ZOOM);
+            aspect((int *)&scale_dstW, (int *)&scale_dstH, A_ZOOM);
         else if (flags & VOFLAG_SWSCALE)  /* -fs */
-            aspect(&scale_dstW, &scale_dstH, A_NOZOOM);
+            aspect((int *)&scale_dstW, (int *)&scale_dstH, A_NOZOOM);
         mp_msg(MSGT_VO, MSGL_INFO,
                "vo_dga: Aspect corrected size for SwScaler: %4d x %4d.\n",
                scale_dstW, scale_dstH);

libvo/vo_gl2.c

@@ -791 +791 @@
         glValName(gl_bitmap_format), glValName(gl_bitmap_type),
         rgb_sz, r_sz, g_sz, b_sz, a_sz, glValName(gl_internal_format));
 
-  resize(&d_width, &d_height);
+  resize((int *)&d_width, (int *)&d_height);
 
   glClearColor( 0.0f,0.0f,0.0f,0.0f );
   glClear( GL_COLOR_BUFFER_BIT );
@@ -820 +820 @@
         aspect_save_prescale(d_width,d_height);
         aspect_save_screenres(vo_screenwidth,vo_screenheight);
 
-        aspect(&d_width,&d_height,A_NOZOOM);
+        aspect((int *)&d_width,(int *)&d_height,A_NOZOOM);
         vo_dx = (int)(vo_screenwidth - d_width) / 2;
         vo_dy = (int)(vo_screenheight - d_height) / 2;
-        geometry(&vo_dx, &vo_dy, &d_width, &d_height,
+        geometry(&vo_dx, &vo_dy, (int *)&d_width, (int *)&d_height,
                   vo_screenwidth, vo_screenheight);
 
 #if defined(HAVE_NEW_GUI) && !defined(GL_WIN32)
@@ -862 +862 @@
         mp_msg(MSGT_VO, MSGL_INFO, "[gl2] You have OpenGL < 1.2 drivers, BAD (16bpp and BGR may be damaged!)\n");
   }
 
-  glFindFormat(format, &image_bpp, &gl_internal_format, &gl_bitmap_format, &gl_bitmap_type);
+  glFindFormat(format, (int *)&image_bpp, &gl_internal_format, &gl_bitmap_format, &gl_bitmap_type);
 
   image_bytes=(image_bpp+7)/8;
 

libvo/vo_gl.c

@@ -308 +308 @@
         aspect_save_prescale(d_width,d_height);
         aspect_save_screenres(vo_screenwidth,vo_screenheight);
 
-        aspect(&d_width,&d_height,A_NOZOOM);
+        aspect((int *)&d_width,(int *)&d_height,A_NOZOOM);
         vo_dx = (int)(vo_screenwidth - d_width) / 2;
         vo_dy = (int)(vo_screenheight - d_height) / 2;
-        geometry(&vo_dx, &vo_dy, &d_width, &d_height,
+        geometry(&vo_dx, &vo_dy, (int *)&d_width, (int *)&d_height,
                   vo_screenwidth, vo_screenheight);
 #ifdef HAVE_NEW_GUI
   if (use_gui) {

libvo/vo_jpeg.c

@@ -179 +179 @@
     int row_stride;
 
     if ( !buffer ) return 1; 
-    if ( (outfile = fopen(name, "wb") ) == NULL ) {
+    if ( (outfile = fopen((char *)name, "wb") ) == NULL ) {
         mp_msg(MSGT_VO, MSGL_ERR, "\n%s: %s\n", info.short_name,
                 MSGTR_VO_CantCreateFile);
         mp_msg(MSGT_VO, MSGL_ERR, "%s: %s: %s\n",
@@ -264 +264 @@
     
     framecounter++;
     
-    return jpeg_write(buf, src[0]);
+    return jpeg_write((unsigned char *)buf, src[0]);
 }
 
 /* ------------------------------------------------------------------------- */

libvo/vo_x11.c

@@ -288 +288 @@
     srcH = height;
     vo_dx = (vo_screenwidth - d_width) / 2;
     vo_dy = (vo_screenheight - d_height) / 2;
-    geometry(&vo_dx, &vo_dy, &d_width, &d_height, vo_screenwidth,
+    geometry(&vo_dx, &vo_dy, (int *)&d_width, (int *)&d_height, vo_screenwidth,
              vo_screenheight);
     vo_dwidth = d_width;
     vo_dheight = d_height;
@@ -346 +346 @@
                 vm_width = d_width;
                 vm_height = d_height;
             }
-            vo_vm_switch(vm_width, vm_height, &modeline_width,
-                         &modeline_height);
+            vo_vm_switch(vm_width, vm_height, (int *)&modeline_width,
+                         (int *)&modeline_height);
             vo_dx = (vo_screenwidth - modeline_width) / 2;
             vo_dy = (vo_screenheight - modeline_height) / 2;
             vo_dwidth = modeline_width;
@@ -392 +392 @@
                                            ExposureMask);
                 XMapWindow(mDisplay, vo_window);
                 XGetGeometry(mDisplay, vo_window, &mRootWin,
-                             &vo_dx, &vo_dy, &vo_dwidth, &vo_dheight,
-                             &border, &depth);
+                             &vo_dx, &vo_dy, (unsigned int *)&vo_dwidth, (unsigned int *)&vo_dheight,
+                             (unsigned int *)&border, (unsigned int *)&depth);
             } else
                 XSelectInput(mDisplay, vo_window, ExposureMask);
         } else

libvo/vo_xover.c

@@ -80 +80 @@
   Window mRoot;
   if ( WinID )
     {
-      XGetGeometry(mDisplay, vo_window, &mRoot, &drwX, &drwY, &drwWidth,
-                   &drwHeight, &drwBorderWidth, &drwDepth);
+      XGetGeometry(mDisplay, vo_window, &mRoot, (int *)&drwX, (int *)&drwY, (unsigned int *)&drwWidth,
+                   (unsigned int *)&drwHeight, &drwBorderWidth, &drwDepth);
       drwX = drwY = 0;
 
       XTranslateCoordinates(mDisplay, vo_window, mRoot, 0, 0,
-                            &drwcX, &drwcY, &mRoot);
-      aspect(&dwidth,&dheight,A_NOZOOM);
+                            (int *)&drwcX, (int *)&drwcY, &mRoot);
+      aspect((int *)&dwidth,(int *)&dheight,A_NOZOOM);
       if (!vo_fs)
         mp_msg(MSGT_VO, MSGL_V, "[xvidix] dcx: %d dcy: %d dx: %d dy: %d dw: %d dh: %d\n",
                drwcX, drwcY, drwX, drwY, drwWidth, drwHeight);
@@ -95 +95 @@
     } 
   else 
     { 
-      aspect(&dwidth,&dheight,A_NOZOOM);
+      aspect((int *)&dwidth,(int *)&dheight,A_NOZOOM);
       drwcX=drwX=vo_dx; drwcY=drwY=vo_dy; drwWidth=vo_dwidth; drwHeight=vo_dheight; 
     }
 
 #if X11_FULLSCREEN
   if (vo_fs)
     {
-      aspect(&dwidth,&dheight,A_ZOOM);
+      aspect((int *)&dwidth,(int *)&dheight,A_ZOOM);
       drwX = (vo_screenwidth - ((int)dwidth > vo_screenwidth ? vo_screenwidth : dwidth)) / 2;
       drwcX = drwX;
       drwY = (vo_screenheight - ((int)dheight > vo_screenheight ? vo_screenheight : dheight)) / 2;
@@ -258 +258 @@
     }
   mp_msg(MSGT_VO, MSGL_V, "Using colorkey: %x\n", colorkey);
 
-  aspect(&d_width, &d_height, A_NOZOOM);
+  aspect((int *)&d_width, (int *)&d_height, A_NOZOOM);
 
   vo_dx=( vo_screenwidth - d_width ) / 2; vo_dy=( vo_screenheight - d_height ) / 2;    
   vo_dwidth=d_width; vo_dheight=d_height;
@@ -270 +270 @@
 #endif
 
 #ifdef X11_FULLSCREEN
-      if ( ( flags&VOFLAG_FULLSCREEN )||(flags & VOFLAG_SWSCALE) ) aspect(&d_width, &d_height, A_ZOOM);
+      if ( ( flags&VOFLAG_FULLSCREEN )||(flags & VOFLAG_SWSCALE) ) aspect((int *)&d_width, (int *)&d_height, A_ZOOM);
 #endif
       dwidth = d_width;
       dheight = d_height;

libvo/vo_xv.c

@@ -102 +102 @@
 {
     x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
     vo_draw_alpha_yv12(w, h, src, srca, stride,
-                       xvimage[current_buf]->data +
+                       (unsigned char *)xvimage[current_buf]->data +
                        xvimage[current_buf]->offsets[0] +
                        xvimage[current_buf]->pitches[0] * y0 + x0,
                        xvimage[current_buf]->pitches[0]);
@@ -114 +114 @@
 {
     x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
     vo_draw_alpha_yuy2(w, h, src, srca, stride,
-                       xvimage[current_buf]->data +
+                       (unsigned char *)xvimage[current_buf]->data +
                        xvimage[current_buf]->offsets[0] +
                        xvimage[current_buf]->pitches[0] * y0 + 2 * x0,
                        xvimage[current_buf]->pitches[0]);
@@ -126 +126 @@
 {
     x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
     vo_draw_alpha_yuy2(w, h, src, srca, stride,
-                       xvimage[current_buf]->data +
+                       (unsigned char *)xvimage[current_buf]->data +
                        xvimage[current_buf]->offsets[0] +
                        xvimage[current_buf]->pitches[0] * y0 + 2 * x0 + 1,
                        xvimage[current_buf]->pitches[0]);
@@ -192 +192 @@
 
     vo_dx = (vo_screenwidth - d_width) / 2;
     vo_dy = (vo_screenheight - d_height) / 2;
-    geometry(&vo_dx, &vo_dy, &d_width, &d_height, vo_screenwidth,
+    geometry(&vo_dx, &vo_dy, (int *)&d_width, (int *)&d_height, vo_screenwidth,
              vo_screenheight);
     vo_dwidth = d_width;
     vo_dheight = d_height;
@@ -232 +232 @@
     {
         hint.x = vo_dx;
         hint.y = vo_dy;
-        aspect(&d_width, &d_height, A_NOZOOM);
+        aspect((int *)&d_width, (int *)&d_height, A_NOZOOM);
         hint.width = d_width;
         hint.height = d_height;
 #ifdef HAVE_XF86VM
@@ -247 +247 @@
                 vm_width = d_width;
                 vm_height = d_height;
             }
-            vo_vm_switch(vm_width, vm_height, &modeline_width,
-                         &modeline_height);
+            vo_vm_switch(vm_width, vm_height, (int *)&modeline_width,
+                         (int *)&modeline_height);
             hint.x = (vo_screenwidth - modeline_width) / 2;
             hint.y = (vo_screenheight - modeline_height) / 2;
             hint.width = modeline_width;
@@ -266 +266 @@
              * irritated for now (and send lots o' mails ;) ::atmos
              */
 
-            aspect(&d_width, &d_height, A_ZOOM);
+            aspect((int *)&d_width, (int *)&d_height, A_ZOOM);
 #endif
 
         }
@@ -309 +309 @@
                                            ExposureMask);
                 XMapWindow(mDisplay, vo_window);
                 XGetGeometry(mDisplay, vo_window, &mRoot,
-                             &drwX, &drwY, &vo_dwidth, &vo_dheight,
+                             (int *)&drwX, (int *)&drwY, (unsigned int *)&vo_dwidth, (unsigned int *)&vo_dheight,
                              &drwBorderWidth, &drwDepth);
                 drwX = drwY = 0; // coordinates need to be local to the window
                 aspect_save_prescale(vo_dwidth, vo_dheight);
@@ -564 +564 @@
 
     if (e & VO_EVENT_RESIZE)
     {
-        XGetGeometry(mDisplay, vo_window, &mRoot, &drwX, &drwY, &vo_dwidth,
-                     &vo_dheight, &drwBorderWidth, &drwDepth);
+        XGetGeometry(mDisplay, vo_window, &mRoot, (int *)&drwX, (int *)&drwY, (unsigned int *)&vo_dwidth,
+                     (unsigned int *)&vo_dheight, &drwBorderWidth, &drwDepth);
         drwX = drwY = 0;
         mp_msg(MSGT_VO, MSGL_V, "[xv] dx: %d dy: %d dw: %d dh: %d\n", drwX,
                drwY, vo_dwidth, vo_dheight);
 
-        aspect(&dwidth, &dheight, A_NOZOOM);
+        aspect((int *)&dwidth, (int *)&dheight, A_NOZOOM);
         if (vo_fs)
         {
-            aspect(&dwidth, &dheight, A_ZOOM);
+            aspect((int *)&dwidth, (int *)&dheight, A_ZOOM);
             drwX =
                 (vo_screenwidth -
                  (dwidth > vo_screenwidth ? vo_screenwidth : dwidth)) / 2;

libvo/vo_xvidix.c

@@ -81 +81 @@
 
     if (WinID)
     {
-        XGetGeometry(mDisplay, vo_window, &mRoot, &drwX, &drwY, &drwWidth,
-                     &drwHeight, &drwBorderWidth, &drwDepth);
+        XGetGeometry(mDisplay, vo_window, &mRoot, (int *)&drwX, (int *)&drwY, (unsigned int *)&drwWidth,
+                     (unsigned int *)&drwHeight, &drwBorderWidth, &drwDepth);
         drwX = drwY = 0;
 
         XTranslateCoordinates(mDisplay, vo_window, mRoot, 0, 0,
-                              &drwcX, &drwcY, &mRoot);
-        aspect(&dwidth, &dheight, A_NOZOOM);
+                              (int *)&drwcX, (int *)&drwcY, &mRoot);
+        aspect((int *)&dwidth, (int *)&dheight, A_NOZOOM);
         if (!vo_fs)
             mp_msg(MSGT_VO, MSGL_V,
                    "[xvidix] dcx: %d dcy: %d dx: %d dy: %d dw: %d dh: %d\n",
@@ -96 +96 @@
         /* following stuff copied from vo_xmga.c */
     } else
     {
-        aspect(&dwidth, &dheight, A_NOZOOM);
+        aspect((int *)&dwidth, (int *)&dheight, A_NOZOOM);
         drwcX = drwX = vo_dx;
         drwcY = drwY = vo_dy;
         drwWidth = vo_dwidth;
@@ -106 +106 @@
 #if X11_FULLSCREEN
     if (vo_fs)
     {
-        aspect(&dwidth, &dheight, A_ZOOM);
+        aspect((int *)&dwidth, (int *)&dheight, A_ZOOM);
         drwX =
             (vo_screenwidth -
              (dwidth > vo_screenwidth ? vo_screenwidth : dwidth)) / 2;
@@ -255 +255 @@
     vo_dy = 0;
     vo_dx = (vo_screenwidth - d_width) / 2;
     vo_dy = (vo_screenheight - d_height) / 2;
-    geometry(&vo_dx, &vo_dy, &d_width, &d_height, vo_screenwidth,
+    geometry(&vo_dx, &vo_dy, (int *)&d_width, (int *)&d_height, vo_screenwidth,
              vo_screenheight);
     window_width = d_width;
     window_height = d_height;
@@ -288 +288 @@
     }
     mp_msg(MSGT_VO, MSGL_V, "Using colorkey: %x\n", colorkey);
 
-    aspect(&d_width, &d_height, A_NOZOOM);
+    aspect((int *)&d_width, (int *)&d_height, A_NOZOOM);
 
     vo_dwidth = d_width;
     vo_dheight = d_height;
@@ -302 +302 @@
 
 #ifdef X11_FULLSCREEN
         if ((flags & VOFLAG_FULLSCREEN) || (flags & VOFLAG_SWSCALE))
-            aspect(&d_width, &d_height, A_ZOOM);
+            aspect((int *)&d_width, (int *)&d_height, A_ZOOM);
 #endif
         dwidth = d_width;
         dheight = d_height;

libvo/x11_common.c

@@ -1036 +1036 @@
                     Window win;
 
                     XGetGeometry(mydisplay, vo_window, &root, &foo, &foo,
-                                 &foo /*width */ , &foo /*height */ , &foo,
-                                 &foo);
+                                 (unsigned int *)&foo /*width */ ,(unsigned int *) &foo /*height */ ,(unsigned int *) &foo,
+                                 (unsigned int *)&foo);
                     XTranslateCoordinates(mydisplay, vo_window, root, 0, 0,
                                           &vo_dx, &vo_dy, &win);
                 }

loader/pe_image.c

@@ -312 +312 @@
                 } else {                
                     pe_name = (PIMAGE_IMPORT_BY_NAME)RVA(import_list->u1.AddressOfData);
 //                  TRACE("--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint);
-                    thunk_list->u1.Function=LookupExternalByName(name, pe_name->Name);
+                    thunk_list->u1.Function=LookupExternalByName(name, (char *)pe_name->Name);
                 }
                 import_list++;
                 thunk_list++;
@@ -333 +333 @@
                     TRACE("--- %s %s.%d\n",
                                   pe_name->Name,name,pe_name->Hint);
                     thunk_list->u1.Function=LookupExternalByName(
-                      name, pe_name->Name);
+                      name, (char *)pe_name->Name);
                 }
                 thunk_list++;
             }

loader/win32.c

@@ -2289 +2289 @@
 static int WINAPI expGetModuleFileNameA(int module, char* s, int len)
 {
     WINE_MODREF *mr;
-    int result;
+    unsigned int result;
     //printf("File name of module %X (%s) requested\n", module, s);
 
     if (module == 0 && len >= 12)

mencoder.c

@@ -321 +321 @@
                 if(len>sh_audio->a_out_buffer_size) len=sh_audio->a_out_buffer_size;
                 if(len>sh_audio->a_out_buffer_len){
                     int ret=decode_audio(sh_audio,
-                        &sh_audio->a_out_buffer[sh_audio->a_out_buffer_len],
+                        (unsigned char *)&sh_audio->a_out_buffer[sh_audio->a_out_buffer_len],
                         len-sh_audio->a_out_buffer_len,
                         sh_audio->a_out_buffer_size-sh_audio->a_out_buffer_len);
                     if(ret>0) sh_audio->a_out_buffer_len+=ret; else at_eof=1;
@@ -562 +562 @@
 
 #ifdef USE_DVDREAD
 if(stream->type==STREAMTYPE_DVD){
-  if(audio_lang && audio_id==-1) audio_id=dvd_aid_from_lang(stream,audio_lang);
-  if(dvdsub_lang && dvdsub_id==-2) dvdsub_id=dvd_sid_from_lang(stream,dvdsub_lang);
+  if(audio_lang && audio_id==-1) audio_id=dvd_aid_from_lang(stream,(unsigned char *)audio_lang);
+  if(dvdsub_lang && dvdsub_id==-2) dvdsub_id=dvd_sid_from_lang(stream,(unsigned char *)dvdsub_lang);
 }
 #endif
 
@@ -670 +670 @@
 if (vobsub_out) {
     unsigned int palette[16], width, height;
     unsigned char tmp[3] = { 0, 0, 0 };
-    if (spudec_ifo && vobsub_parse_ifo(NULL,spudec_ifo, palette, &width, &height, 1, dvdsub_id, tmp) >= 0)
+    if (spudec_ifo && vobsub_parse_ifo(NULL,spudec_ifo, palette, &width, &height, 1, dvdsub_id, (char *)tmp) >= 0)
         vobsub_writer = vobsub_out_open(vobsub_out, palette, sh_video->disp_w, sh_video->disp_h,
                                         vobsub_out_id?vobsub_out_id:(char *)tmp, vobsub_out_index);
 #ifdef USE_DVDREAD

mp3lib/sr1.c

@@ -178 +178 @@
 }
 
 LOCAL int stream_head_read(unsigned char *hbuf,unsigned long *newhead){
-  if(mp3_read(hbuf,4) != 4) return FALSE;
+  if(mp3_read((char *)hbuf,4) != 4) return FALSE;
 #if defined(CAN_COMPILE_X86_ASM)
   *newhead = bswap_32(*((unsigned long *)hbuf));
 #else
@@ -197 +197 @@
 
 LOCAL int stream_head_shift(unsigned char *hbuf,unsigned long *head){
   *((unsigned long *)hbuf) >>= 8;
-  if(mp3_read(hbuf+3,1) != 1) return 0;
+  if(mp3_read((char *)hbuf+3,1) != 1) return 0;
   *head <<= 8;
   *head |= hbuf[3];
   return 1;
@@ -299 +299 @@
   bsbuf = bsspace[bsnum]+512;
   bsnum = (bsnum + 1) & 1;
 
-  if( mp3_read(bsbuf,size) != size) return 0; // broken frame
+  if( mp3_read((char *)bsbuf,size) != size) return 0; // broken frame
 
   bitindex = 0;
   wordpointer = (unsigned char *) bsbuf;

mplayer.c

@@ -1845 +1845 @@
       /* try from ~/.mplayer/sub */
       if(!vo_vobsub && (psub = get_path( "sub/" ))) {
           char *bname;
-          int l;
+          unsigned int l;
           bname = strrchr(buf,'/');
 #ifdef WIN32
           if(!bname) bname = strrchr(buf,'\\');
@@ -1945 +1945 @@
 #ifdef USE_DVDREAD
 if(stream->type==STREAMTYPE_DVD){
   current_module="dvd lang->id";
-  if(audio_id==-1) audio_id=dvd_aid_from_lang(stream,audio_lang);
+  if(audio_id==-1) audio_id=dvd_aid_from_lang(stream,(unsigned char *)audio_lang);
   if(dvdsub_lang && dvdsub_id==-2) dvdsub_id=-1;
-  if(dvdsub_lang && dvdsub_id==-1) dvdsub_id=dvd_sid_from_lang(stream,dvdsub_lang);
+  if(dvdsub_lang && dvdsub_id==-1) dvdsub_id=dvd_sid_from_lang(stream,(unsigned char *)dvdsub_lang);
   // setup global sub numbering
   global_sub_indices[SUB_SOURCE_DEMUX] = global_sub_size; // the global # of the first demux-specific sub.
   global_sub_size += dvd_number_of_subs(stream);
@@ -1990 +1990 @@
     
     mp_msg(MSGT_CPLAYER,MSGL_V,"Adding file %s to element entry.\n",playlist_entry);
 
-    bname=mp_basename(playlist_entry);
-    if ((strlen(bname)>10) && !strncmp(bname,"qt",2) && !strncmp(bname+3,"gateQT",6))
+    bname=mp_basename((char *)playlist_entry);
+    if ((strlen((char *)bname)>10) && !strncmp(bname,"qt",2) && !strncmp(bname+3,"gateQT",6))
         continue;
 
     if (!strncmp(bname,mp_basename(filename),strlen(bname))) // ignoring self-reference
         continue;
 
-    entry = play_tree_new();
+   entry = play_tree_new();
     
-    if (filename && !strcmp(mp_basename(playlist_entry),playlist_entry)) // add reference path of current file
+    if (filename && !strcmp(mp_basename((char *)playlist_entry),(char *)playlist_entry)) // add reference path of current file
     {
-      temp=malloc((strlen(filename)-strlen(mp_basename(filename))+strlen(playlist_entry)+1)*sizeof(char));
+      temp=malloc((strlen(filename)-strlen(mp_basename(filename))+strlen((char *)playlist_entry)+1)*sizeof(char));
       if (temp)
       {
-        strncpy(temp, filename, strlen(filename)-strlen(mp_basename(filename)));
+        strncpy(temp, filename, strlen(filename)-strlen((char *)mp_basename((char *)filename)));
         temp[strlen(filename)-strlen(mp_basename(filename))]='\0';
-        strcat(temp, playlist_entry);
+        strcat(temp, (char *)playlist_entry);
         play_tree_add_file(entry,temp);
         mp_msg(MSGT_CPLAYER,MSGL_V,"Resolving reference to %s.\n",temp);
         free(temp);
       }
     }
     else
-      play_tree_add_file(entry,playlist_entry);
+      play_tree_add_file(entry,(char *)playlist_entry);
     
     if(!list)
       list = entry;
@@ -2610 +2610 @@
   t=GetTimer();
   while(sh_audio->a_out_buffer_len<playsize &&
         (!d_audio->eof || sh_audio->a_in_buffer_len > 0 || sh_audio->a_buffer_len > 0)){
-    int ret=decode_audio(sh_audio,&sh_audio->a_out_buffer[sh_audio->a_out_buffer_len],
+    int ret=decode_audio(sh_audio,(unsigned char *)&sh_audio->a_out_buffer[sh_audio->a_out_buffer_len],
         playsize-sh_audio->a_out_buffer_len,sh_audio->a_out_buffer_size-sh_audio->a_out_buffer_len);
     if(ret<=0) { // EOF?
       if (d_audio->eof)
@@ -3013 +3013 @@
         // take the first and the last char out
         if(use_term_osd) {
           char msg[128] = MSGTR_Paused;
-          int mlen = strlen(msg);
+          unsigned int mlen = strlen(msg);
           msg[mlen-1] = '\0';
           set_osd_msg(OSD_MSG_PAUSE,1,0,"%s",msg+1);
           update_osd_msg();

playtreeparser.c

@@ -69 +69 @@
     }
     
     if(p->buffer_size - p->buffer_end > 1 && ! p->stream->eof) {
-      r = stream_read(p->stream,p->buffer + p->buffer_end,p->buffer_size - p->buffer_end - 1);
+      r = stream_read(p->stream,(unsigned char*)(p->buffer + p->buffer_end),p->buffer_size - p->buffer_end - 1);
       if(r > 0) {
         p->buffer_end += r;
         p->buffer[p->buffer_end] = '\0';

postproc/swscale_template.c

@@ -2260 +2260 @@
     if(!(flags&SWS_FAST_BILINEAR))
 #endif
     {
-        RENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);
+        RENAME(hScale)((int16_t *)dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);
     }
     else // Fast Bilinear upscale / crap downscale
     {
@@ -2444 +2444 @@
     if(!(flags&SWS_FAST_BILINEAR))
 #endif
     {
-        RENAME(hScale)(dst     , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
-        RENAME(hScale)(dst+2048, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
+        RENAME(hScale)((int16_t *)dst     , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
+        RENAME(hScale)((int16_t *)dst+2048, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
     }
     else // Fast Bilinear upscale / crap downscale
     {
@@ -2714 +2714 @@
                                 ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH)
                                 ASSERT(lastInLumBuf + 1 - srcSliceY >= 0)
 //                              printf("%d %d\n", lumBufIndex, vLumBufSize);
-                                RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,
+                                RENAME(hyscale)((uint16_t *)lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,
                                                 flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,
                                                 funnyYCode, c->srcFormat, formatConvBuffer, 
                                                 c->lumMmx2Filter, c->lumMmx2FilterPos);
@@ -2731 +2731 @@
                                 //FIXME replace parameters through context struct (some at least)
 
                                 if(!(isGray(srcFormat) || isGray(dstFormat)))
-                                        RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,
+                                        RENAME(hcscale)((uint16_t *)chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,
                                                 flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,
                                                 funnyUVCode, c->srcFormat, formatConvBuffer, 
                                                 c->chrMmx2Filter, c->chrMmx2FilterPos);
@@ -2756 +2756 @@
                                 ASSERT(lumBufIndex < 2*vLumBufSize)
                                 ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH)
                                 ASSERT(lastInLumBuf + 1 - srcSliceY >= 0)
-                                RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,
+                                RENAME(hyscale)((uint16_t *)lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,
                                                 flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,
                                                 funnyYCode, c->srcFormat, formatConvBuffer, 
                                                 c->lumMmx2Filter, c->lumMmx2FilterPos);
@@ -2772 +2772 @@
                                 ASSERT(lastInChrBuf + 1 - chrSrcSliceY >= 0)
 
                                 if(!(isGray(srcFormat) || isGray(dstFormat)))
-                                        RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,
+                                        RENAME(hcscale)((uint16_t *)chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,
                                                 flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,
                                                 funnyUVCode, c->srcFormat, formatConvBuffer, 
                                                 c->chrMmx2Filter, c->chrMmx2FilterPos);
@@ -2844 +2844 @@
                         if(vLumFilterSize == 1 && vChrFilterSize == 2) //Unscaled RGB
                         {
                                 int chrAlpha= vChrFilter[2*dstY+1];
-                                RENAME(yuv2packed1)(c, *lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),
+                                RENAME(yuv2packed1)(c, (uint16_t *)*lumSrcPtr, (uint16_t *)*chrSrcPtr, (uint16_t *)*(chrSrcPtr+1),
                                                  dest, dstW, chrAlpha, dstFormat, flags, dstY);
                         }
                         else if(vLumFilterSize == 2 && vChrFilterSize == 2) //BiLinear Upscale RGB
                         {
                                 int lumAlpha= vLumFilter[2*dstY+1];
                                 int chrAlpha= vChrFilter[2*dstY+1];
-                                RENAME(yuv2packed2)(c, *lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),
+                                RENAME(yuv2packed2)(c, (uint16_t *)*lumSrcPtr, (uint16_t *)*(lumSrcPtr+1), (uint16_t *)*chrSrcPtr, (uint16_t *)*(chrSrcPtr+1),
                                                  dest, dstW, lumAlpha, chrAlpha, dstY);
                         }
                         else //General RGB

vidix/drivers/pm3_vid.c

@@ -283 +283 @@
         frames[i] = (base0 + info->offsets[i]) >> 1;
     }
 
-    compute_scale_factor(&src_w, &drw_w, &shrink, &zoom);
+    compute_scale_factor(&src_w, &drw_w, (unsigned int *)&shrink, (unsigned int *)&zoom);
 
     WRITE_REG(PM3VideoOverlayBase0, base0 >> 1);
     WRITE_REG(PM3VideoOverlayStride, PM3VideoOverlayStride_STRIDE(pitch));

vidix/drivers/unichrome_vid.c

@@ -800 +800 @@
   zoom = 0;
   mini = 0;
   uc_ovl_map_vzoom (src_h, drw_h, &zoom, &mini);
-  uc_ovl_map_hzoom (src_w, drw_w, &zoom, &mini, &falign, &dcount);
+  uc_ovl_map_hzoom (src_w, drw_w, &zoom, &mini, (int *)&falign, (int *)&dcount);
   qwfetch = uc_ovl_map_qwfetch (info->fourcc, src_w);
 
   /* Calculate buffer sizes */

vobsub.c

@@ -1216 +1216 @@
 }
 
 int
-vobsub_set_from_lang(void *vobhandle, unsigned char * lang)
+vobsub_set_from_lang(void *vobhandle, char * lang)
 {
-    int i;
+    unsigned int i;
     vobsub_t *vob= (vobsub_t *) vobhandle;
     while(lang && strlen(lang) >= 2){
       for(i=0; i < vob->spu_streams_size; i++)