@@ -21,21 +21,8 @@ version next:

 - Microsoft Expression Encoder Screen decoder

 - RTMPS protocol support

 - RTMPTS protocol support

-- showwaves filter

-- LucasArts SMUSH playback support

-- SAMI demuxer and decoder

-- RealText demuxer and decoder

-- Heart Of Darkness PAF playback support

-- iec61883 device

-- asettb filter

-- new option: -progress

-- 3GPP Timed Text decoder

-- GeoTIFF decoder support

-- ffmpeg -(no)stdin option

-- Opus decoder using libopus

-- caca output device using libcaca

-- alphaextract and alphamerge filters

-- concat filter

+- RTMPE protocol support

+- RTMPTE protocol support

 version 0.11:

@@ -667,11 +667,15 @@ check_cmd(){

     "$@" >> $logfile 2>&1

 }

+cc_o(){

+    eval printf '%s\\n' $CC_O

+}

+

 check_cc(){

     log check_cc "$@"

     cat > $TMPC

     log_file $TMPC

-    check_cmd $cc $CPPFLAGS $CFLAGS "$@" -c -o $TMPO $TMPC

+    check_cmd $cc $CPPFLAGS $CFLAGS "$@" -c $(cc_o $TMPO) $TMPC

 }

 check_cxx(){

@@ -1055,6 +1059,7 @@ CONFIG_LIST="

     fft

     fontconfig

     frei0r

+    gcrypt

     gnutls

     gpl

     gray

@@ -1100,6 +1105,7 @@ CONFIG_LIST="

     memalign_hack

     memory_poisoning

     mpegaudiodsp

+    nettle

     network

     nonfree

     openal

@@ -1731,6 +1737,9 @@ x11_grab_device_indev_deps="x11grab"

 # protocols

 bluray_protocol_deps="libbluray"

+ffrtmpcrypt_protocol_deps="!librtmp_protocol"

+ffrtmpcrypt_protocol_deps_any="gcrypt nettle openssl"

+ffrtmpcrypt_protocol_select="tcp_protocol"

 ffrtmphttp_protocol_deps="!librtmp_protocol"

 ffrtmphttp_protocol_select="http_protocol"

 gopher_protocol_deps="network"

@@ -1748,9 +1757,11 @@ mmsh_protocol_select="http_protocol"

 mmst_protocol_deps="network"

 rtmp_protocol_deps="!librtmp_protocol"

 rtmp_protocol_select="tcp_protocol"

+rtmpe_protocol_select="ffrtmpcrypt_protocol"

 rtmps_protocol_deps="!librtmp_protocol"

 rtmps_protocol_select="tls_protocol"

 rtmpt_protocol_select="ffrtmphttp_protocol"

+rtmpte_protocol_select="ffrtmpcrypt_protocol ffrtmphttp_protocol"

 rtmpts_protocol_select="ffrtmphttp_protocol"

 rtp_protocol_select="udp_protocol"

 sctp_protocol_deps="network netinet_sctp_h"

@@ -2371,12 +2382,10 @@ elif $cc --vsn 2>/dev/null | grep -q "ARM C/C++ Compiler"; then

 elif $cc -version 2>/dev/null | grep -q TMS470; then

     cc_type=tms470

     cc_ident=$($cc -version | head -n1 | tr -s ' ')

-    cc="$cc --gcc --abi=eabi -eo=.o -mc -me"

-    CC_O='-fr=$(@D)'

+    cc="$cc --gcc --abi=eabi -me"

+    CC_O='-fe=$@'

     as_default="${cross_prefix}gcc"

     ld_default="${cross_prefix}gcc"

-    TMPO=$(basename $TMPC .c).o

-    append TMPFILES $TMPO

     add_cflags -D__gnuc_va_list=va_list -D__USER_LABEL_PREFIX__=

     CC_DEPFLAGS='-ppa -ppd=$(@:.o=.d)'

     AS_DEPFLAGS='-MMD'

@@ -3375,6 +3384,11 @@ enabled openssl    && { check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto

                         check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto -lws2_32 -lgdi32 ||

                         die "ERROR: openssl not found"; }

+if enabled gnutls; then

+    { check_lib nettle/bignum.h nettle_mpz_get_str_256 -lnettle -lhogweed -lgmp && enable nettle; } ||

+    { check_lib gcrypt.h gcry_mpi_new -lgcrypt && enable gcrypt; }

+fi

+

 # libdc1394 check

 if enabled libdc1394; then

     { check_lib dc1394/dc1394.h dc1394_new -ldc1394 -lraw1394 &&

@@ -904,10 +904,10 @@ performance on systems without hardware floating point support).

 @item MMST         @tab X

 @item pipe         @tab X

 @item RTMP         @tab X

-@item RTMPE        @tab E

+@item RTMPE        @tab X

 @item RTMPS        @tab X

 @item RTMPT        @tab X

-@item RTMPTE       @tab E

+@item RTMPTE       @tab X

 @item RTMPTS       @tab X

 @item RTP          @tab X

 @item SCTP         @tab X

@@ -277,6 +277,15 @@ For example to read with @command{ffplay} a multimedia resource named

 ffplay rtmp://myserver/vod/sample

 @end example

+@section rtmpe

+

+Encrypted Real-Time Messaging Protocol.

+

+The Encrypted Real-Time Messaging Protocol (RTMPE) is used for

+streaming multimedia content within standard cryptographic primitives,

+consisting of Diffie-Hellman key exchange and HMACSHA256, generating

+a pair of RC4 keys.

+

 @section rtmps

 Real-Time Messaging Protocol over a secure SSL connection.

@@ -292,6 +301,14 @@ The Real-Time Messaging Protocol tunneled through HTTP (RTMPT) is used

 for streaming multimedia content within HTTP requests to traverse

 firewalls.

+@section rtmpte

+

+Encrypted Real-Time Messaging Protocol tunneled through HTTP.

+

+The Encrypted Real-Time Messaging Protocol tunneled through HTTP (RTMPTE)

+is used for streaming multimedia content within HTTP requests to traverse

+firewalls.

+

 @section rtmpts

 Real-Time Messaging Protocol tunneled through HTTPS.

@@ -188,42 +188,50 @@ const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src,

     src++;

     length--;

+#define STARTCODE_TEST                                                  \

+        if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) {     \

+            if (src[i + 2] != 3) {                                      \

+                /* startcode, so we must be past the end */             \

+                length = i;                                             \

+            }                                                           \

+            break;                                                      \

+        }

 #if HAVE_FAST_UNALIGNED

