[FFmpeg-devel] [PATCH 1/5] Add av_ prefix to bswap macros

Mans Rullgard mans
Sat Jul 10 14:22:31 CEST 2010


---
 libavcodec/4xm.c               |   12 ++++----
 libavcodec/8bps.c              |    2 +-
 libavcodec/aac_parser.c        |    2 +-
 libavcodec/ac3_parser.c        |    2 +-
 libavcodec/ac3enc.c            |    4 +-
 libavcodec/alsdec.c            |    4 +-
 libavcodec/asv1.c              |    4 +-
 libavcodec/atrac3.c            |    2 +-
 libavcodec/bmp.c               |    2 +-
 libavcodec/cook.c              |    4 +-
 libavcodec/dca.c               |    2 +-
 libavcodec/dsputil.c           |   18 +++++-----
 libavcodec/eamad.c             |    2 +-
 libavcodec/flacenc.c           |    4 +-
 libavcodec/get_bits.h          |    4 +-
 libavcodec/iff.c               |   32 ++++++++++----------
 libavcodec/imc.c               |    2 +-
 libavcodec/indeo3.c            |   66 ++++++++++++++++++++--------------------
 libavcodec/mjpegdec.c          |    4 +-
 libavcodec/pngdec.c            |    2 +-
 libavcodec/pngenc.c            |    2 +-
 libavcodec/pnmdec.c            |    2 +-
 libavcodec/put_bits.h          |   10 +++---
 libavcodec/r210dec.c           |    2 +-
 libavcodec/shorten.c           |    4 +-
 libavcodec/smacker.c           |    2 +-
 libavcodec/tta.c               |    2 +-
 libavcodec/v210dec.c           |    6 ++--
 libavcodec/v210x.c             |    8 ++--
 libavformat/asfcrypt.c         |    2 +-
 libavformat/asfdec.c           |    2 +-
 libavformat/avidec.c           |    2 +-
 libavformat/electronicarts.c   |    2 +-
 libavformat/mov.c              |    2 +-
 libavformat/mpegtsenc.c        |    2 +-
 libavformat/mtv.c              |    2 +-
 libavformat/nutdec.c           |    2 +-
 libavformat/smacker.c          |    8 ++--
 libavformat/sol.c              |    2 +-
 libavformat/spdif.c            |   18 +++++-----
 libavutil/arm/bswap.h          |   16 +++++-----
 libavutil/avr32/bswap.h        |    8 ++--
 libavutil/avr32/intreadwrite.h |    4 +-
 libavutil/bfin/bswap.h         |    4 +-
 libavutil/bswap.h              |   64 +++++++++++++++++++-------------------
 libavutil/crc.c                |    6 ++--
 libavutil/des.c                |    8 ++--
 libavutil/intreadwrite.h       |    8 ++--
 libavutil/md5.c                |    6 ++--
 libavutil/sh4/bswap.h          |    8 ++--
 libavutil/sha.c                |    6 ++--
 libavutil/x86/bswap.h          |   12 ++++----
 52 files changed, 203 insertions(+), 203 deletions(-)

diff --git a/libavcodec/4xm.c b/libavcodec/4xm.c
index 2198503..b6a97aa 100644
--- a/libavcodec/4xm.c
+++ b/libavcodec/4xm.c
@@ -333,16 +333,16 @@ static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int lo
             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
             return;
         }
-        mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
+        mcdc(dst, src, log2w, h, stride, 1, av_le2ne16(*f->wordstream++));
     }else if(code == 5){
-        mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
+        mcdc(dst, src, log2w, h, stride, 0, av_le2ne16(*f->wordstream++));
     }else if(code == 6){
         if(log2w){
-            dst[0] = le2me_16(*f->wordstream++);
-            dst[1] = le2me_16(*f->wordstream++);
+            dst[0] = av_le2ne16(*f->wordstream++);
+            dst[1] = av_le2ne16(*f->wordstream++);
         }else{
-            dst[0     ] = le2me_16(*f->wordstream++);
-            dst[stride] = le2me_16(*f->wordstream++);
+            dst[0     ] = av_le2ne16(*f->wordstream++);
+            dst[stride] = av_le2ne16(*f->wordstream++);
         }
     }
 }
diff --git a/libavcodec/8bps.c b/libavcodec/8bps.c
index ff57955..292c739 100644
--- a/libavcodec/8bps.c
+++ b/libavcodec/8bps.c
@@ -100,7 +100,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
                 for(row = 0; row < height; row++) {
                         pixptr = c->pic.data[0] + row * c->pic.linesize[0] + planemap[p];
                         pixptr_end = pixptr + c->pic.linesize[0];
-                        dlen = be2me_16(*(const unsigned short *)(lp+row*2));
+                        dlen = av_be2ne16(*(const unsigned short *)(lp+row*2));
                         /* Decode a row of this plane */
                         while(dlen > 0) {
                                 if(dp + 1 >= buf+buf_size) return -1;
diff --git a/libavcodec/aac_parser.c b/libavcodec/aac_parser.c
index 30ce04d..23ac8ce 100644
--- a/libavcodec/aac_parser.c
+++ b/libavcodec/aac_parser.c
@@ -80,7 +80,7 @@ static int aac_sync(uint64_t state, AACAC3ParseContext *hdr_info,
         uint8_t  u8[8];
     } tmp;
 
-    tmp.u64 = be2me_64(state);
+    tmp.u64 = av_be2ne64(state);
     init_get_bits(&bits, tmp.u8+8-AAC_ADTS_HEADER_SIZE, AAC_ADTS_HEADER_SIZE * 8);
 
     if ((size = ff_aac_parse_header(&bits, &hdr)) < 0)
diff --git a/libavcodec/ac3_parser.c b/libavcodec/ac3_parser.c
index 6cd666b..b844ec3 100644
--- a/libavcodec/ac3_parser.c
+++ b/libavcodec/ac3_parser.c
@@ -164,7 +164,7 @@ static int ac3_sync(uint64_t state, AACAC3ParseContext *hdr_info,
     union {
         uint64_t u64;
         uint8_t  u8[8];
-    } tmp = { be2me_64(state) };
+    } tmp = { av_be2ne64(state) };
     AC3HeaderInfo hdr;
     GetBitContext gbc;
 
diff --git a/libavcodec/ac3enc.c b/libavcodec/ac3enc.c
index e30e1bd..edae9a9 100644
--- a/libavcodec/ac3enc.c
+++ b/libavcodec/ac3enc.c
@@ -1161,14 +1161,14 @@ static int output_frame_end(AC3EncodeContext *s)
     /* Now we must compute both crcs : this is not so easy for crc1
        because it is at the beginning of the data... */
     frame_size_58 = (frame_size >> 1) + (frame_size >> 3);
-    crc1 = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
+    crc1 = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
                            frame + 4, 2 * frame_size_58 - 4));
     /* XXX: could precompute crc_inv */
     crc_inv = pow_poly((CRC16_POLY >> 1), (16 * frame_size_58) - 16, CRC16_POLY);
     crc1 = mul_poly(crc_inv, crc1, CRC16_POLY);
     AV_WB16(frame+2,crc1);
 
-    crc2 = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
+    crc2 = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
                            frame + 2 * frame_size_58,
                            (frame_size - frame_size_58) * 2 - 2));
     AV_WB16(frame+2*frame_size-2,crc2);
