[dev] merge branch 'endian'.

Author: winshining

hls/ngx_rtmp_hls_module.c

@@ -745,7 +745,7 @@ ngx_rtmp_hls_append_sps_pps(ngx_rtmp_session_t *s, ngx_buf_t *out)
                 return NGX_ERROR;
             }
 
-            ngx_rtmp_rmemcpy(&len, &rlen, 2);
+            len = ntohs(rlen);
 
             ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
                            "hls: header NAL length: %uz", (size_t) len);
@@ -1948,8 +1948,17 @@ ngx_rtmp_hls_video(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h,
             return NGX_OK;
         }
 
-        len = 0;
-        ngx_rtmp_rmemcpy(&len, &rlen, nal_bytes);
+        if (nal_bytes != 3 && nal_bytes != 4) {
+            ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
+                          "hls: incorrect NAL start code length");
+            return NGX_ERROR;
+        }
+
+        if (nal_bytes == 3) {
+            len = ngx_rtmp_n3_to_h4((u_char *) &rlen);
+        } else {
+            len = ntohl(rlen);
+        }
 
         if (len == 0) {
             continue;

ngx_http_flv_live_module.c

@@ -2250,7 +2250,7 @@ ngx_http_flv_live_append_shared_bufs(ngx_rtmp_core_srv_conf_t *cscf,
 {
     ngx_chain_t        *tag, *chunk_head, *chunk_tail, chunk,
                        *iter, *last_in, **tail, prev_tag_size;
-    u_char             *pos, *p,
+    u_char             *pos,
 #if !(NGX_WIN32)
                         chunk_item[ngx_strlen("0000000000000000" CRLF) + 1];
 #else
@@ -2279,11 +2279,8 @@ ngx_http_flv_live_append_shared_bufs(ngx_rtmp_core_srv_conf_t *cscf,
     prev_tag_size_buf.last = prev_tag_size_buf.end;
 
     pos = prev_tag_size_buf.pos;
-    p = (u_char *) &tag_size;
-    *pos++ = p[3];
-    *pos++ = p[2];
-    *pos++ = p[1];
-    *pos++ = p[0];
+    *(uint32_t *) pos = htonl(tag_size);
+    pos += 4;
 
     /* ngx_rtmp_alloc_shared_buf returns the memory:
      * |4B|sizeof(ngx_chain_t)|sizeof(ngx_buf_t)|NGX_RTMP_MAX_CHUNK_HEADER|
@@ -2305,17 +2302,13 @@ ngx_http_flv_live_append_shared_bufs(ngx_rtmp_core_srv_conf_t *cscf,
     *pos++ = (u_char) (h->type & 0x1f);
 
     /* data length, 3B */
-    p = (u_char *) &data_size;
-    *pos++ = p[2];
-    *pos++ = p[1];
-    *pos++ = p[0];
+    ngx_rtmp_h4_to_n3(pos, data_size);
+    pos += 3;
 
     /* timestamp, 3B + ext, 1B */
-    p = (u_char *) &h->timestamp;
-    *pos++ = p[2];
-    *pos++ = p[1];
-    *pos++ = p[0];
-    *pos++ = p[3];
+    ngx_rtmp_h4_to_n3(pos, h->timestamp);
+    pos += 3;
+    *pos++ = (u_char) (h->timestamp >> 24);
 
     /* streamId, 3B, always be 0 */
     *pos++ = 0;

ngx_rtmp.c

@@ -1097,6 +1097,24 @@ ngx_rtmp_rmemcpy(void *dst, const void* src, size_t n)
 }
 
 
+u_char *
+ngx_rtmp_h4_to_n3(u_char *dst, uint32_t h)
+{
+    dst[0] = (u_char) (h >> 16);
+    dst[1] = (u_char) (h >> 8);
+    dst[2] = (u_char) h;
+
+    return dst;
+}
+
+
+uint32_t
+ngx_rtmp_n3_to_h4(u_char *n)
+{
+    return ((uint32_t) n[0] << 16) | ((uint32_t) n[1] << 8) | (uint32_t) n[2];
+}
+
+
 static ngx_int_t
 ngx_rtmp_init_process(ngx_cycle_t *cycle)
 {

ngx_rtmp.h

@@ -584,12 +584,12 @@ typedef struct {
 
 
 #ifdef NGX_DEBUG
-char* ngx_rtmp_message_type(uint8_t type);
-char* ngx_rtmp_user_message_type(uint16_t evt);
+char *ngx_rtmp_message_type(uint8_t type);
+char *ngx_rtmp_user_message_type(uint16_t evt);
 #endif
 
 void ngx_rtmp_init_connection(ngx_connection_t *c);
-ngx_rtmp_session_t * ngx_rtmp_init_session(ngx_connection_t *c,
+ngx_rtmp_session_t *ngx_rtmp_init_session(ngx_connection_t *c,
      ngx_rtmp_addr_conf_t *addr_conf);
 void ngx_rtmp_finalize_session(ngx_rtmp_session_t *s);
 void ngx_rtmp_handshake(ngx_rtmp_session_t *s);
@@ -602,38 +602,49 @@ ngx_chain_t *ngx_rtmp_alloc_in_buf(ngx_rtmp_session_t *s);
 ngx_int_t ngx_rtmp_finalize_set_chunk_size(ngx_rtmp_session_t *s);
 
 ngx_int_t ngx_rtmp_fire_event(ngx_rtmp_session_t *s, ngx_uint_t evt,
-        ngx_rtmp_header_t *h, ngx_chain_t *in);
+     ngx_rtmp_header_t *h, ngx_chain_t *in);
 
 
 ngx_int_t ngx_rtmp_set_chunk_size(ngx_rtmp_session_t *s, ngx_uint_t size);
 
 
 /* Bit reverse: we need big-endians in many places  */
-void * ngx_rtmp_rmemcpy(void *dst, const void* src, size_t n);
-
-#define ngx_rtmp_rcpymem(dst, src, n) \
-    (((u_char*)ngx_rtmp_rmemcpy(dst, src, n)) + (n))
+void *ngx_rtmp_rmemcpy(void *dst, const void *src, size_t n);
+u_char *ngx_rtmp_h4_to_n3(u_char *dst, uint32_t h);
+uint32_t ngx_rtmp_n3_to_h4(u_char *n);
 
 
 static ngx_inline uint16_t
 ngx_rtmp_r16(uint16_t n)
 {
+#if (NGX_HAVE_LITTLE_ENDIAN)
     return (n << 8) | (n >> 8);
+#else
+    return n;
+#endif
 }
 
 
 static ngx_inline uint32_t
 ngx_rtmp_r32(uint32_t n)
 {
+#if (NGX_HAVE_LITTLE_ENDIAN)
     return (n << 24) | ((n << 8) & 0xff0000) | ((n >> 8) & 0xff00) | (n >> 24);
+#else
+    return n;
+#endif
 }
 
 
 static ngx_inline uint64_t
 ngx_rtmp_r64(uint64_t n)
 {
+#if (NGX_HAVE_LITTLE_ENDIAN)
     return (uint64_t) ngx_rtmp_r32((uint32_t) n) << 32 |
                       ngx_rtmp_r32((uint32_t) (n >> 32));
+#else
+    return n;
+#endif
 }
 
 
@@ -671,10 +682,10 @@ ngx_int_t ngx_rtmp_amf_shared_object_handler(ngx_rtmp_session_t *s,
 #define ngx_rtmp_ref_put(b)                 \
     --ngx_rtmp_ref(b)
 
-ngx_chain_t * ngx_rtmp_alloc_shared_buf(ngx_rtmp_core_srv_conf_t *cscf);
+ngx_chain_t *ngx_rtmp_alloc_shared_buf(ngx_rtmp_core_srv_conf_t *cscf);
 void ngx_rtmp_free_shared_chain(ngx_rtmp_core_srv_conf_t *cscf,
         ngx_chain_t *in);
-ngx_chain_t * ngx_rtmp_append_shared_bufs(ngx_rtmp_core_srv_conf_t *cscf,
+ngx_chain_t *ngx_rtmp_append_shared_bufs(ngx_rtmp_core_srv_conf_t *cscf,
         ngx_chain_t *head, ngx_chain_t *in);
 
 #define ngx_rtmp_acquire_shared_chain(in)   \
@@ -697,15 +708,15 @@ ngx_int_t ngx_rtmp_send_message(ngx_rtmp_session_t *s, ngx_chain_t *out,
 #define NGX_RTMP_LIMIT_DYNAMIC      2
 
 /* Protocol control messages */
-ngx_chain_t * ngx_rtmp_create_chunk_size(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_chunk_size(ngx_rtmp_session_t *s,
         uint32_t chunk_size);
-ngx_chain_t * ngx_rtmp_create_abort(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_abort(ngx_rtmp_session_t *s,
         uint32_t csid);
-ngx_chain_t * ngx_rtmp_create_ack(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_ack(ngx_rtmp_session_t *s,
         uint32_t seq);
-ngx_chain_t * ngx_rtmp_create_ack_size(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_ack_size(ngx_rtmp_session_t *s,
         uint32_t ack_size);
-ngx_chain_t * ngx_rtmp_create_bandwidth(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_bandwidth(ngx_rtmp_session_t *s,
         uint32_t ack_size, uint8_t limit_type);
 
 ngx_int_t ngx_rtmp_send_chunk_size(ngx_rtmp_session_t *s,
@@ -720,19 +731,19 @@ ngx_int_t ngx_rtmp_send_bandwidth(ngx_rtmp_session_t *s,
         uint32_t ack_size, uint8_t limit_type);
 
 /* User control messages */
-ngx_chain_t * ngx_rtmp_create_stream_begin(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_stream_begin(ngx_rtmp_session_t *s,
         uint32_t msid);
-ngx_chain_t * ngx_rtmp_create_stream_eof(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_stream_eof(ngx_rtmp_session_t *s,
         uint32_t msid);
-ngx_chain_t * ngx_rtmp_create_stream_dry(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_stream_dry(ngx_rtmp_session_t *s,
         uint32_t msid);
-ngx_chain_t * ngx_rtmp_create_set_buflen(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_set_buflen(ngx_rtmp_session_t *s,
         uint32_t msid, uint32_t buflen_msec);
-ngx_chain_t * ngx_rtmp_create_recorded(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_recorded(ngx_rtmp_session_t *s,
         uint32_t msid);
-ngx_chain_t * ngx_rtmp_create_ping_request(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_ping_request(ngx_rtmp_session_t *s,
         uint32_t timestamp);
-ngx_chain_t * ngx_rtmp_create_ping_response(ngx_rtmp_session_t *s,
+ngx_chain_t *ngx_rtmp_create_ping_response(ngx_rtmp_session_t *s,
         uint32_t timestamp);
 
 ngx_int_t ngx_rtmp_send_stream_begin(ngx_rtmp_session_t *s,
@@ -757,22 +768,22 @@ ngx_int_t ngx_rtmp_append_amf(ngx_rtmp_session_t *s,
 ngx_int_t ngx_rtmp_receive_amf(ngx_rtmp_session_t *s, ngx_chain_t *in,
         ngx_rtmp_amf_elt_t *elts, size_t nelts);
 
-ngx_chain_t * ngx_rtmp_create_amf(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h,
+ngx_chain_t *ngx_rtmp_create_amf(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h,
         ngx_rtmp_amf_elt_t *elts, size_t nelts);
 ngx_int_t ngx_rtmp_send_amf(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h,
         ngx_rtmp_amf_elt_t *elts, size_t nelts);
 
 /* AMF status sender */
-ngx_chain_t * ngx_rtmp_create_status(ngx_rtmp_session_t *s, char *code,
-        char* level, char *desc);
-ngx_chain_t * ngx_rtmp_create_play_status(ngx_rtmp_session_t *s, char *code,
-        char* level, ngx_uint_t duration, ngx_uint_t bytes);
-ngx_chain_t * ngx_rtmp_create_sample_access(ngx_rtmp_session_t *s);
+ngx_chain_t *ngx_rtmp_create_status(ngx_rtmp_session_t *s, char *code,
+        char *level, char *desc);
+ngx_chain_t *ngx_rtmp_create_play_status(ngx_rtmp_session_t *s, char *code,
+        char *level, ngx_uint_t duration, ngx_uint_t bytes);
+ngx_chain_t *ngx_rtmp_create_sample_access(ngx_rtmp_session_t *s);
 
 ngx_int_t ngx_rtmp_send_status(ngx_rtmp_session_t *s, char *code,
-        char* level, char *desc);
+        char *level, char *desc);
 ngx_int_t ngx_rtmp_send_play_status(ngx_rtmp_session_t *s, char *code,
-        char* level, ngx_uint_t duration, ngx_uint_t bytes);
+        char *level, ngx_uint_t duration, ngx_uint_t bytes);
 ngx_int_t ngx_rtmp_send_sample_access(ngx_rtmp_session_t *s);
 
 

ngx_rtmp_amf.c

@@ -15,15 +15,15 @@
 static ngx_inline void*
 ngx_rtmp_amf_reverse_copy(void *dst, void* src, size_t len)
 {
-    size_t  k;
-
     if (dst == NULL || src == NULL) {
         return NULL;
     }
 
-    for(k = 0; k < len; ++k) {
-        ((u_char*)dst)[k] = ((u_char*)src)[len - 1 - k];
-    }
+#if (NGX_HAVE_LITTLE_ENDIAN)
+    ngx_rtmp_rmemcpy(dst, src, len);
+#else
+    ngx_memcpy(dst, src, len);
+#endif
 
     return dst;
 }

ngx_rtmp_bitop.h

@@ -40,7 +40,7 @@ uint64_t ngx_rtmp_bit_read_golomb(ngx_rtmp_bit_reader_t *br);
     ((uint32_t) ngx_rtmp_bit_read(br, 32))
 
 #define ngx_rtmp_bit_read_64(br)                                              \
-    ((uint64_t) ngx_rtmp_read(br, 64))
+    ((uint64_t) ngx_rtmp_bit_read(br, 64))
 
 
 #endif /* _NGX_RTMP_BITOP_H_INCLUDED_ */

ngx_rtmp_flv_module.c

@@ -1,6 +1,7 @@
 
 /*
  * Copyright (C) Roman Arutyunyan
+ * Copyright (C) Winshining
  */
 
 
@@ -102,7 +103,7 @@ ngx_rtmp_flv_fill_index(ngx_rtmp_amf_ctx_t *ctx, ngx_rtmp_flv_index_t *idx)
         return NGX_ERROR;
     }
 
-    ngx_rtmp_rmemcpy(&nelts, b->pos + ctx->offset, 4);
+    nelts = htonl(*(uint32_t *) (b->pos + ctx->offset));
 
     idx->nelts = nelts;
     idx->offset = ctx->offset + 4;
@@ -201,11 +202,7 @@ ngx_rtmp_flv_init_index(ngx_rtmp_session_t *s, ngx_chain_t *in)
 static double
 ngx_rtmp_flv_index_value(void *src)
 {
-    double      v;
-
-    ngx_rtmp_rmemcpy(&v, src, 8);
-
-    return v;
+    return *(double *) src;
 }
 
 
@@ -352,8 +349,7 @@ ngx_rtmp_flv_read_meta(ngx_rtmp_session_t *s, ngx_file_t *f)
     h.msid = NGX_RTMP_MSID;
     h.csid = NGX_RTMP_CSID_AMF;
 
-    size = 0;
-    ngx_rtmp_rmemcpy(&size, ngx_rtmp_flv_header + 1, 3);
+    size = ngx_rtmp_n3_to_h4(ngx_rtmp_flv_header + 1);
 
     ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
                   "flv: metadata size=%D", size);
@@ -440,12 +436,9 @@ ngx_rtmp_flv_send(ngx_rtmp_session_t *s, ngx_file_t *f, ngx_uint_t *ts)
     h.msid = NGX_RTMP_MSID;
     h.type = ngx_rtmp_flv_header[0];
 
-    size = 0;
-
-    ngx_rtmp_rmemcpy(&size, ngx_rtmp_flv_header + 1, 3);
-    ngx_rtmp_rmemcpy(&h.timestamp, ngx_rtmp_flv_header + 4, 3);
-
-    ((u_char *) &h.timestamp)[3] = ngx_rtmp_flv_header[7];
+    size = ngx_rtmp_n3_to_h4(ngx_rtmp_flv_header + 1);
+    h.timestamp = ngx_rtmp_n3_to_h4(ngx_rtmp_flv_header + 4);
+    h.timestamp |= ((uint32_t) ngx_rtmp_flv_header[7] << 24);
 
     ctx->offset += (sizeof(ngx_rtmp_flv_header) + size + 4);