+#define FIND_FIRST_ZERO                                                 \

+        if (i > 0 && !src[i])                                           \

+            i--;                                                        \

+        while (src[i])                                                  \

+            i++

 #if HAVE_FAST_64BIT

-#define RS 7

     for (i = 0; i + 1 < length; i += 9) {

         if (!((~AV_RN64A(src + i) &

                (AV_RN64A(src + i) - 0x0100010001000101ULL)) &

               0x8000800080008080ULL))

+            continue;

+        FIND_FIRST_ZERO;

+        STARTCODE_TEST;

+        i -= 7;

+    }

 #else

-#define RS 3

     for (i = 0; i + 1 < length; i += 5) {

         if (!((~AV_RN32A(src + i) &

                (AV_RN32A(src + i) - 0x01000101U)) &

               0x80008080U))

-#endif

             continue;

-        if (i > 0 && !src[i])

-            i--;

-        while (src[i])

-            i++;

+        FIND_FIRST_ZERO;

+        STARTCODE_TEST;

+        i -= 3;

+    }

+#endif

 #else

-#define RS 0

     for (i = 0; i + 1 < length; i += 2) {

         if (src[i])

             continue;

         if (i > 0 && src[i - 1] == 0)

             i--;

-#endif

-        if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) {

-            if (src[i + 2] != 3) {

-                /* startcode, so we must be past the end */

-                length = i;

-            }

-            break;

-        }

-        i -= RS;

+        STARTCODE_TEST;

     }

+#endif

     // use second escape buffer for inter data

     bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0;

@@ -23,7 +23,8 @@

 #include "libavutil/ppc/util_altivec.h"

 #include "dsputil_altivec.h"

-static void int32_to_float_fmul_scalar_altivec(float *dst, const int *src, float mul, int len)

