@@ -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, le2ne_16(*f->wordstream++));

     }else if(code == 5){

-        mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));

+        mcdc(dst, src, log2w, h, stride, 0, le2ne_16(*f->wordstream++));

     }else if(code == 6){

         if(log2w){

-            dst[0] = le2me_16(*f->wordstream++);

-            dst[1] = le2me_16(*f->wordstream++);

+            dst[0] = le2ne_16(*f->wordstream++);

+            dst[1] = le2ne_16(*f->wordstream++);

         }else{

-            dst[0     ] = le2me_16(*f->wordstream++);

-            dst[stride] = le2me_16(*f->wordstream++);

+            dst[0     ] = le2ne_16(*f->wordstream++);

+            dst[stride] = le2ne_16(*f->wordstream++);

         }

     }

 }

@@ -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 = be2ne_16(*(const unsigned short *)(lp+row*2));

                         /* Decode a row of this plane */

                         while(dlen > 0) {

                                 if(dp + 1 >= buf+buf_size) return -1;

@@ -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 = be2ne_64(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)

@@ -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 = { be2ne_64(state) };

     AC3HeaderInfo hdr;

     GetBitContext gbc;

@@ -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]= le2ne_32(a->inv_qscale);

+    ((uint32_t*)avctx->extradata)[1]= le2ne_32(AV_RL32("ASUS"));

     for(i=0; i<64; i++){

         int q= 32*scale*ff_mpeg1_default_intra_matrix[i];

@@ -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 = be2ne_32((0x537F6103 >> (off*8)) | (0x537F6103 << (32-(off*8))));

     bytes += 3 + off;

     for (i = 0; i < bytes/4; i++)

         obuf[i] = c ^ buf[i];

@@ -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++ = le2ne_16(*src++);

                 buf += n;

                 ptr += linesize;

@@ -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^be2ne_64(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 = be2ne_32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));

     bytes += 3 + off;

     for (i = 0; i < bytes/4; i++)

         obuf[i] = c ^ buf[i];

@@ -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 = le2ne_16(samples[i]);

         av_md5_update(s->md5ctx, (uint8_t *)&smp, 2);

     }

 #else

@@ -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= be2ne_32( *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 = be2ne_32( re_buffer_ptr[-1] ) << re_bit_count;

     re_cache1 = 0;

     UPDATE_CACHE(re, s)

     CLOSE_READER(re, s)

@@ -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),                \