diff --git a/libavcodec/alsdec.c b/libavcodec/alsdec.c
index 7bf574a..bbcbb70 100644
--- a/libavcodec/alsdec.c
+++ b/libavcodec/alsdec.c
@@ -1464,7 +1464,7 @@ static int decode_frame(AVCodecContext *avctx,
                 int32_t v;
 
                 if (swap)
-                    v = bswap_32(src[sample]);
+                    v = av_bswap32(src[sample]);
                 else
                     v = src[sample];
                 if (!HAVE_BIGENDIAN)
@@ -1482,7 +1482,7 @@ static int decode_frame(AVCodecContext *avctx,
                     for (sample = 0;
                          sample < ctx->cur_frame_length * avctx->channels;
                          sample++)
-                        *dest++ = bswap_16(src[sample]);
+                        *dest++ = av_bswap16(src[sample]);
                 } else {
                     ctx->dsp.bswap_buf((uint32_t*)ctx->crc_buffer, data,
                                        ctx->cur_frame_length * avctx->channels);
diff --git a/libavcodec/asv1.c b/libavcodec/asv1.c
index 211a13f..6b1a093 100644
--- a/libavcodec/asv1.c
+++ b/libavcodec/asv1.c
@@ -588,8 +588,8 @@ static av_cold int encode_init(AVCodecContext *avctx){
 
     avctx->extradata= av_mallocz(8);
     avctx->extradata_size=8;
-    ((uint32_t*)avctx->extradata)[0]= le2me_32(a->inv_qscale);
-    ((uint32_t*)avctx->extradata)[1]= le2me_32(AV_RL32("ASUS"));
+    ((uint32_t*)avctx->extradata)[0]= av_le2ne32(a->inv_qscale);
+    ((uint32_t*)avctx->extradata)[1]= av_le2ne32(AV_RL32("ASUS"));
 
     for(i=0; i<64; i++){
         int q= 32*scale*ff_mpeg1_default_intra_matrix[i];
diff --git a/libavcodec/atrac3.c b/libavcodec/atrac3.c
index 150f201..c29fb19 100644
--- a/libavcodec/atrac3.c
+++ b/libavcodec/atrac3.c
@@ -179,7 +179,7 @@ static int decode_bytes(const uint8_t* inbuffer, uint8_t* out, int bytes){
 
     off = (intptr_t)inbuffer & 3;
     buf = (const uint32_t*) (inbuffer - off);
-    c = be2me_32((0x537F6103 >> (off*8)) | (0x537F6103 << (32-(off*8))));
+    c = av_be2ne32((0x537F6103 >> (off*8)) | (0x537F6103 << (32-(off*8))));
     bytes += 3 + off;
     for (i = 0; i < bytes/4; i++)
         obuf[i] = c ^ buf[i];
diff --git a/libavcodec/bmp.c b/libavcodec/bmp.c
index 623a8a9..270452f 100644
--- a/libavcodec/bmp.c
+++ b/libavcodec/bmp.c
@@ -290,7 +290,7 @@ static int bmp_decode_frame(AVCodecContext *avctx,
                 uint16_t *dst = (uint16_t *) ptr;
 
                 for(j = 0; j < avctx->width; j++)
-                    *dst++ = le2me_16(*src++);
+                    *dst++ = av_le2ne16(*src++);
 
                 buf += n;
                 ptr += linesize;
diff --git a/libavcodec/cook.c b/libavcodec/cook.c
index 0dd1d48..b7e2ef1 100644
--- a/libavcodec/cook.c
+++ b/libavcodec/cook.c
@@ -316,12 +316,12 @@ static inline int decode_bytes(const uint8_t* inbuffer, uint8_t* out, int bytes)
     /* FIXME: 64 bit platforms would be able to do 64 bits at a time.
      * I'm too lazy though, should be something like
      * for(i=0 ; i<bitamount/64 ; i++)
-     *     (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);
+     *     (int64_t)out[i] = 0x37c511f237c511f2^av_be2ne64(int64_t)in[i]);
      * Buffer alignment needs to be checked. */
 
     off = (intptr_t)inbuffer & 3;
     buf = (const uint32_t*) (inbuffer - off);
-    c = be2me_32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));
+    c = av_be2ne32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));
     bytes += 3 + off;
     for (i = 0; i < bytes/4; i++)
         obuf[i] = c ^ buf[i];
diff --git a/libavcodec/dca.c b/libavcodec/dca.c
index 4b232c7..7deb284 100644
--- a/libavcodec/dca.c
+++ b/libavcodec/dca.c
@@ -1230,7 +1230,7 @@ static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * ds
         return src_size;
     case DCA_MARKER_RAW_LE:
         for (i = 0; i < (src_size + 1) >> 1; i++)
-            *sdst++ = bswap_16(*ssrc++);
+            *sdst++ = av_bswap16(*ssrc++);
         return src_size;
     case DCA_MARKER_14B_BE:
     case DCA_MARKER_14B_LE:
diff --git a/libavcodec/dsputil.c b/libavcodec/dsputil.c
index eb9e1ad..44fcf59 100644
--- a/libavcodec/dsputil.c
+++ b/libavcodec/dsputil.c
@@ -247,17 +247,17 @@ static void bswap_buf(uint32_t *dst, const uint32_t *src, int w){
     int i;
 
     for(i=0; i+8<=w; i+=8){
-        dst[i+0]= bswap_32(src[i+0]);
-        dst[i+1]= bswap_32(src[i+1]);
-        dst[i+2]= bswap_32(src[i+2]);
-        dst[i+3]= bswap_32(src[i+3]);
-        dst[i+4]= bswap_32(src[i+4]);
-        dst[i+5]= bswap_32(src[i+5]);
-        dst[i+6]= bswap_32(src[i+6]);
-        dst[i+7]= bswap_32(src[i+7]);
+        dst[i+0]= av_bswap32(src[i+0]);
+        dst[i+1]= av_bswap32(src[i+1]);
+        dst[i+2]= av_bswap32(src[i+2]);
+        dst[i+3]= av_bswap32(src[i+3]);
+        dst[i+4]= av_bswap32(src[i+4]);
+        dst[i+5]= av_bswap32(src[i+5]);
+        dst[i+6]= av_bswap32(src[i+6]);
+        dst[i+7]= av_bswap32(src[i+7]);
     }
     for(;i<w; i++){
-        dst[i+0]= bswap_32(src[i+0]);
+        dst[i+0]= av_bswap32(src[i+0]);
     }
 }
 
diff --git a/libavcodec/eamad.c b/libavcodec/eamad.c
index 8fc5ef1..3077c08 100644
--- a/libavcodec/eamad.c
+++ b/libavcodec/eamad.c
@@ -53,7 +53,7 @@ static void bswap16_buf(uint16_t *dst, const uint16_t *src, int count)
 {
     int i;
     for (i=0; i<count; i++)
-        dst[i] = bswap_16(src[i]);
+        dst[i] = av_bswap16(src[i]);
 }
 
 static av_cold int decode_init(AVCodecContext *avctx)
diff --git a/libavcodec/flacenc.c b/libavcodec/flacenc.c
index ebec6f6..fa05b7d 100644
--- a/libavcodec/flacenc.c
+++ b/libavcodec/flacenc.c
@@ -1153,7 +1153,7 @@ static void output_frame_footer(FlacEncodeContext *s)
 {
     int crc;
     flush_put_bits(&s->pb);
-    crc = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
+    crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
                           s->pb.buf, put_bits_count(&s->pb)>>3));
     put_bits(&s->pb, 16, crc);
     flush_put_bits(&s->pb);
@@ -1164,7 +1164,7 @@ static void update_md5_sum(FlacEncodeContext *s, int16_t *samples)
 #if HAVE_BIGENDIAN
     int i;
     for(i = 0; i < s->frame.blocksize*s->channels; i++) {
-        int16_t smp = le2me_16(samples[i]);
+        int16_t smp = av_le2ne16(samples[i]);
         av_md5_update(s->md5ctx, (uint8_t *)&smp, 2);
     }
 #else
diff --git a/libavcodec/get_bits.h b/libavcodec/get_bits.h
index 556f542..f4b3646 100644
--- a/libavcodec/get_bits.h
+++ b/libavcodec/get_bits.h
@@ -267,7 +267,7 @@ static inline void skip_bits_long(GetBitContext *s, int n){
 
 #   define UPDATE_CACHE(name, gb)\
     if(name##_bit_count > 0){\
-        const uint32_t next= be2me_32( *name##_buffer_ptr );\
+        const uint32_t next= av_be2ne32( *name##_buffer_ptr );\
         name##_cache0 |= NEG_USR32(next,name##_bit_count);\
         name##_cache1 |= next<<name##_bit_count;\
         name##_buffer_ptr++;\
@@ -319,7 +319,7 @@ static inline void skip_bits_long(GetBitContext *s, int n){
     re_bit_count += n;
     re_buffer_ptr += re_bit_count>>5;
     re_bit_count &= 31;
-    re_cache0 = be2me_32( re_buffer_ptr[-1] ) << re_bit_count;
+    re_cache0 = av_be2ne32( re_buffer_ptr[-1] ) << re_bit_count;
     re_cache1 = 0;
     UPDATE_CACHE(re, s)
     CLOSE_READER(re, s)
diff --git a/libavcodec/iff.c b/libavcodec/iff.c
index b9ed560..2992cb4 100644
--- a/libavcodec/iff.c
+++ b/libavcodec/iff.c
@@ -38,22 +38,22 @@ typedef struct {
 } IffContext;
 
 #define LUT8_PART(plane, v)                             \
-    AV_LE2ME64C(UINT64_C(0x0000000)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x1000000)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x0010000)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x1010000)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x0000100)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x1000100)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x0010100)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x1010100)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x0000001)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x1000001)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x0010001)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x1010001)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x0000101)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x1000101)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x0010101)<<32 | v) << plane,  \
-    AV_LE2ME64C(UINT64_C(0x1010101)<<32 | v) << plane
+    AV_LE2NE64C(UINT64_C(0x0000000)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x1000000)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x0010000)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x1010000)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x0000100)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x1000100)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x0010100)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x1010100)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x0000001)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x1000001)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x0010001)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x1010001)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x0000101)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x1000101)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x0010101)<<32 | v) << plane,  \
+    AV_LE2NE64C(UINT64_C(0x1010101)<<32 | v) << plane
 
 #define LUT8(plane) {                           \
     LUT8_PART(plane, 0x0000000),                \