+static void int32_to_float_fmul_scalar_altivec(float *dst, const int *src,

+                                               float mul, int len)

 {

     union {

         vector float v;

@@ -36,7 +37,7 @@ static void int32_to_float_fmul_scalar_altivec(float *dst, const int *src, float

     mul_u.s[0] = mul;

     mul_v = vec_splat(mul_u.v, 0);

-    for(i=0; i<len; i+=8) {

+    for (i = 0; i < len; i += 8) {

         src1 = vec_ctf(vec_ld(0,  src+i), 0);

         src2 = vec_ctf(vec_ld(16, src+i), 0);

         dst1 = vec_madd(src1, mul_v, zero);

@@ -47,8 +48,7 @@ static void int32_to_float_fmul_scalar_altivec(float *dst, const int *src, float

 }

-static vector signed short

-float_to_int16_one_altivec(const float *src)

+static vector signed short float_to_int16_one_altivec(const float *src)

 {

     vector float s0 = vec_ld(0, src);

     vector float s1 = vec_ld(16, src);

@@ -62,80 +62,82 @@ static void float_to_int16_altivec(int16_t *dst, const float *src, long len)

     int i;

     vector signed short d0, d1, d;

     vector unsigned char align;

-    if(((long)dst)&15) //FIXME

-    for(i=0; i<len-7; i+=8) {

-        d0 = vec_ld(0, dst+i);

-        d = float_to_int16_one_altivec(src+i);

-        d1 = vec_ld(15, dst+i);

-        d1 = vec_perm(d1, d0, vec_lvsl(0,dst+i));

-        align = vec_lvsr(0, dst+i);

-        d0 = vec_perm(d1, d, align);

-        d1 = vec_perm(d, d1, align);

-        vec_st(d0, 0, dst+i);

-        vec_st(d1,15, dst+i);

-    }

-    else

-    for(i=0; i<len-7; i+=8) {

-        d = float_to_int16_one_altivec(src+i);

-        vec_st(d, 0, dst+i);

+    if (((long)dst) & 15) { //FIXME

+        for (i = 0; i < len - 7; i += 8) {

+            d0 = vec_ld(0, dst+i);

+            d  = float_to_int16_one_altivec(src + i);

+            d1 = vec_ld(15, dst+i);

+            d1 = vec_perm(d1, d0, vec_lvsl(0, dst + i));

+            align = vec_lvsr(0, dst + i);

+            d0 = vec_perm(d1, d, align);

+            d1 = vec_perm(d, d1, align);

+            vec_st(d0,  0, dst + i);

+            vec_st(d1, 15, dst + i);

+        }

+    } else {

+        for (i = 0; i < len - 7; i += 8) {

+            d = float_to_int16_one_altivec(src + i);

+            vec_st(d, 0, dst + i);

+        }

     }

 }

-static void

-float_to_int16_interleave_altivec(int16_t *dst, const float **src,

-                                  long len, int channels)

+static void float_to_int16_interleave_altivec(int16_t *dst, const float **src,

+                                              long len, int channels)

 {

     int i;

     vector signed short d0, d1, d2, c0, c1, t0, t1;

     vector unsigned char align;

-    if(channels == 1)

+

+    if (channels == 1)

         float_to_int16_altivec(dst, src[0], len);

-    else

+    else {

         if (channels == 2) {

-        if(((long)dst)&15)

-        for(i=0; i<len-7; i+=8) {

-            d0 = vec_ld(0, dst + i);

-            t0 = float_to_int16_one_altivec(src[0] + i);

-            d1 = vec_ld(31, dst + i);

-            t1 = float_to_int16_one_altivec(src[1] + i);

-            c0 = vec_mergeh(t0, t1);

-            c1 = vec_mergel(t0, t1);

-            d2 = vec_perm(d1, d0, vec_lvsl(0, dst + i));

-            align = vec_lvsr(0, dst + i);

-            d0 = vec_perm(d2, c0, align);

-            d1 = vec_perm(c0, c1, align);

-            vec_st(d0,  0, dst + i);

-            d0 = vec_perm(c1, d2, align);

-            vec_st(d1, 15, dst + i);

-            vec_st(d0, 31, dst + i);

-            dst+=8;

-        }

-        else

-        for(i=0; i<len-7; i+=8) {

-            t0 = float_to_int16_one_altivec(src[0] + i);

-            t1 = float_to_int16_one_altivec(src[1] + i);

-            d0 = vec_mergeh(t0, t1);

-            d1 = vec_mergel(t0, t1);

-            vec_st(d0,  0, dst + i);

-            vec_st(d1, 16, dst + i);

-            dst+=8;

-        }

-    } else {

-        DECLARE_ALIGNED(16, int16_t, tmp)[len];

-        int c, j;

-        for (c = 0; c < channels; c++) {

-            float_to_int16_altivec(tmp, src[c], len);

-            for (i = 0, j = c; i < len; i++, j+=channels) {

-                dst[j] = tmp[i];

+            if (((long)dst) & 15) {

+                for (i = 0; i < len - 7; i += 8) {

+                    d0 = vec_ld(0,  dst + i);

+                    t0 = float_to_int16_one_altivec(src[0] + i);

+                    d1 = vec_ld(31, dst + i);

+                    t1 = float_to_int16_one_altivec(src[1] + i);

+                    c0 = vec_mergeh(t0, t1);

+                    c1 = vec_mergel(t0, t1);

+                    d2 = vec_perm(d1, d0, vec_lvsl(0, dst + i));

+                    align = vec_lvsr(0, dst + i);

+                    d0 = vec_perm(d2, c0, align);

+                    d1 = vec_perm(c0, c1, align);

+                    vec_st(d0,  0, dst + i);

+                    d0 = vec_perm(c1, d2, align);

+                    vec_st(d1, 15, dst + i);

+                    vec_st(d0, 31, dst + i);

+                    dst += 8;

+                }

+            } else {

+                for (i = 0; i < len - 7; i += 8) {

+                    t0 = float_to_int16_one_altivec(src[0] + i);

+                    t1 = float_to_int16_one_altivec(src[1] + i);

+                    d0 = vec_mergeh(t0, t1);

+                    d1 = vec_mergel(t0, t1);

+                    vec_st(d0,  0, dst + i);

+                    vec_st(d1, 16, dst + i);

+                    dst += 8;

+                }

+            }

+        } else {

+            DECLARE_ALIGNED(16, int16_t, tmp)[len];

+            int c, j;

+            for (c = 0; c < channels; c++) {

+                float_to_int16_altivec(tmp, src[c], len);

+                for (i = 0, j = c; i < len; i++, j+=channels)

+                    dst[j] = tmp[i];

             }

         }

-   }

+    }

 }

 void ff_fmt_convert_init_altivec(FmtConvertContext *c, AVCodecContext *avctx)

 {

     c->int32_to_float_fmul_scalar = int32_to_float_fmul_scalar_altivec;

-    if(!(avctx->flags & CODEC_FLAG_BITEXACT)) {

+    if (!(avctx->flags & CODEC_FLAG_BITEXACT)) {

         c->float_to_int16 = float_to_int16_altivec;

         c->float_to_int16_interleave = float_to_int16_interleave_altivec;

     }

@@ -29,7 +29,12 @@ static av_cold int v410_decode_init(AVCodecContext *avctx)

     avctx->bits_per_raw_sample = 10;

     if (avctx->width & 1) {

-        av_log(avctx, AV_LOG_WARNING, "v410 requires width to be even.\n");

+        if (avctx->err_recognition & AV_EF_EXPLODE) {

+            av_log(avctx, AV_LOG_ERROR, "v410 requires width to be even, continuing anyway.\n");

+            return AVERROR_INVALIDDATA;

+        } else {

+            av_log(avctx, AV_LOG_WARNING, "v410 requires width to be even.\n");

+        }

     }

     avctx->coded_frame = avcodec_alloc_frame();

@@ -28,7 +28,7 @@ pb_zzzzzzzz77777777: times 8 db -1

 pb_7: times 8 db 7

 pb_zzzz3333zzzzbbbb: db -1,-1,-1,-1,3,3,3,3,-1,-1,-1,-1,11,11,11,11

 pb_zz11zz55zz99zzdd: db -1,-1,1,1,-1,-1,5,5,-1,-1,9,9,-1,-1,13,13

-pb_revwords: db 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1

+pb_revwords: SHUFFLE_MASK_W 7, 6, 5, 4, 3, 2, 1, 0

 pd_16384: times 4 dd 16384

 pb_bswap32: db 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12

@@ -94,7 +94,7 @@ static int zerocodec_decode_frame(AVCodecContext *avctx, void *data,

     if (prev_pic->data[0])

         avctx->release_buffer(avctx, prev_pic);

-    *data_size = sizeof(AVFrame);

+    *data_size       = sizeof(AVFrame);

     *(AVFrame *)data = *pic;

     /* Store the previous frame for use later.

@@ -23,6 +23,8 @@

 #include "libavutil/x86_cpu.h"

 #include "libavfilter/gradfun.h"

+#if HAVE_INLINE_ASM

+

 DECLARE_ALIGNED(16, static const uint16_t, pw_7f)[8] = {0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F};

 DECLARE_ALIGNED(16, static const uint16_t, pw_ff)[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};

@@ -164,10 +166,13 @@ static void gradfun_blur_line_sse2(uint16_t *dc, uint16_t *buf, const uint16_t *

 }

 #endif // HAVE_SSE

+#endif /* HAVE_INLINE_ASM */

+

 av_cold void ff_gradfun_init_x86(GradFunContext *gf)

 {

     int cpu_flags = av_get_cpu_flags();

+#if HAVE_INLINE_ASM

 #if HAVE_MMX2

     if (cpu_flags & AV_CPU_FLAG_MMX2)

         gf->filter_line = gradfun_filter_line_mmx2;

@@ -180,4 +185,5 @@ av_cold void ff_gradfun_init_x86(GradFunContext *gf)

     if (cpu_flags & AV_CPU_FLAG_SSE2)

         gf->blur_line = gradfun_blur_line_sse2;

 #endif

+#endif /* HAVE_INLINE_ASM */

 }

@@ -24,6 +24,8 @@

 #include "libavcodec/x86/dsputil_mmx.h"

 #include "libavfilter/yadif.h"

+#if HAVE_INLINE_ASM

+

 DECLARE_ASM_CONST(16, const xmm_reg, pb_1) = {0x0101010101010101ULL, 0x0101010101010101ULL};

 DECLARE_ASM_CONST(16, const xmm_reg, pw_1) = {0x0001000100010001ULL, 0x0001000100010001ULL};

@@ -49,10 +51,13 @@ DECLARE_ASM_CONST(16, const xmm_reg, pw_1) = {0x0001000100010001ULL, 0x000100010

 #include "yadif_template.c"

 #endif

+#endif /* HAVE_INLINE_ASM */

+

 av_cold void ff_yadif_init_x86(YADIFContext *yadif)

 {

     int cpu_flags = av_get_cpu_flags();

+#if HAVE_INLINE_ASM

 #if HAVE_MMX

     if (cpu_flags & AV_CPU_FLAG_MMX)

         yadif->filter_line = yadif_filter_line_mmx;

@@ -65,4 +70,5 @@ av_cold void ff_yadif_init_x86(YADIFContext *yadif)

     if (cpu_flags & AV_CPU_FLAG_SSSE3)

         yadif->filter_line = yadif_filter_line_ssse3;

 #endif

+#endif /* HAVE_INLINE_ASM */

 }

@@ -374,6 +374,7 @@ OBJS-$(CONFIG_BLURAY_PROTOCOL)           += bluray.o

 OBJS-$(CONFIG_CACHE_PROTOCOL)            += cache.o

 OBJS-$(CONFIG_CONCAT_PROTOCOL)           += concat.o

 OBJS-$(CONFIG_CRYPTO_PROTOCOL)           += crypto.o

+OBJS-$(CONFIG_FFRTMPCRYPT_PROTOCOL)      += rtmpcrypt.o rtmpdh.o

 OBJS-$(CONFIG_FFRTMPHTTP_PROTOCOL)       += rtmphttp.o

 OBJS-$(CONFIG_FILE_PROTOCOL)             += file.o

 OBJS-$(CONFIG_GOPHER_PROTOCOL)           += gopher.o

@@ -386,8 +387,10 @@ OBJS-$(CONFIG_MMST_PROTOCOL)             += mmst.o mms.o asf.o

 OBJS-$(CONFIG_MD5_PROTOCOL)              += md5proto.o

 OBJS-$(CONFIG_PIPE_PROTOCOL)             += file.o

 OBJS-$(CONFIG_RTMP_PROTOCOL)             += rtmpproto.o rtmppkt.o

+OBJS-$(CONFIG_RTMPE_PROTOCOL)            += rtmpproto.o rtmppkt.o

 OBJS-$(CONFIG_RTMPS_PROTOCOL)            += rtmpproto.o rtmppkt.o

 OBJS-$(CONFIG_RTMPT_PROTOCOL)            += rtmpproto.o rtmppkt.o

+OBJS-$(CONFIG_RTMPTE_PROTOCOL)           += rtmpproto.o rtmppkt.o

 OBJS-$(CONFIG_RTMPTS_PROTOCOL)           += rtmpproto.o rtmppkt.o

 OBJS-$(CONFIG_RTP_PROTOCOL)              += rtpproto.o

 OBJS-$(CONFIG_SCTP_PROTOCOL)             += sctp.o

@@ -272,6 +272,7 @@ void av_register_all(void)

     REGISTER_PROTOCOL (CACHE, cache);

     REGISTER_PROTOCOL (CONCAT, concat);

     REGISTER_PROTOCOL (CRYPTO, crypto);

+    REGISTER_PROTOCOL (FFRTMPCRYPT, ffrtmpcrypt);

     REGISTER_PROTOCOL (FFRTMPHTTP, ffrtmphttp);

     REGISTER_PROTOCOL (FILE, file);

     REGISTER_PROTOCOL (GOPHER, gopher);

@@ -284,8 +285,10 @@ void av_register_all(void)

     REGISTER_PROTOCOL (MD5,  md5);

     REGISTER_PROTOCOL (PIPE, pipe);

     REGISTER_PROTOCOL (RTMP, rtmp);

+    REGISTER_PROTOCOL (RTMPE, rtmpe);

     REGISTER_PROTOCOL (RTMPS, rtmps);

     REGISTER_PROTOCOL (RTMPT, rtmpt);

+    REGISTER_PROTOCOL (RTMPTE, rtmpte);

     REGISTER_PROTOCOL (RTMPTS, rtmpts);

     REGISTER_PROTOCOL (RTP, rtp);

     REGISTER_PROTOCOL (SCTP, sctp);

@@ -654,11 +654,7 @@ AVOutputFormat ff_avi_muxer = {

     .mime_type         = "video/x-msvideo",

     .extensions        = "avi",

     .priv_data_size    = sizeof(AVIContext),

-#if CONFIG_LIBMP3LAME_ENCODER

-    .audio_codec       = CODEC_ID_MP3,

-#else

-    .audio_codec       = CODEC_ID_AC3,

-#endif

+    .audio_codec       = CONFIG_LIBMP3LAME ? CODEC_ID_MP3 : CODEC_ID_AC3,

     .video_codec       = CODEC_ID_MPEG4,

     .write_header      = avi_write_header,

     .write_packet      = avi_write_packet,

@@ -570,11 +570,7 @@ AVOutputFormat ff_flv_muxer = {

     .mime_type      = "video/x-flv",

     .extensions     = "flv",

     .priv_data_size = sizeof(FLVContext),

-#if CONFIG_LIBMP3LAME

-    .audio_codec    = CODEC_ID_MP3,

-#else // CONFIG_LIBMP3LAME

-    .audio_codec    = CODEC_ID_ADPCM_SWF,

-#endif // CONFIG_LIBMP3LAME

+    .audio_codec    = CONFIG_LIBMP3LAME ? CODEC_ID_MP3 : CODEC_ID_ADPCM_SWF,

     .video_codec    = CODEC_ID_FLV1,

     .write_header   = flv_write_header,

     .write_packet   = flv_write_packet,

@@ -1311,16 +1311,10 @@ AVOutputFormat ff_matroska_muxer = {

     .mime_type         = "video/x-matroska",

     .extensions        = "mkv",

     .priv_data_size    = sizeof(MatroskaMuxContext),

-#if CONFIG_LIBVORBIS_ENCODER

-    .audio_codec       = CODEC_ID_VORBIS,

-#else

-    .audio_codec       = CODEC_ID_AC3,

-#endif

-#if CONFIG_LIBX264_ENCODER

-    .video_codec       = CODEC_ID_H264,

-#else

-    .video_codec       = CODEC_ID_MPEG4,

-#endif

+    .audio_codec       = CONFIG_LIBVORBIS_ENCODER ?

+                         CODEC_ID_VORBIS : CODEC_ID_AC3,

+    .video_codec       = CONFIG_LIBX264_ENCODER ?

+                         CODEC_ID_H264 : CODEC_ID_MPEG4,

     .write_header      = mkv_write_header,

     .write_packet      = mkv_write_packet,

     .write_trailer     = mkv_write_trailer,

@@ -1355,11 +1349,8 @@ AVOutputFormat ff_matroska_audio_muxer = {

     .mime_type         = "audio/x-matroska",

     .extensions        = "mka",

     .priv_data_size    = sizeof(MatroskaMuxContext),

-#if CONFIG_LIBVORBIS_ENCODER

-    .audio_codec       = CODEC_ID_VORBIS,

-#else

-    .audio_codec       = CODEC_ID_AC3,

-#endif

+    .audio_codec       = CONFIG_LIBVORBIS_ENCODER ?

+                         CODEC_ID_VORBIS : CODEC_ID_AC3,

     .video_codec       = CODEC_ID_NONE,

     .write_header      = mkv_write_header,

     .write_packet      = mkv_write_packet,

@@ -3584,11 +3584,8 @@ AVOutputFormat ff_mov_muxer = {

     .extensions        = "mov",

     .priv_data_size    = sizeof(MOVMuxContext),

     .audio_codec       = CODEC_ID_AAC,

-#if CONFIG_LIBX264_ENCODER

-    .video_codec       = CODEC_ID_H264,

-#else

-    .video_codec       = CODEC_ID_MPEG4,

-#endif

+    .video_codec       = CONFIG_LIBX264_ENCODER ?

+                         CODEC_ID_H264 : CODEC_ID_MPEG4,

     .write_header      = mov_write_header,

     .write_packet      = mov_write_packet,

     .write_trailer     = mov_write_trailer,

@@ -3625,11 +3622,8 @@ AVOutputFormat ff_mp4_muxer = {

     .extensions        = "mp4",

     .priv_data_size    = sizeof(MOVMuxContext),

     .audio_codec       = CODEC_ID_AAC,

-#if CONFIG_LIBX264_ENCODER

-    .video_codec       = CODEC_ID_H264,

-#else

-    .video_codec       = CODEC_ID_MPEG4,

-#endif

+    .video_codec       = CONFIG_LIBX264_ENCODER ?

+                         CODEC_ID_H264 : CODEC_ID_MPEG4,

     .write_header      = mov_write_header,

     .write_packet      = mov_write_packet,

     .write_trailer     = mov_write_trailer,

@@ -3646,11 +3640,8 @@ AVOutputFormat ff_psp_muxer = {

     .extensions        = "mp4,psp",

     .priv_data_size    = sizeof(MOVMuxContext),

     .audio_codec       = CODEC_ID_AAC,

-#if CONFIG_LIBX264_ENCODER

-    .video_codec       = CODEC_ID_H264,

-#else

-    .video_codec       = CODEC_ID_MPEG4,

-#endif

+    .video_codec       = CONFIG_LIBX264_ENCODER ?

+                         CODEC_ID_H264 : CODEC_ID_MPEG4,

     .write_header      = mov_write_header,

     .write_packet      = mov_write_packet,

     .write_trailer     = mov_write_trailer,

@@ -870,13 +870,8 @@ AVOutputFormat ff_nut_muxer = {

     .mime_type      = "video/x-nut",

     .extensions     = "nut",

     .priv_data_size = sizeof(NUTContext),

-#if   CONFIG_LIBVORBIS

-    .audio_codec    = CODEC_ID_VORBIS,

-#elif CONFIG_LIBMP3LAME

-    .audio_codec    = CODEC_ID_MP3,

-#else

-    .audio_codec    = CODEC_ID_MP2,

-#endif

+    .audio_codec    = CONFIG_LIBVORBIS ? CODEC_ID_VORBIS :

+                      CONFIG_LIBMP3LAME ? CODEC_ID_MP3 : CODEC_ID_MP2,

     .video_codec    = CODEC_ID_MPEG4,

     .write_header   = nut_write_header,

     .write_packet   = nut_write_packet,

@@ -29,6 +29,9 @@

 #define RTMP_HANDSHAKE_PACKET_SIZE 1536

+#define HMAC_IPAD_VAL 0x36

+#define HMAC_OPAD_VAL 0x5C

+

 /**

  * emulated Flash client version - 9.0.124.2 on Linux

  * @{

@@ -40,4 +43,29 @@

 #define RTMP_CLIENT_VER4    2

 /** @} */ //version defines

+/**

+ * Calculate HMAC-SHA2 digest for RTMP handshake packets.

+ *

+ * @param src    input buffer

+ * @param len    input buffer length (should be 1536)

+ * @param gap    offset in buffer where 32 bytes should not be taken into account

+ *               when calculating digest (since it will be used to store that digest)

+ * @param key    digest key

+ * @param keylen digest key length

+ * @param dst    buffer where calculated digest will be stored (32 bytes)

+ */

+int ff_rtmp_calc_digest(const uint8_t *src, int len, int gap,

+                        const uint8_t *key, int keylen, uint8_t *dst);

+

+/**

+ * Calculate digest position for RTMP handshake packets.

+ *

+ * @param buf input buffer (should be 1536 bytes)

+ * @param off offset in buffer where to start calculating digest position

+ * @param mod_val value used for computing modulo

+ * @param add_val value added at the end (after computing modulo)

+ */

+int ff_rtmp_calc_digest_pos(const uint8_t *buf, int off, int mod_val,

+                            int add_val);

+

 #endif /* AVFORMAT_RTMP_H */

new file mode 100644

@@ -0,0 +1,334 @@

+/*

+ * RTMPE network protocol

+ * Copyright (c) 2012 Samuel Pitoiset

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+/**

+ * @file

+ * RTMPE protocol

+ */

+

+#include "libavutil/blowfish.h"

+#include "libavutil/intreadwrite.h"

+#include "libavutil/opt.h"

+#include "libavutil/rc4.h"

+#include "libavutil/xtea.h"

+

+#include "internal.h"

+#include "rtmp.h"

+#include "rtmpdh.h"

+#include "rtmpcrypt.h"

+#include "url.h"

+

+/* protocol handler context */

+typedef struct RTMPEContext {

+    const AVClass *class;

+    URLContext   *stream;            ///< TCP stream

+    FF_DH        *dh;                ///< Diffie-Hellman context

+    struct AVRC4 key_in;             ///< RC4 key used for decrypt data

+    struct AVRC4 key_out;            ///< RC4 key used for encrypt data

+    int          handshaked;         ///< flag indicating when the handshake is performed

+    int          tunneling;          ///< use a HTTP connection (RTMPTE)

+} RTMPEContext;

+

+static const uint8_t rtmpe8_keys[16][16] = {

+    { 0xbf, 0xf0, 0x34, 0xb2, 0x11, 0xd9, 0x08, 0x1f,

+      0xcc, 0xdf, 0xb7, 0x95, 0x74, 0x8d, 0xe7, 0x32 },

+    { 0x08, 0x6a, 0x5e, 0xb6, 0x17, 0x43, 0x09, 0x0e,

+      0x6e, 0xf0, 0x5a, 0xb8, 0xfe, 0x5a, 0x39, 0xe2 },

+    { 0x7b, 0x10, 0x95, 0x6f, 0x76, 0xce, 0x05, 0x21,

+      0x23, 0x88, 0xa7, 0x3a, 0x44, 0x01, 0x49, 0xa1 },

+    { 0xa9, 0x43, 0xf3, 0x17, 0xeb, 0xf1, 0x1b, 0xb2,

+      0xa6, 0x91, 0xa5, 0xee, 0x17, 0xf3, 0x63, 0x39 },

+    { 0x7a, 0x30, 0xe0, 0x0a, 0xb5, 0x29, 0xe2, 0x2c,

+      0xa0, 0x87, 0xae, 0xa5, 0xc0, 0xcb, 0x79, 0xac },

+    { 0xbd, 0xce, 0x0c, 0x23, 0x2f, 0xeb, 0xde, 0xff,

+      0x1c, 0xfa, 0xae, 0x16, 0x11, 0x23, 0x23, 0x9d },

+    { 0x55, 0xdd, 0x3f, 0x7b, 0x77, 0xe7, 0xe6, 0x2e,

+      0x9b, 0xb8, 0xc4, 0x99, 0xc9, 0x48, 0x1e, 0xe4 },

+    { 0x40, 0x7b, 0xb6, 0xb4, 0x71, 0xe8, 0x91, 0x36,

+      0xa7, 0xae, 0xbf, 0x55, 0xca, 0x33, 0xb8, 0x39 },

+    { 0xfc, 0xf6, 0xbd, 0xc3, 0xb6, 0x3c, 0x36, 0x97,

+      0x7c, 0xe4, 0xf8, 0x25, 0x04, 0xd9, 0x59, 0xb2 },

+    { 0x28, 0xe0, 0x91, 0xfd, 0x41, 0x95, 0x4c, 0x4c,

+      0x7f, 0xb7, 0xdb, 0x00, 0xe3, 0xa0, 0x66, 0xf8 },

+    { 0x57, 0x84, 0x5b, 0x76, 0x4f, 0x25, 0x1b, 0x03,

+      0x46, 0xd4, 0x5b, 0xcd, 0xa2, 0xc3, 0x0d, 0x29 },

+    { 0x0a, 0xcc, 0xee, 0xf8, 0xda, 0x55, 0xb5, 0x46,

+      0x03, 0x47, 0x34, 0x52, 0x58, 0x63, 0x71, 0x3b },

+    { 0xb8, 0x20, 0x75, 0xdc, 0xa7, 0x5f, 0x1f, 0xee,

+      0xd8, 0x42, 0x68, 0xe8, 0xa7, 0x2a, 0x44, 0xcc },

+    { 0x07, 0xcf, 0x6e, 0x9e, 0xa1, 0x6d, 0x7b, 0x25,

+      0x9f, 0xa7, 0xae, 0x6c, 0xd9, 0x2f, 0x56, 0x29 },

+    { 0xfe, 0xb1, 0xea, 0xe4, 0x8c, 0x8c, 0x3c, 0xe1,

+      0x4e, 0x00, 0x64, 0xa7, 0x6a, 0x38, 0x7c, 0x2a },

+    { 0x89, 0x3a, 0x94, 0x27, 0xcc, 0x30, 0x13, 0xa2,

+      0xf1, 0x06, 0x38, 0x5b, 0xa8, 0x29, 0xf9, 0x27 }

+};

+

+static const uint8_t rtmpe9_keys[16][24] = {

+    { 0x79, 0x34, 0x77, 0x4c, 0x67, 0xd1, 0x38, 0x3a, 0xdf, 0xb3, 0x56, 0xbe,

+      0x8b, 0x7b, 0xd0, 0x24, 0x38, 0xe0, 0x73, 0x58, 0x41, 0x5d, 0x69, 0x67, },

+    { 0x46, 0xf6, 0xb4, 0xcc, 0x01, 0x93, 0xe3, 0xa1, 0x9e, 0x7d, 0x3c, 0x65,

+      0x55, 0x86, 0xfd, 0x09, 0x8f, 0xf7, 0xb3, 0xc4, 0x6f, 0x41, 0xca, 0x5c, },

+    { 0x1a, 0xe7, 0xe2, 0xf3, 0xf9, 0x14, 0x79, 0x94, 0xc0, 0xd3, 0x97, 0x43,

+      0x08, 0x7b, 0xb3, 0x84, 0x43, 0x2f, 0x9d, 0x84, 0x3f, 0x21, 0x01, 0x9b, },

+    { 0xd3, 0xe3, 0x54, 0xb0, 0xf7, 0x1d, 0xf6, 0x2b, 0x5a, 0x43, 0x4d, 0x04,

+      0x83, 0x64, 0x3e, 0x0d, 0x59, 0x2f, 0x61, 0xcb, 0xb1, 0x6a, 0x59, 0x0d, },

+    { 0xc8, 0xc1, 0xe9, 0xb8, 0x16, 0x56, 0x99, 0x21, 0x7b, 0x5b, 0x36, 0xb7,

+      0xb5, 0x9b, 0xdf, 0x06, 0x49, 0x2c, 0x97, 0xf5, 0x95, 0x48, 0x85, 0x7e, },

+    { 0xeb, 0xe5, 0xe6, 0x2e, 0xa4, 0xba, 0xd4, 0x2c, 0xf2, 0x16, 0xe0, 0x8f,

+      0x66, 0x23, 0xa9, 0x43, 0x41, 0xce, 0x38, 0x14, 0x84, 0x95, 0x00, 0x53, },

+    { 0x66, 0xdb, 0x90, 0xf0, 0x3b, 0x4f, 0xf5, 0x6f, 0xe4, 0x9c, 0x20, 0x89,

+      0x35, 0x5e, 0xd2, 0xb2, 0xc3, 0x9e, 0x9f, 0x7f, 0x63, 0xb2, 0x28, 0x81, },

+    { 0xbb, 0x20, 0xac, 0xed, 0x2a, 0x04, 0x6a, 0x19, 0x94, 0x98, 0x9b, 0xc8,

+      0xff, 0xcd, 0x93, 0xef, 0xc6, 0x0d, 0x56, 0xa7, 0xeb, 0x13, 0xd9, 0x30, },

+    { 0xbc, 0xf2, 0x43, 0x82, 0x09, 0x40, 0x8a, 0x87, 0x25, 0x43, 0x6d, 0xe6,

+      0xbb, 0xa4, 0xb9, 0x44, 0x58, 0x3f, 0x21, 0x7c, 0x99, 0xbb, 0x3f, 0x24, },

+    { 0xec, 0x1a, 0xaa, 0xcd, 0xce, 0xbd, 0x53, 0x11, 0xd2, 0xfb, 0x83, 0xb6,

+      0xc3, 0xba, 0xab, 0x4f, 0x62, 0x79, 0xe8, 0x65, 0xa9, 0x92, 0x28, 0x76, },

+    { 0xc6, 0x0c, 0x30, 0x03, 0x91, 0x18, 0x2d, 0x7b, 0x79, 0xda, 0xe1, 0xd5,

+      0x64, 0x77, 0x9a, 0x12, 0xc5, 0xb1, 0xd7, 0x91, 0x4f, 0x96, 0x4c, 0xa3, },

+    { 0xd7, 0x7c, 0x2a, 0xbf, 0xa6, 0xe7, 0x85, 0x7c, 0x45, 0xad, 0xff, 0x12,

+      0x94, 0xd8, 0xde, 0xa4, 0x5c, 0x3d, 0x79, 0xa4, 0x44, 0x02, 0x5d, 0x22, },

+    { 0x16, 0x19, 0x0d, 0x81, 0x6a, 0x4c, 0xc7, 0xf8, 0xb8, 0xf9, 0x4e, 0xcd,

+      0x2c, 0x9e, 0x90, 0x84, 0xb2, 0x08, 0x25, 0x60, 0xe1, 0x1e, 0xae, 0x18, },

+    { 0xe9, 0x7c, 0x58, 0x26, 0x1b, 0x51, 0x9e, 0x49, 0x82, 0x60, 0x61, 0xfc,

+      0xa0, 0xa0, 0x1b, 0xcd, 0xf5, 0x05, 0xd6, 0xa6, 0x6d, 0x07, 0x88, 0xa3, },

+    { 0x2b, 0x97, 0x11, 0x8b, 0xd9, 0x4e, 0xd9, 0xdf, 0x20, 0xe3, 0x9c, 0x10,

+      0xe6, 0xa1, 0x35, 0x21, 0x11, 0xf9, 0x13, 0x0d, 0x0b, 0x24, 0x65, 0xb2, },

+    { 0x53, 0x6a, 0x4c, 0x54, 0xac, 0x8b, 0x9b, 0xb8, 0x97, 0x29, 0xfc, 0x60,

+      0x2c, 0x5b, 0x3a, 0x85, 0x68, 0xb5, 0xaa, 0x6a, 0x44, 0xcd, 0x3f, 0xa7, },

+};

+

+int ff_rtmpe_gen_pub_key(URLContext *h, uint8_t *buf)

+{

+    RTMPEContext *rt = h->priv_data;

+    int offset, ret;

+

+    if (!(rt->dh = ff_dh_init(1024)))

+        return AVERROR(ENOMEM);

+

+    offset = ff_rtmp_calc_digest_pos(buf, 768, 632, 8);

+    if (offset < 0)

+        return offset;

+

+    /* generate a Diffie-Hellmann public key */

+    if ((ret = ff_dh_generate_public_key(rt->dh)) < 0)

+        return ret;

+

+    /* write the public key into the handshake buffer */

+    if ((ret = ff_dh_write_public_key(rt->dh, buf + offset, 128)) < 0)

+        return ret;

+

+    return 0;

+}

+

+int ff_rtmpe_compute_secret_key(URLContext *h, const uint8_t *serverdata,

+                                const uint8_t *clientdata, int type)

+{

+    RTMPEContext *rt = h->priv_data;

+    uint8_t secret_key[128], digest[32];

+    int server_pos, client_pos;

+    int ret;

+

+    if (type) {

+        if ((server_pos = ff_rtmp_calc_digest_pos(serverdata, 1532, 632, 772)) < 0)

+            return server_pos;

+    } else {

+        if ((server_pos = ff_rtmp_calc_digest_pos(serverdata, 768, 632, 8)) < 0)

+            return server_pos;

+    }

+

+    if ((client_pos = ff_rtmp_calc_digest_pos(clientdata, 768, 632, 8)) < 0)

+        return client_pos;

+

+    /* compute the shared secret secret in order to compute RC4 keys */

+    if ((ret = ff_dh_compute_shared_secret_key(rt->dh, serverdata + server_pos,

+                                               128, secret_key)) < 0)

+        return ret;

+

+    /* set output key */

+    if ((ret = ff_rtmp_calc_digest(serverdata + server_pos, 128, 0, secret_key,

+                                   128, digest)) < 0)

+        return ret;

+    av_rc4_init(&rt->key_out, digest, 16 * 8, 1);

+

+    /* set input key */