@@ -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 = le2ne_32(((le2ne_32(*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 = ((le2ne_16(((unsigned short *)(ref_lp))[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;

+                                ((unsigned short *)cur_lp)[0] = le2ne_16(res);

+                                res = ((le2ne_16(((unsigned short *)(ref_lp))[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;

+                                ((unsigned short *)cur_lp)[1] = le2ne_16(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]] = le2ne_32(((le2ne_32(*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] = le2ne_32(((le2ne_32(*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 = ((le2ne_16(((unsigned short *)ref_lp)[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;

+                                ((unsigned short *)cur_lp)[width_tbl[2]] = le2ne_16(res);

+                                res = ((le2ne_16(((unsigned short *)ref_lp)[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;

+                                ((unsigned short *)cur_lp)[width_tbl[2]+1] = le2ne_16(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]] = le2ne_32(((le2ne_32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][k]) << 1);

+                                    cur_lp[width_tbl[1]+1] = le2ne_32(((le2ne_32(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]] = le2ne_32(((le2ne_32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][*buf1]) << 1);

+                                    cur_lp[width_tbl[1]+1] = le2ne_32(((le2ne_32(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] = le2ne_32(((le2ne_32(ref_lp[0]) >> 1) + lv1) << 1);

+                                    cur_lp[1] = le2ne_32(((le2ne_32(ref_lp[1]) >> 1) + lv2) << 1);

+                                    cur_lp[width_tbl[1]] = le2ne_32(((le2ne_32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);

+                                    cur_lp[width_tbl[1]+1] = le2ne_32(((le2ne_32(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] = le2ne_32(((le2ne_32(ref_lp[0]) >> 1) + lv1) << 1);

+                                    cur_lp[1] = le2ne_32(((le2ne_32(ref_lp[1]) >> 1) + lv2) << 1);

+                                    cur_lp[width_tbl[1]] = le2ne_32(((le2ne_32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);

+                                    cur_lp[width_tbl[1]+1] = le2ne_32(((le2ne_32(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] = le2ne_32(((le2ne_32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);

+                                cur_lp[width_tbl[1]] = le2ne_32(((le2ne_32(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)(((le2ne_16(((unsigned short *)ref_lp)[0]) >> 1) + lv1) << 1);

+                                ((unsigned short *)cur_lp)[0] = le2ne_16(res);

+                                res = (unsigned short)(((le2ne_16(((unsigned short *)ref_lp)[1]) >> 1) + lv2) << 1);

+                                ((unsigned short *)cur_lp)[1] = le2ne_16(res);

+                                res = (unsigned short)(((le2ne_16(((unsigned short *)ref_lp)[width_tbl[2]]) >> 1) + lv1) << 1);

+                                ((unsigned short *)cur_lp)[width_tbl[2]] = le2ne_16(res);

+                                res = (unsigned short)(((le2ne_16(((unsigned short *)ref_lp)[width_tbl[2]+1]) >> 1) + lv2) << 1);

+                                ((unsigned short *)cur_lp)[width_tbl[2]+1] = le2ne_16(res);

                                 lp2++;

                                 break;

@@ -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 = be2ne_32(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 = be2ne_32(id);

         len -= 4;

         if (id == AV_RL32("mjpg")) /* Apple MJPEG-A */

         {

@@ -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 = be2ne_16(((uint16_t *)s->bytestream)[j]);

                     ((uint16_t *)ptr)[j] = (v * f + 16384) >> 15;

                 }

             }

@@ -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 = le2ne_32(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 = be2ne_32(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] |= be2ne_32(value>>(index&31));

+    ptr[1]  = be2ne_32(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] |= be2ne_32(value<<(32-n-(index&7) ));

     ptr[1] = 0;

 //if(n>24) printf("%d %d\n", n, value);

     index+= n;

@@ -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 = be2ne_32(*src++);

             uint16_t r, g, b;

             b =  pixel <<  6;

             g = (pixel >>  4) & 0xffc0;

@@ -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  = le2ne_32(*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  = le2ne_32(*src++);

             *y++ =  val <<  6;

         }

         if (w < avctx->width - 3) {

             *u++ = (val >>  4) & 0xFFC0;

             *y++ = (val >> 14) & 0xFFC0;

-            val  = le2me_32(*src++);

+            val  = le2ne_32(*src++);

             *v++ =  val <<  6;

             *y++ = (val >>  4) & 0xFFC0;

         }

@@ -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= be2ne_32(*src++);

         *udst++= (v>>16) & 0xFFC0;

         *ydst++= (v>>6 ) & 0xFFC0;

         *vdst++= (v<<4 ) & 0xFFC0;

-        v= be2me_32(*src++);

+        v= be2ne_32(*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= be2ne_32(*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= be2ne_32(*src++);

         *ydst++= (v>>16) & 0xFFC0;

         *vdst++= (v>>6 ) & 0xFFC0;

         *ydst++= (v<<4 ) & 0xFFC0;

@@ -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 = le2ne_64(packetkey);

     packetkey = multiswap_dec(ms_keys, ms_state, packetkey);

     AV_WL64(qwords, packetkey);

 }

@@ -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= be2ne_64(startcode);

     startcode= ff_crc04C11DB7_update(0, (uint8_t*)&startcode, 8);

     init_checksum(bc, ff_crc04C11DB7_update, startcode);

@@ -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] = le2ne_32(smk->mmap_size);

+    ((int32_t*)st->codec->extradata)[1] = le2ne_32(smk->mclr_size);

+    ((int32_t*)st->codec->extradata)[2] = le2ne_32(smk->full_size);

+    ((int32_t*)st->codec->extradata)[3] = le2ne_32(smk->type_size);

     smk->curstream = -1;

     smk->nextpos = url_ftell(pb);

@@ -34,7 +34,7 @@ static int sol_probe(AVProbeData *p)

 {

     /* check file header */

     uint16_t magic;

-    magic=le2me_16(*((uint16_t*)p->buf));

+    magic=le2ne_16(*((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)

@@ -85,34 +85,34 @@ static inline uint64_t av_const bswap_64(uint64_t x)

 }

 #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 be2ne_16(x) (x)

+#define be2ne_32(x) (x)

+#define be2ne_64(x) (x)

+#define le2ne_16(x) bswap_16(x)

+#define le2ne_32(x) bswap_32(x)

+#define le2ne_64(x) bswap_64(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 be2ne_16(x) bswap_16(x)

+#define be2ne_32(x) bswap_32(x)

+#define be2ne_64(x) bswap_64(x)

+#define le2ne_16(x) (x)

+#define le2ne_32(x) (x)

+#define le2ne_64(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 */

@@ -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 ^= le2ne_32(*(const uint32_t*)buffer); buffer+=4;

             crc =  ctx[3*256 + ( crc     &0xFF)]

                   ^ctx[2*256 + ((crc>>8 )&0xFF)]

                   ^ctx[1*256 + ((crc>>16)&0xFF)]

@@ -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 ? be2ne_64(*(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 ? be2ne_64(*(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 = be2ne_64(dst_val);

         src += 8;

         dst += 8;

     }

     if (iv)

-        *(uint64_t *)iv = be2me_64(iv_val);

+        *(uint64_t *)iv = be2ne_64(iv_val);

 }

 #ifdef TEST

@@ -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= le2ne_64(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]= le2ne_32(ctx->ABCD[3-i]);

 }

 void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len){

@@ -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] = be2ne_32(((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 = be2ne_32(((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 = be2ne_64(ctx->count << 3);

     av_sha_update(ctx, "\200", 1);

     while ((ctx->count & 63) != 56)