diff --git a/libavcodec/imc.c b/libavcodec/imc.c
index 2a420f5..a27e4b6 100644
--- a/libavcodec/imc.c
+++ b/libavcodec/imc.c
@@ -660,7 +660,7 @@ static int imc_decode_frame(AVCodecContext * avctx,
         return -1;
     }
     for(i = 0; i < IMC_BLOCK_SIZE / 2; i++)
-        buf16[i] = bswap_16(((const uint16_t*)buf)[i]);
+        buf16[i] = av_bswap16(((const uint16_t*)buf)[i]);
 
     init_get_bits(&q->gb, (const uint8_t*)buf16, IMC_BLOCK_SIZE * 8);
 
diff --git a/libavcodec/indeo3.c b/libavcodec/indeo3.c
index e5df32c..63d91da 100644
--- a/libavcodec/indeo3.c
+++ b/libavcodec/indeo3.c
@@ -359,14 +359,14 @@ static void iv_Decode_Chunk(Indeo3DecodeContext *s,
 
                             switch(correction_type_sp[0][k]) {
                             case 0:
-                                *cur_lp = le2me_32(((le2me_32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
+                                *cur_lp = av_le2ne32(((av_le2ne32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
                                 lp2++;
                                 break;
                             case 1:
-                                res = ((le2me_16(((unsigned short *)(ref_lp))[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;
-                                ((unsigned short *)cur_lp)[0] = le2me_16(res);
-                                res = ((le2me_16(((unsigned short *)(ref_lp))[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;
-                                ((unsigned short *)cur_lp)[1] = le2me_16(res);
+                                res = ((av_le2ne16(((unsigned short *)(ref_lp))[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;
+                                ((unsigned short *)cur_lp)[0] = av_le2ne16(res);
+                                res = ((av_le2ne16(((unsigned short *)(ref_lp))[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;
+                                ((unsigned short *)cur_lp)[1] = av_le2ne16(res);
                                 buf1++;
                                 lp2++;
                                 break;
@@ -462,19 +462,19 @@ static void iv_Decode_Chunk(Indeo3DecodeContext *s,
 
                             switch(correction_type_sp[lp2 & 0x01][k]) {
                             case 0:
-                                cur_lp[width_tbl[1]] = le2me_32(((le2me_32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
+                                cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
                                 if(lp2 > 0 || flag1 == 0 || strip->ypos != 0)
                                     cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
                                 else
-                                    cur_lp[0] = le2me_32(((le2me_32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
+                                    cur_lp[0] = av_le2ne32(((av_le2ne32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
                                 lp2++;
                                 break;
 
                             case 1:
-                                res = ((le2me_16(((unsigned short *)ref_lp)[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;
-                                ((unsigned short *)cur_lp)[width_tbl[2]] = le2me_16(res);
-                                res = ((le2me_16(((unsigned short *)ref_lp)[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;
-                                ((unsigned short *)cur_lp)[width_tbl[2]+1] = le2me_16(res);
+                                res = ((av_le2ne16(((unsigned short *)ref_lp)[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;
+                                ((unsigned short *)cur_lp)[width_tbl[2]] = av_le2ne16(res);
+                                res = ((av_le2ne16(((unsigned short *)ref_lp)[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;
+                                ((unsigned short *)cur_lp)[width_tbl[2]+1] = av_le2ne16(res);
 
                                 if(lp2 > 0 || flag1 == 0 || strip->ypos != 0)
                                     cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
@@ -591,8 +591,8 @@ static void iv_Decode_Chunk(Indeo3DecodeContext *s,
 
                                 switch(correction_type_sp[lp2 & 0x01][k]) {
                                 case 0:
-                                    cur_lp[width_tbl[1]] = le2me_32(((le2me_32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][k]) << 1);
-                                    cur_lp[width_tbl[1]+1] = le2me_32(((le2me_32(lv2) >> 1) + correctionhighorder_lp[lp2 & 0x01][k]) << 1);
+                                    cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][k]) << 1);
+                                    cur_lp[width_tbl[1]+1] = av_le2ne32(((av_le2ne32(lv2) >> 1) + correctionhighorder_lp[lp2 & 0x01][k]) << 1);
                                     if(lp2 > 0 || strip->ypos != 0 || flag1 == 0) {
                                         cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
                                         cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
@@ -604,8 +604,8 @@ static void iv_Decode_Chunk(Indeo3DecodeContext *s,
                                     break;
 
                                 case 1:
-                                    cur_lp[width_tbl[1]] = le2me_32(((le2me_32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][*buf1]) << 1);
-                                    cur_lp[width_tbl[1]+1] = le2me_32(((le2me_32(lv2) >> 1) + correctionloworder_lp[lp2 & 0x01][k]) << 1);
+                                    cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][*buf1]) << 1);
+                                    cur_lp[width_tbl[1]+1] = av_le2ne32(((av_le2ne32(lv2) >> 1) + correctionloworder_lp[lp2 & 0x01][k]) << 1);
                                     if(lp2 > 0 || strip->ypos != 0 || flag1 == 0) {
                                         cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
                                         cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
@@ -748,20 +748,20 @@ static void iv_Decode_Chunk(Indeo3DecodeContext *s,
                                 case 0:
                                     lv1 = correctionloworder_lp[lp2 & 0x01][k];
                                     lv2 = correctionhighorder_lp[lp2 & 0x01][k];
-                                    cur_lp[0] = le2me_32(((le2me_32(ref_lp[0]) >> 1) + lv1) << 1);
-                                    cur_lp[1] = le2me_32(((le2me_32(ref_lp[1]) >> 1) + lv2) << 1);
-                                    cur_lp[width_tbl[1]] = le2me_32(((le2me_32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);
-                                    cur_lp[width_tbl[1]+1] = le2me_32(((le2me_32(ref_lp[width_tbl[1]+1]) >> 1) + lv2) << 1);
+                                    cur_lp[0] = av_le2ne32(((av_le2ne32(ref_lp[0]) >> 1) + lv1) << 1);
+                                    cur_lp[1] = av_le2ne32(((av_le2ne32(ref_lp[1]) >> 1) + lv2) << 1);
+                                    cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);
+                                    cur_lp[width_tbl[1]+1] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]+1]) >> 1) + lv2) << 1);
                                     lp2++;
                                     break;
 
                                 case 1:
                                     lv1 = correctionloworder_lp[lp2 & 0x01][*buf1++];
                                     lv2 = correctionloworder_lp[lp2 & 0x01][k];
-                                    cur_lp[0] = le2me_32(((le2me_32(ref_lp[0]) >> 1) + lv1) << 1);
-                                    cur_lp[1] = le2me_32(((le2me_32(ref_lp[1]) >> 1) + lv2) << 1);
-                                    cur_lp[width_tbl[1]] = le2me_32(((le2me_32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);
-                                    cur_lp[width_tbl[1]+1] = le2me_32(((le2me_32(ref_lp[width_tbl[1]+1]) >> 1) + lv2) << 1);
+                                    cur_lp[0] = av_le2ne32(((av_le2ne32(ref_lp[0]) >> 1) + lv1) << 1);
+                                    cur_lp[1] = av_le2ne32(((av_le2ne32(ref_lp[1]) >> 1) + lv2) << 1);
+                                    cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);
+                                    cur_lp[width_tbl[1]+1] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]+1]) >> 1) + lv2) << 1);
                                     lp2++;
                                     break;
 
@@ -849,22 +849,22 @@ static void iv_Decode_Chunk(Indeo3DecodeContext *s,
 
                             switch(correction_type_sp[lp2 & 0x01][k]) {
                             case 0:
-                                cur_lp[0] = le2me_32(((le2me_32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
-                                cur_lp[width_tbl[1]] = le2me_32(((le2me_32(ref_lp[width_tbl[1]]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
+                                cur_lp[0] = av_le2ne32(((av_le2ne32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
+                                cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
                                 lp2++;
                                 break;
 
                             case 1:
                                 lv1 = (unsigned short)(correction_lp[lp2 & 0x01][*buf1++]);
                                 lv2 = (unsigned short)(correction_lp[lp2 & 0x01][k]);
-                                res = (unsigned short)(((le2me_16(((unsigned short *)ref_lp)[0]) >> 1) + lv1) << 1);
-                                ((unsigned short *)cur_lp)[0] = le2me_16(res);
-                                res = (unsigned short)(((le2me_16(((unsigned short *)ref_lp)[1]) >> 1) + lv2) << 1);
-                                ((unsigned short *)cur_lp)[1] = le2me_16(res);
-                                res = (unsigned short)(((le2me_16(((unsigned short *)ref_lp)[width_tbl[2]]) >> 1) + lv1) << 1);
-                                ((unsigned short *)cur_lp)[width_tbl[2]] = le2me_16(res);
-                                res = (unsigned short)(((le2me_16(((unsigned short *)ref_lp)[width_tbl[2]+1]) >> 1) + lv2) << 1);
-                                ((unsigned short *)cur_lp)[width_tbl[2]+1] = le2me_16(res);
+                                res = (unsigned short)(((av_le2ne16(((unsigned short *)ref_lp)[0]) >> 1) + lv1) << 1);
+                                ((unsigned short *)cur_lp)[0] = av_le2ne16(res);
+                                res = (unsigned short)(((av_le2ne16(((unsigned short *)ref_lp)[1]) >> 1) + lv2) << 1);
+                                ((unsigned short *)cur_lp)[1] = av_le2ne16(res);
+                                res = (unsigned short)(((av_le2ne16(((unsigned short *)ref_lp)[width_tbl[2]]) >> 1) + lv1) << 1);
+                                ((unsigned short *)cur_lp)[width_tbl[2]] = av_le2ne16(res);
+                                res = (unsigned short)(((av_le2ne16(((unsigned short *)ref_lp)[width_tbl[2]+1]) >> 1) + lv2) << 1);
+                                ((unsigned short *)cur_lp)[width_tbl[2]+1] = av_le2ne16(res);
                                 lp2++;
                                 break;
 
diff --git a/libavcodec/mjpegdec.c b/libavcodec/mjpegdec.c
index 47f5a0e..8aff966 100644
--- a/libavcodec/mjpegdec.c
+++ b/libavcodec/mjpegdec.c
@@ -1027,7 +1027,7 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
         return -1;
 
     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
-    id = be2me_32(id);
+    id = av_be2ne32(id);
     len -= 6;
 
     if(s->avctx->debug & FF_DEBUG_STARTCODE){
@@ -1134,7 +1134,7 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
     if ((s->start_code == APP1) && (len > (0x28 - 8)))
     {
         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
-        id = be2me_32(id);
+        id = av_be2ne32(id);
         len -= 4;
         if (id == AV_RL32("mjpg")) /* Apple MJPEG-A */
         {
diff --git a/libavcodec/pngdec.c b/libavcodec/pngdec.c
index a00c284..037c5a0 100644
--- a/libavcodec/pngdec.c
+++ b/libavcodec/pngdec.c
@@ -429,7 +429,7 @@ static int decode_frame(AVCodecContext *avctx,
         if (length > 0x7fffffff)
             goto fail;
         tag32 = bytestream_get_be32(&s->bytestream);
-        tag = bswap_32(tag32);
+        tag = av_bswap32(tag32);
         dprintf(avctx, "png: tag=%c%c%c%c length=%u\n",
                 (tag & 0xff),
                 ((tag >> 8) & 0xff),
diff --git a/libavcodec/pngenc.c b/libavcodec/pngenc.c
index 615bcc4..d199b95 100644
--- a/libavcodec/pngenc.c
+++ b/libavcodec/pngenc.c
@@ -199,7 +199,7 @@ static void png_write_chunk(uint8_t **f, uint32_t tag,
     crc = crc32(0, Z_NULL, 0);
     AV_WL32(tagbuf, tag);
     crc = crc32(crc, tagbuf, 4);
-    bytestream_put_be32(f, bswap_32(tag));
+    bytestream_put_be32(f, av_bswap32(tag));
     if (length > 0) {
         crc = crc32(crc, buf, length);
         memcpy(*f, buf, length);
diff --git a/libavcodec/pnmdec.c b/libavcodec/pnmdec.c
index 4ccaa45..6bea93d 100644
--- a/libavcodec/pnmdec.c
+++ b/libavcodec/pnmdec.c
@@ -124,7 +124,7 @@ static int pnm_decode_frame(AVCodecContext *avctx, void *data,
             } else if (upgrade == 2) {
                 unsigned int j, v, f = (65535 * 32768 + s->maxval / 2) / s->maxval;
                 for (j = 0; j < n / 2; j++) {
-                    v = be2me_16(((uint16_t *)s->bytestream)[j]);
+                    v = av_be2ne16(((uint16_t *)s->bytestream)[j]);
                     ((uint16_t *)ptr)[j] = (v * f + 16384) >> 15;
                 }
             }
diff --git a/libavcodec/put_bits.h b/libavcodec/put_bits.h
index 44d81c1..d301d0a 100644
--- a/libavcodec/put_bits.h
+++ b/libavcodec/put_bits.h
@@ -168,7 +168,7 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
             AV_WL32(s->buf_ptr, bit_buf);
         } else
 #endif
-        *(uint32_t *)s->buf_ptr = le2me_32(bit_buf);
+        *(uint32_t *)s->buf_ptr = av_le2ne32(bit_buf);
         s->buf_ptr+=4;
         bit_buf = (bit_left==32)?0:value >> bit_left;
         bit_left+=32;
@@ -186,7 +186,7 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
             AV_WB32(s->buf_ptr, bit_buf);
         } else
 #endif
-        *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
+        *(uint32_t *)s->buf_ptr = av_be2ne32(bit_buf);
         //printf("bitbuf = %08x\n", bit_buf);
         s->buf_ptr+=4;
         bit_left+=32 - n;
@@ -224,8 +224,8 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
 
     value<<= 32-n;
 
-    ptr[0] |= be2me_32(value>>(index&31));
-    ptr[1]  = be2me_32(value<<(32-(index&31)));
+    ptr[0] |= av_be2ne32(value>>(index&31));
+    ptr[1]  = av_be2ne32(value<<(32-(index&31)));
 //if(n>24) printf("%d %d\n", n, value);
     index+= n;
     s->index= index;
@@ -252,7 +252,7 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
     int index= s->index;
     uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
 
-    ptr[0] |= be2me_32(value<<(32-n-(index&7) ));
+    ptr[0] |= av_be2ne32(value<<(32-n-(index&7) ));
     ptr[1] = 0;
 //if(n>24) printf("%d %d\n", n, value);
     index+= n;
diff --git a/libavcodec/r210dec.c b/libavcodec/r210dec.c
index 416f764..cf04070 100644
--- a/libavcodec/r210dec.c
+++ b/libavcodec/r210dec.c
@@ -61,7 +61,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
     for (h = 0; h < avctx->height; h++) {
         uint16_t *dst = (uint16_t *)dst_line;
         for (w = 0; w < avctx->width; w++) {
-            uint32_t pixel = be2me_32(*src++);
+            uint32_t pixel = av_be2ne32(*src++);
             uint16_t r, g, b;
             b =  pixel <<  6;
             g = (pixel >>  4) & 0xffc0;
diff --git a/libavcodec/shorten.c b/libavcodec/shorten.c
index 934da8e..213e5b3 100644
--- a/libavcodec/shorten.c
+++ b/libavcodec/shorten.c
@@ -184,12 +184,12 @@ static void init_offset(ShortenContext *s)
 
 static inline int get_le32(GetBitContext *gb)
 {
-    return bswap_32(get_bits_long(gb, 32));
+    return av_bswap32(get_bits_long(gb, 32));
 }
 
 static inline short get_le16(GetBitContext *gb)
 {
-    return bswap_16(get_bits_long(gb, 16));
+    return av_bswap16(get_bits_long(gb, 16));
 }
 
 static int decode_wave_header(AVCodecContext *avctx, uint8_t *header, int header_size)
diff --git a/libavcodec/smacker.c b/libavcodec/smacker.c
index 1d85f68..ac2f76b 100644
--- a/libavcodec/smacker.c
+++ b/libavcodec/smacker.c
@@ -618,7 +618,7 @@ static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
     }
     if(bits) { //decode 16-bit data
         for(i = stereo; i >= 0; i--)
-            pred[i] = bswap_16(get_bits(&gb, 16));
+            pred[i] = av_bswap16(get_bits(&gb, 16));
         for(i = 0; i < stereo; i++)
             *samples++ = pred[i];
         for(i = 0; i < unp_size / 2; i++) {
diff --git a/libavcodec/tta.c b/libavcodec/tta.c
index 9014553..0a4c69a 100644
--- a/libavcodec/tta.c
+++ b/libavcodec/tta.c
@@ -221,7 +221,7 @@ static av_cold int tta_decode_init(AVCodecContext * avctx)
     {
         /* signature */
         skip_bits(&s->gb, 32);
-//        if (get_bits_long(&s->gb, 32) != bswap_32(AV_RL32("TTA1"))) {
+//        if (get_bits_long(&s->gb, 32) != av_bswap32(AV_RL32("TTA1"))) {
 //            av_log(s->avctx, AV_LOG_ERROR, "Missing magic\n");
 //            return -1;
 //        }
diff --git a/libavcodec/v210dec.c b/libavcodec/v210dec.c
index a1a0827..61e9566 100644
--- a/libavcodec/v210dec.c
+++ b/libavcodec/v210dec.c
@@ -68,7 +68,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 
 #define READ_PIXELS(a, b, c)         \
     do {                             \
-        val  = le2me_32(*src++);     \
+        val  = av_le2ne32(*src++);     \
         *a++ =  val <<  6;           \
         *b++ = (val >>  4) & 0xFFC0; \
         *c++ = (val >> 14) & 0xFFC0; \
@@ -86,14 +86,14 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
         if (w < avctx->width - 1) {
             READ_PIXELS(u, y, v);
 
-            val  = le2me_32(*src++);
+            val  = av_le2ne32(*src++);
             *y++ =  val <<  6;
         }
         if (w < avctx->width - 3) {
             *u++ = (val >>  4) & 0xFFC0;
             *y++ = (val >> 14) & 0xFFC0;
 
-            val  = le2me_32(*src++);
+            val  = av_le2ne32(*src++);
             *v++ =  val <<  6;
             *y++ = (val >>  4) & 0xFFC0;
         }
diff --git a/libavcodec/v210x.c b/libavcodec/v210x.c
index d869d64..6b93a05 100644
--- a/libavcodec/v210x.c
+++ b/libavcodec/v210x.c
@@ -67,12 +67,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
     pic->key_frame= 1;
 
     for(;;){
-        uint32_t v= be2me_32(*src++);
+        uint32_t v= av_be2ne32(*src++);
         *udst++= (v>>16) & 0xFFC0;
         *ydst++= (v>>6 ) & 0xFFC0;
         *vdst++= (v<<4 ) & 0xFFC0;
 
-        v= be2me_32(*src++);
+        v= av_be2ne32(*src++);
         *ydst++= (v>>16) & 0xFFC0;
 
         if(ydst >= yend){
@@ -87,7 +87,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
         *udst++= (v>>6 ) & 0xFFC0;
         *ydst++= (v<<4 ) & 0xFFC0;
 
-        v= be2me_32(*src++);
+        v= av_be2ne32(*src++);
         *vdst++= (v>>16) & 0xFFC0;
         *ydst++= (v>>6 ) & 0xFFC0;
 
@@ -102,7 +102,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
 
         *udst++= (v<<4 ) & 0xFFC0;
 
-        v= be2me_32(*src++);
+        v= av_be2ne32(*src++);
         *ydst++= (v>>16) & 0xFFC0;
         *vdst++= (v>>6 ) & 0xFFC0;
         *ydst++= (v<<4 ) & 0xFFC0;
diff --git a/libavformat/asfcrypt.c b/libavformat/asfcrypt.c
index 09e9af6..55ad827 100644
--- a/libavformat/asfcrypt.c
+++ b/libavformat/asfcrypt.c
@@ -170,7 +170,7 @@ void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len) {
         ms_state = multiswap_enc(ms_keys, ms_state, AV_RL64(qwords));
     multiswap_invert_keys(ms_keys);
     packetkey = (packetkey << 32) | (packetkey >> 32);
-    packetkey = le2me_64(packetkey);
+    packetkey = av_le2ne64(packetkey);
     packetkey = multiswap_dec(ms_keys, ms_state, packetkey);
     AV_WL64(qwords, packetkey);
 }
diff --git a/libavformat/asfdec.c b/libavformat/asfdec.c
index 17b2033..149a493 100644
--- a/libavformat/asfdec.c
+++ b/libavformat/asfdec.c
@@ -386,7 +386,7 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
                     st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
 #if HAVE_BIGENDIAN
                     for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
-                        st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]);
+                        st->codec->palctrl->palette[i] = av_bswap32(((uint32_t*)st->codec->extradata)[i]);
 #else
                     memcpy(st->codec->palctrl->palette, st->codec->extradata,
                            FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
diff --git a/libavformat/avidec.c b/libavformat/avidec.c
index cdf8307..78ccc26 100644
--- a/libavformat/avidec.c
+++ b/libavformat/avidec.c
@@ -539,7 +539,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
                         st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
 #if HAVE_BIGENDIAN
                         for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
-                            st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]);
+                            st->codec->palctrl->palette[i] = av_bswap32(((uint32_t*)st->codec->extradata)[i]);
 #else
                         memcpy(st->codec->palctrl->palette, st->codec->extradata,
                                FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
diff --git a/libavformat/electronicarts.c b/libavformat/electronicarts.c
index 86d7f91..df517df 100644
--- a/libavformat/electronicarts.c
+++ b/libavformat/electronicarts.c
@@ -301,7 +301,7 @@ static int process_ea_header(AVFormatContext *s) {
         if (i == 0)
             ea->big_endian = size > 0x000FFFFF;
         if (ea->big_endian)
-            size = bswap_32(size);
+            size = av_bswap32(size);
 
         switch (blockid) {
             case ISNh_TAG:
diff --git a/libavformat/mov.c b/libavformat/mov.c
index fb2353c..bf986b3 100644
--- a/libavformat/mov.c
+++ b/libavformat/mov.c
@@ -993,7 +993,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
         st->codec->codec_tag = format;
         id = ff_codec_get_id(codec_movaudio_tags, format);
         if (id<=0 && ((format&0xFFFF) == 'm'+('s'<<8) || (format&0xFFFF) == 'T'+('S'<<8)))
-            id = ff_codec_get_id(ff_codec_wav_tags, bswap_32(format)&0xFFFF);
+            id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format)&0xFFFF);
 
         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
             st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
diff --git a/libavformat/mpegtsenc.c b/libavformat/mpegtsenc.c
index af019ca..4bd48d3 100644
--- a/libavformat/mpegtsenc.c
+++ b/libavformat/mpegtsenc.c
@@ -74,7 +74,7 @@ static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len)
     unsigned char *q;
     int first, b, len1, left;
 
-    crc = bswap_32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4));
+    crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, buf, len - 4));
     buf[len - 4] = (crc >> 24) & 0xff;
     buf[len - 3] = (crc >> 16) & 0xff;
     buf[len - 2] = (crc >> 8) & 0xff;
diff --git a/libavformat/mtv.c b/libavformat/mtv.c
index 4eae1a1..9280455 100644
--- a/libavformat/mtv.c
+++ b/libavformat/mtv.c
@@ -188,7 +188,7 @@ static int mtv_read_packet(AVFormatContext *s, AVPacket *pkt)
          */
 
         for(i=0;i<mtv->img_segment_size/2;i++)
-            *((uint16_t *)pkt->data+i) = bswap_16(*((uint16_t *)pkt->data+i));
+            *((uint16_t *)pkt->data+i) = av_bswap16(*((uint16_t *)pkt->data+i));
 #endif
         pkt->stream_index = VIDEO_SID;
     }
diff --git a/libavformat/nutdec.c b/libavformat/nutdec.c
index aae5826..1b616de 100644
--- a/libavformat/nutdec.c
+++ b/libavformat/nutdec.c
@@ -94,7 +94,7 @@ static int get_packetheader(NUTContext *nut, ByteIOContext *bc, int calculate_ch
     int64_t size;
 //    start= url_ftell(bc) - 8;
 
-    startcode= be2me_64(startcode);
+    startcode= av_be2ne64(startcode);
     startcode= ff_crc04C11DB7_update(0, (uint8_t*)&startcode, 8);
 
     init_checksum(bc, ff_crc04C11DB7_update, startcode);
diff --git a/libavformat/smacker.c b/libavformat/smacker.c
index 898dbd2..89e9e35 100644
--- a/libavformat/smacker.c
+++ b/libavformat/smacker.c
@@ -213,10 +213,10 @@ static int smacker_read_header(AVFormatContext *s, AVFormatParameters *ap)
         av_free(smk->frm_flags);
         return AVERROR(EIO);
     }
-    ((int32_t*)st->codec->extradata)[0] = le2me_32(smk->mmap_size);
-    ((int32_t*)st->codec->extradata)[1] = le2me_32(smk->mclr_size);
-    ((int32_t*)st->codec->extradata)[2] = le2me_32(smk->full_size);
-    ((int32_t*)st->codec->extradata)[3] = le2me_32(smk->type_size);
+    ((int32_t*)st->codec->extradata)[0] = av_le2ne32(smk->mmap_size);
+    ((int32_t*)st->codec->extradata)[1] = av_le2ne32(smk->mclr_size);
+    ((int32_t*)st->codec->extradata)[2] = av_le2ne32(smk->full_size);
+    ((int32_t*)st->codec->extradata)[3] = av_le2ne32(smk->type_size);
 
     smk->curstream = -1;
     smk->nextpos = url_ftell(pb);
diff --git a/libavformat/sol.c b/libavformat/sol.c
index 3ae2d04..a7faacc 100644
--- a/libavformat/sol.c
+++ b/libavformat/sol.c
@@ -34,7 +34,7 @@ static int sol_probe(AVProbeData *p)
 {
     /* check file header */
     uint16_t magic;
-    magic=le2me_16(*((uint16_t*)p->buf));
+    magic=av_le2ne16(*((uint16_t*)p->buf));
     if ((magic == 0x0B8D || magic == 0x0C0D || magic == 0x0C8D) &&
         p->buf[2] == 'S' && p->buf[3] == 'O' &&
         p->buf[4] == 'L' && p->buf[5] == 0)
diff --git a/libavformat/spdif.c b/libavformat/spdif.c
index 813be67..1355797 100644
--- a/libavformat/spdif.c
+++ b/libavformat/spdif.c
@@ -90,17 +90,17 @@ static void bswap_buf16(uint16_t *dst, const uint16_t *src, int w)
     int i;
 
     for (i = 0; i + 8 <= w; i += 8) {
-        dst[i + 0] = bswap_16(src[i + 0]);
-        dst[i + 1] = bswap_16(src[i + 1]);
-        dst[i + 2] = bswap_16(src[i + 2]);
-        dst[i + 3] = bswap_16(src[i + 3]);
-        dst[i + 4] = bswap_16(src[i + 4]);
-        dst[i + 5] = bswap_16(src[i + 5]);
-        dst[i + 6] = bswap_16(src[i + 6]);
-        dst[i + 7] = bswap_16(src[i + 7]);
+        dst[i + 0] = av_bswap16(src[i + 0]);
+        dst[i + 1] = av_bswap16(src[i + 1]);
+        dst[i + 2] = av_bswap16(src[i + 2]);
+        dst[i + 3] = av_bswap16(src[i + 3]);
+        dst[i + 4] = av_bswap16(src[i + 4]);
+        dst[i + 5] = av_bswap16(src[i + 5]);
+        dst[i + 6] = av_bswap16(src[i + 6]);
+        dst[i + 7] = av_bswap16(src[i + 7]);
     }
     for (; i < w; i++)
-        dst[i + 0] = bswap_16(src[i + 0]);
+        dst[i + 0] = av_bswap16(src[i + 0]);
 }
 
 static int spdif_header_ac3(AVFormatContext *s, AVPacket *pkt)
diff --git a/libavutil/arm/bswap.h b/libavutil/arm/bswap.h
index 9126350..c5e74cc 100644
--- a/libavutil/arm/bswap.h
+++ b/libavutil/arm/bswap.h
@@ -26,15 +26,15 @@
 #ifdef __ARMCC_VERSION
 
 #if HAVE_ARMV6
-#define bswap_16 bswap_16
-static av_always_inline av_const unsigned bswap_16(unsigned x)
+#define av_bswap16 av_bswap16
+static av_always_inline av_const unsigned av_bswap16(unsigned x)
 {
     __asm { rev16 x, x }
     return x;
 }
 
-#define bswap_32 bswap_32
-static av_always_inline av_const uint32_t bswap_32(uint32_t x)
+#define av_bswap32 av_bswap32
+static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
 {
     return __rev(x);
 }
@@ -43,16 +43,16 @@ static av_always_inline av_const uint32_t bswap_32(uint32_t x)
 #elif HAVE_INLINE_ASM
 
 #if HAVE_ARMV6
-#define bswap_16 bswap_16
-static av_always_inline av_const unsigned bswap_16(unsigned x)
+#define av_bswap16 av_bswap16
+static av_always_inline av_const unsigned av_bswap16(unsigned x)
 {
     __asm__("rev16 %0, %0" : "+r"(x));
     return x;
 }
 #endif
 
-#define bswap_32 bswap_32
-static av_always_inline av_const uint32_t bswap_32(uint32_t x)
+#define av_bswap32 av_bswap32
+static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
 {
 #if HAVE_ARMV6
     __asm__("rev %0, %0" : "+r"(x));
diff --git a/libavutil/avr32/bswap.h b/libavutil/avr32/bswap.h
index e8c8ddc..e79d53f 100644
--- a/libavutil/avr32/bswap.h
+++ b/libavutil/avr32/bswap.h
@@ -25,15 +25,15 @@
 
 #if HAVE_INLINE_ASM
 
-#define bswap_16 bswap_16
-static av_always_inline av_const uint16_t bswap_16(uint16_t x)
+#define av_bswap16 av_bswap16
+static av_always_inline av_const uint16_t av_bswap16(uint16_t x)
 {
     __asm__ ("swap.bh %0" : "+r"(x));
     return x;
 }
 
-#define bswap_32 bswap_32
-static av_always_inline av_const uint32_t bswap_32(uint32_t x)
+#define av_bswap32 av_bswap32
+static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
 {
     __asm__ ("swap.b  %0" : "+r"(x));
     return x;
diff --git a/libavutil/avr32/intreadwrite.h b/libavutil/avr32/intreadwrite.h
index 3e468b4..c6fd3aa 100644
--- a/libavutil/avr32/intreadwrite.h
+++ b/libavutil/avr32/intreadwrite.h
@@ -106,8 +106,8 @@ static av_always_inline void AV_WB32(void *p, uint32_t v)
 }
 
 /* These two would be defined by generic code, but we need them sooner. */
-#define AV_RL32(p)    bswap_32(AV_RB32(p))
-#define AV_WL32(p, v) AV_WB32(p, bswap_32(v))
+#define AV_RL32(p)    av_bswap32(AV_RB32(p))
+#define AV_WL32(p, v) AV_WB32(p, av_bswap32(v))
 
 #define AV_WB64 AV_WB64
 static av_always_inline void AV_WB64(void *p, uint64_t v)
diff --git a/libavutil/bfin/bswap.h b/libavutil/bfin/bswap.h
index ccdfeb7..363ed40 100644
--- a/libavutil/bfin/bswap.h
+++ b/libavutil/bfin/bswap.h
@@ -30,8 +30,8 @@
 #include "config.h"
 #include "libavutil/attributes.h"
 
-#define bswap_32 bswap_32
-static av_always_inline av_const uint32_t bswap_32(uint32_t x)
+#define av_bswap32 av_bswap32
+static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
 {
     unsigned tmp;
     __asm__("%1 = %0 >> 8 (V);      \n\t"
diff --git a/libavutil/bswap.h b/libavutil/bswap.h
index 6dd2a35..f8c866a 100644
--- a/libavutil/bswap.h
+++ b/libavutil/bswap.h
@@ -48,16 +48,16 @@
 
 #define AV_BSWAPC(s, x) AV_BSWAP##s##C(x)
 
-#ifndef bswap_16
-static av_always_inline av_const uint16_t bswap_16(uint16_t x)
+#ifndef av_bswap16
+static av_always_inline av_const uint16_t av_bswap16(uint16_t x)
 {
     x= (x>>8) | (x<<8);
     return x;
 }
 #endif
 
-#ifndef bswap_32
-static av_always_inline av_const uint32_t bswap_32(uint32_t x)
+#ifndef av_bswap32
+static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
 {
     x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF);
     x= (x>>16) | (x<<16);
@@ -65,8 +65,8 @@ static av_always_inline av_const uint32_t bswap_32(uint32_t x)
 }
 #endif
 
-#ifndef bswap_64
-static inline uint64_t av_const bswap_64(uint64_t x)
+#ifndef av_bswap64
+static inline uint64_t av_const av_bswap64(uint64_t x)
 {
 #if 0
     x= ((x<< 8)&0xFF00FF00FF00FF00ULL) | ((x>> 8)&0x00FF00FF00FF00FFULL);
@@ -78,41 +78,41 @@ static inline uint64_t av_const bswap_64(uint64_t x)
         uint32_t l[2];
     } w, r;
     w.ll = x;
-    r.l[0] = bswap_32 (w.l[1]);
-    r.l[1] = bswap_32 (w.l[0]);
+    r.l[0] = av_bswap32 (w.l[1]);
+    r.l[1] = av_bswap32 (w.l[0]);
     return r.ll;
 #endif
 }
 #endif
 
-// be2me ... big-endian to machine-endian
-// le2me ... little-endian to machine-endian
+// be2ne ... big-endian to native-endian
+// le2ne ... little-endian to native-endian
 
 #if HAVE_BIGENDIAN
-#define be2me_16(x) (x)
-#define be2me_32(x) (x)
-#define be2me_64(x) (x)
-#define le2me_16(x) bswap_16(x)
-#define le2me_32(x) bswap_32(x)
-#define le2me_64(x) bswap_64(x)
-#define AV_BE2MEC(s, x) (x)
-#define AV_LE2MEC(s, x) AV_BSWAPC(s, x)
+#define av_be2ne16(x) (x)
+#define av_be2ne32(x) (x)
+#define av_be2ne64(x) (x)
+#define av_le2ne16(x) av_bswap16(x)
+#define av_le2ne32(x) av_bswap32(x)
+#define av_le2ne64(x) av_bswap64(x)
+#define AV_BE2NEC(s, x) (x)
+#define AV_LE2NEC(s, x) AV_BSWAPC(s, x)
 #else
-#define be2me_16(x) bswap_16(x)
-#define be2me_32(x) bswap_32(x)
-#define be2me_64(x) bswap_64(x)
-#define le2me_16(x) (x)
-#define le2me_32(x) (x)
-#define le2me_64(x) (x)
-#define AV_BE2MEC(s, x) AV_BSWAPC(s, x)
-#define AV_LE2MEC(s, x) (x)
+#define av_be2ne16(x) av_bswap16(x)
+#define av_be2ne32(x) av_bswap32(x)
+#define av_be2ne64(x) av_bswap64(x)
+#define av_le2ne16(x) (x)
+#define av_le2ne32(x) (x)
+#define av_le2ne64(x) (x)
+#define AV_BE2NEC(s, x) AV_BSWAPC(s, x)
+#define AV_LE2NEC(s, x) (x)
 #endif
 
-#define AV_BE2ME16C(x) AV_BE2MEC(16, x)
-#define AV_BE2ME32C(x) AV_BE2MEC(32, x)
-#define AV_BE2ME64C(x) AV_BE2MEC(64, x)
-#define AV_LE2ME16C(x) AV_LE2MEC(16, x)
-#define AV_LE2ME32C(x) AV_LE2MEC(32, x)
-#define AV_LE2ME64C(x) AV_LE2MEC(64, x)
+#define AV_BE2NE16C(x) AV_BE2NEC(16, x)
+#define AV_BE2NE32C(x) AV_BE2NEC(32, x)
+#define AV_BE2NE64C(x) AV_BE2NEC(64, x)
+#define AV_LE2NE16C(x) AV_LE2NEC(16, x)
+#define AV_LE2NE32C(x) AV_LE2NEC(32, x)
+#define AV_LE2NE64C(x) AV_LE2NEC(64, x)
 
 #endif /* AVUTIL_BSWAP_H */
diff --git a/libavutil/crc.c b/libavutil/crc.c
index 54133e7..c3d74a2 100644
--- a/libavutil/crc.c
+++ b/libavutil/crc.c
@@ -49,7 +49,7 @@ static AVCRC av_crc_table[AV_CRC_MAX][257];
  *           If 0, you must swap the CRC parameter and the result of av_crc
  *           if you need the standard representation (can be simplified in
  *           most cases to e.g. bswap16):
- *           bswap_32(crc << (32-bits))
+ *           av_bswap32(crc << (32-bits))
  * @param bits number of bits for the CRC
  * @param poly generator polynomial without the x**bits coefficient, in the
  *             representation as specified by le
@@ -73,7 +73,7 @@ int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size){
         } else {
             for (c = i << 24, j = 0; j < 8; j++)
                 c = (c<<1) ^ ((poly<<(32-bits)) & (((int32_t)c)>>31) );
-            ctx[i] = bswap_32(c);
+            ctx[i] = av_bswap32(c);
         }
     }
     ctx[256]=1;
@@ -121,7 +121,7 @@ uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t le
             crc = ctx[((uint8_t)crc) ^ *buffer++] ^ (crc >> 8);
 
         while(buffer<end-3){
-            crc ^= le2me_32(*(const uint32_t*)buffer); buffer+=4;
+            crc ^= av_le2ne32(*(const uint32_t*)buffer); buffer+=4;
             crc =  ctx[3*256 + ( crc     &0xFF)]
                   ^ctx[2*256 + ((crc>>8 )&0xFF)]
                   ^ctx[1*256 + ((crc>>16)&0xFF)]
diff --git a/libavutil/des.c b/libavutil/des.c
index ab66a0b..9c1a530 100644
--- a/libavutil/des.c
+++ b/libavutil/des.c
@@ -297,10 +297,10 @@ int av_des_init(AVDES *d, const uint8_t *key, int key_bits, int decrypt) {
 }
 
 void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt) {
-    uint64_t iv_val = iv ? be2me_64(*(uint64_t *)iv) : 0;
+    uint64_t iv_val = iv ? av_be2ne64(*(uint64_t *)iv) : 0;
     while (count-- > 0) {
         uint64_t dst_val;
-        uint64_t src_val = src ? be2me_64(*(const uint64_t *)src) : 0;
+        uint64_t src_val = src ? av_be2ne64(*(const uint64_t *)src) : 0;
         if (decrypt) {
             uint64_t tmp = src_val;
             if (d->triple_des) {
@@ -317,12 +317,12 @@ void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t
             }
             iv_val = iv ? dst_val : 0;
         }
-        *(uint64_t *)dst = be2me_64(dst_val);
+        *(uint64_t *)dst = av_be2ne64(dst_val);
         src += 8;
         dst += 8;
     }
     if (iv)
-        *(uint64_t *)iv = be2me_64(iv_val);
+        *(uint64_t *)iv = av_be2ne64(iv_val);
 }
 
 #ifdef TEST
diff --git a/libavutil/intreadwrite.h b/libavutil/intreadwrite.h
index 9315cdd..0ea30e9 100644
--- a/libavutil/intreadwrite.h
+++ b/libavutil/intreadwrite.h
@@ -339,11 +339,11 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
 #if HAVE_BIGENDIAN
 #   define AV_RB(s, p)    AV_RN##s(p)
 #   define AV_WB(s, p, v) AV_WN##s(p, v)
-#   define AV_RL(s, p)    bswap_##s(AV_RN##s(p))
-#   define AV_WL(s, p, v) AV_WN##s(p, bswap_##s(v))
+#   define AV_RL(s, p)    av_bswap##s(AV_RN##s(p))
+#   define AV_WL(s, p, v) AV_WN##s(p, av_bswap##s(v))
 #else
-#   define AV_RB(s, p)    bswap_##s(AV_RN##s(p))
-#   define AV_WB(s, p, v) AV_WN##s(p, bswap_##s(v))
+#   define AV_RB(s, p)    av_bswap##s(AV_RN##s(p))
+#   define AV_WB(s, p, v) AV_WN##s(p, av_bswap##s(v))
 #   define AV_RL(s, p)    AV_RN##s(p)
 #   define AV_WL(s, p, v) AV_WN##s(p, v)
 #endif
diff --git a/libavutil/md5.c b/libavutil/md5.c
index 39ee624..173ed06 100644
--- a/libavutil/md5.c
+++ b/libavutil/md5.c
@@ -95,7 +95,7 @@ static void body(uint32_t ABCD[4], uint32_t X[16]){
 
 #if HAVE_BIGENDIAN
     for(i=0; i<16; i++)
-        X[i]= bswap_32(X[i]);
+        X[i]= av_bswap32(X[i]);
 #endif
 
 #if CONFIG_SMALL
@@ -141,7 +141,7 @@ void av_md5_update(AVMD5 *ctx, const uint8_t *src, const int len){
 
 void av_md5_final(AVMD5 *ctx, uint8_t *dst){
     int i;
-    uint64_t finalcount= le2me_64(ctx->len<<3);
+    uint64_t finalcount= av_le2ne64(ctx->len<<3);
 
     av_md5_update(ctx, "\200", 1);
     while((ctx->len & 63)!=56)
@@ -150,7 +150,7 @@ void av_md5_final(AVMD5 *ctx, uint8_t *dst){
     av_md5_update(ctx, (uint8_t*)&finalcount, 8);
 
     for(i=0; i<4; i++)
-        ((uint32_t*)dst)[i]= le2me_32(ctx->ABCD[3-i]);
+        ((uint32_t*)dst)[i]= av_le2ne32(ctx->ABCD[3-i]);
 }
 
 void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len){
diff --git a/libavutil/sh4/bswap.h b/libavutil/sh4/bswap.h
index 6d237c5..48dd27f 100644
--- a/libavutil/sh4/bswap.h
+++ b/libavutil/sh4/bswap.h
@@ -28,15 +28,15 @@
 #include "config.h"
 #include "libavutil/attributes.h"
 
-#define bswap_16 bswap_16
-static av_always_inline av_const uint16_t bswap_16(uint16_t x)
+#define av_bswap16 av_bswap16
+static av_always_inline av_const uint16_t av_bswap16(uint16_t x)
 {
     __asm__("swap.b %0,%0" : "+r"(x));
     return x;
 }
 
-#define bswap_32 bswap_32
-static av_always_inline av_const uint32_t bswap_32(uint32_t x)
+#define av_bswap32 av_bswap32
+static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
 {
     __asm__("swap.b %0,%0\n"
             "swap.w %0,%0\n"
diff --git a/libavutil/sha.c b/libavutil/sha.c
index 5a3b575..2657f7e 100644
--- a/libavutil/sha.c
+++ b/libavutil/sha.c
@@ -43,7 +43,7 @@ const int av_sha_size = sizeof(AVSHA);
 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
 
 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
-#define blk0(i) (block[i] = be2me_32(((const uint32_t*)buffer)[i]))
+#define blk0(i) (block[i] = av_be2ne32(((const uint32_t*)buffer)[i]))
 #define blk(i)  (block[i] = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1))
 
 #define R0(v,w,x,y,z,i) z += ((w&(x^y))^y)     + blk0(i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
@@ -68,7 +68,7 @@ static void sha1_transform(uint32_t state[5], const uint8_t buffer[64])
     for (i = 0; i < 80; i++) {
         int t;
         if (i < 16)
-            t = be2me_32(((uint32_t*)buffer)[i]);
+            t = av_be2ne32(((uint32_t*)buffer)[i]);
         else
             t = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1);
         block[i] = t;
@@ -314,7 +314,7 @@ void av_sha_update(AVSHA* ctx, const uint8_t* data, unsigned int len)
 void av_sha_final(AVSHA* ctx, uint8_t *digest)
 {
     int i;
-    uint64_t finalcount = be2me_64(ctx->count << 3);
+    uint64_t finalcount = av_be2ne64(ctx->count << 3);
 
     av_sha_update(ctx, "\200", 1);
     while ((ctx->count & 63) != 56)
diff --git a/libavutil/x86/bswap.h b/libavutil/x86/bswap.h
index 26dc4e2..b6ceb76 100644
--- a/libavutil/x86/bswap.h
+++ b/libavutil/x86/bswap.h
@@ -28,15 +28,15 @@
 #include "config.h"
 #include "libavutil/attributes.h"
 
-#define bswap_16 bswap_16
-static av_always_inline av_const uint16_t bswap_16(uint16_t x)
+#define av_bswap16 av_bswap16
+static av_always_inline av_const uint16_t av_bswap16(uint16_t x)
 {
     __asm__("rorw $8, %0" : "+r"(x));
     return x;
 }
 
-#define bswap_32 bswap_32
-static av_always_inline av_const uint32_t bswap_32(uint32_t x)
+#define av_bswap32 av_bswap32
+static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
 {
 #if HAVE_BSWAP
     __asm__("bswap   %0" : "+r" (x));
@@ -50,8 +50,8 @@ static av_always_inline av_const uint32_t bswap_32(uint32_t x)
 }
 
 #if ARCH_X86_64
-#define bswap_64 bswap_64
-static inline uint64_t av_const bswap_64(uint64_t x)
+#define av_bswap64 av_bswap64
+static inline uint64_t av_const av_bswap64(uint64_t x)
 {
     __asm__("bswap  %0": "=r" (x) : "0" (x));
     return x;
-- 
1.7.1.1




More information about the ffmpeg-devel mailing list