├── test ├── dump.sh ├── play.sh ├── www │ ├── bg.jpg │ ├── jwplayer_old │ │ ├── player.swf │ │ └── swfobject.js │ ├── jwplayer │ │ └── jwplayer.flash.swf │ ├── index.html │ └── record.html ├── ffstream.sh ├── rtmp-publisher │ ├── RtmpPlayer.swf │ ├── RtmpPublisher.swf │ ├── RtmpPlayerLight.swf │ ├── README.md │ ├── publisher.html │ ├── player.html │ ├── RtmpPlayer.mxml │ ├── RtmpPublisher.mxml │ ├── RtmpPlayerLight.mxml │ └── swfobject.js ├── README.md └── nginx.conf ├── .gitignore ├── AUTHORS ├── ngx_rtmp_version.h ├── ngx_rtmp_proxy_protocol.h ├── ngx_rtmp_streams.h ├── doc ├── debug_log.md ├── faq.md ├── installing_ubuntu_using_ppas.md ├── README.md ├── installing_in_gentoo.md ├── getting_number_of_subscribers.md ├── exec_wrapper_in_bash.md ├── examples.md ├── tutorial.md ├── control_modul.md └── getting_started.md ├── ngx_rtmp_bandwidth.c ├── ngx_rtmp_bandwidth.h ├── ngx_rtmp_eval.h ├── hls ├── ngx_rtmp_mpegts.h ├── ngx_rtmp_mpegts_crc.h ├── ngx_rtmp_mpegts_crc.c └── ngx_rtmp_mpegts.c ├── ngx_rtmp_bitop.c ├── ngx_rtmp_bitop.h ├── LICENSE ├── dash └── ngx_rtmp_mp4.h ├── ngx_rtmp_amf.h ├── ngx_rtmp_netcall_module.h ├── ngx_rtmp_relay_module.h ├── ngx_rtmp_play_module.h ├── ngx_rtmp_codec_module.h ├── ngx_rtmp_live_module.h ├── ngx_rtmp_shared.c ├── ngx_rtmp_record_module.h ├── ngx_rtmp_proxy_protocol.c ├── ngx_rtmp_cmd_module.h ├── config ├── ngx_rtmp_limit_module.c ├── ngx_rtmp_eval.c ├── ngx_rtmp_init.c ├── README.md ├── stat.xsl ├── ngx_rtmp_receive.c └── ngx_rtmp_access_module.c /test/dump.sh: -------------------------------------------------------------------------------- 1 | rtmpdump -v -r "rtmp://localhost/myapp/mystream" 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /.idea 2 | /.settings 3 | /.project 4 | /.cproject 5 | /.vscode 6 | -------------------------------------------------------------------------------- /test/play.sh: -------------------------------------------------------------------------------- 1 | ffplay -loglevel verbose "rtmp://localhost/myapp/mystream" 2 | -------------------------------------------------------------------------------- /test/www/bg.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sergey-dryabzhinsky/nginx-rtmp-module/dev/test/www/bg.jpg -------------------------------------------------------------------------------- /test/ffstream.sh: -------------------------------------------------------------------------------- 1 | ffmpeg -loglevel verbose -re -i ~/movie.avi -f flv rtmp://localhost/myapp/mystream 2 | -------------------------------------------------------------------------------- /test/www/jwplayer_old/player.swf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sergey-dryabzhinsky/nginx-rtmp-module/dev/test/www/jwplayer_old/player.swf -------------------------------------------------------------------------------- /test/rtmp-publisher/RtmpPlayer.swf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sergey-dryabzhinsky/nginx-rtmp-module/dev/test/rtmp-publisher/RtmpPlayer.swf -------------------------------------------------------------------------------- /test/rtmp-publisher/RtmpPublisher.swf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sergey-dryabzhinsky/nginx-rtmp-module/dev/test/rtmp-publisher/RtmpPublisher.swf -------------------------------------------------------------------------------- /test/www/jwplayer/jwplayer.flash.swf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sergey-dryabzhinsky/nginx-rtmp-module/dev/test/www/jwplayer/jwplayer.flash.swf -------------------------------------------------------------------------------- /test/rtmp-publisher/RtmpPlayerLight.swf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sergey-dryabzhinsky/nginx-rtmp-module/dev/test/rtmp-publisher/RtmpPlayerLight.swf -------------------------------------------------------------------------------- /AUTHORS: -------------------------------------------------------------------------------- 1 | Project author: 2 | 3 | Roman Arutyunyan 4 | Moscow, Russia 5 | 6 | Contacts: 7 | arut@qip.ru 8 | arutyunyan.roman@gmail.com 9 | 10 | Fork author: 11 | Sergey Dryanzhinsky 12 | Moscow, Russia 13 | 14 | Contacts: 15 | sergey.dryabzhinsky@gmail.com 16 | -------------------------------------------------------------------------------- /ngx_rtmp_version.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_VERSION_H_INCLUDED_ 8 | #define _NGX_RTMP_VERSION_H_INCLUDED_ 9 | 10 | 11 | #define nginx_rtmp_version 1002002 12 | #define NGINX_RTMP_VERSION "1.2.x-dev" 13 | 14 | 15 | #endif /* _NGX_RTMP_VERSION_H_INCLUDED_ */ 16 | -------------------------------------------------------------------------------- /test/rtmp-publisher/README.md: -------------------------------------------------------------------------------- 1 | # RTMP Publisher 2 | 3 | Simple RTMP publisher. 4 | 5 | Edit the following flashvars in publisher.html & player.html to suite your needs. 6 | 7 | streamer: RTMP endpoint 8 | file: live stream name 9 | 10 | ## Compile 11 | 12 | Install flex sdk http://www.adobe.com/devnet/flex/flex-sdk-download.html 13 | 14 | mxmlc RtmpPublisher.mxml 15 | mxmlc RtmpPlayer.mxml 16 | -------------------------------------------------------------------------------- /ngx_rtmp_proxy_protocol.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_PROXY_PROTOCOL_H_INCLUDED_ 8 | #define _NGX_RTMP_PROXY_PROTOCOL_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include "ngx_rtmp.h" 14 | 15 | 16 | void ngx_rtmp_proxy_protocol(ngx_rtmp_session_t *c); 17 | 18 | 19 | #endif /* _NGX_RTMP_PROXY_PROTOCOL_H_INCLUDED_ */ 20 | -------------------------------------------------------------------------------- /ngx_rtmp_streams.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_STREAMS_H_INCLUDED_ 8 | #define _NGX_RTMP_STREAMS_H_INCLUDED_ 9 | 10 | 11 | #define NGX_RTMP_MSID 1 12 | 13 | #define NGX_RTMP_CSID_AMF_INI 3 14 | #define NGX_RTMP_CSID_AMF 5 15 | #define NGX_RTMP_CSID_AUDIO 6 16 | #define NGX_RTMP_CSID_VIDEO 7 17 | 18 | 19 | #endif /* _NGX_RTMP_STREAMS_H_INCLUDED_ */ 20 | -------------------------------------------------------------------------------- /test/README.md: -------------------------------------------------------------------------------- 1 | # RTMP tests 2 | 3 | nginx.conf is sample config for testing nginx-rtmp. 4 | Please update paths in it before using. 5 | 6 | RTMP port: 1935, HTTP port: 8080 7 | 8 | * http://localhost:8080/ - play myapp/mystream with JWPlayer 9 | * http://localhost:8080/record.html - capture myapp/mystream from webcam with old JWPlayer 10 | * http://localhost:8080/rtmp-publisher/player.html - play myapp/mystream with the test flash applet 11 | * http://localhost:8080/rtmp-publisher/publisher.html - capture myapp/mystream with the test flash applet 12 | -------------------------------------------------------------------------------- /test/www/index.html: -------------------------------------------------------------------------------- 1 | Play | Record 2 |
3 | 4 | 5 |
Loading the player ...
6 | 20 | -------------------------------------------------------------------------------- /test/rtmp-publisher/publisher.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | RTMP Publisher 5 | 6 | 13 | 14 | 15 |
16 |

Flash not installed

17 |
18 | 19 | 20 | -------------------------------------------------------------------------------- /doc/debug_log.md: -------------------------------------------------------------------------------- 1 | # Debug log 2 | 3 | In case you need to solve a streaming problem you might need to watch debug log. 4 | For that configure nginx with *--with-debug* flag. 5 | ```sh 6 | $ cd nginx-X.Y.Z 7 | $ ./configure --add-module=/path/to/nginx-rtmp-module --with-debug ... 8 | ``` 9 | 10 | After compiling set nginx error.log level to *debug* in nginx.conf 11 | ```sh 12 | error_log logs/error.log debug; 13 | ``` 14 | 15 | After that you will have _a lot_ of debug info in error.log. Please grep 16 | what your problem relates to (exec, notify etc) and post to [nginx-rtmp google group](https://groups.google.com/group/nginx-rtmp) to help with solving it. -------------------------------------------------------------------------------- /ngx_rtmp_bandwidth.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | #include "ngx_rtmp_bandwidth.h" 10 | 11 | 12 | void 13 | ngx_rtmp_update_bandwidth(ngx_rtmp_bandwidth_t *bw, uint32_t bytes) 14 | { 15 | if (ngx_cached_time->sec > bw->intl_end) { 16 | bw->bandwidth = ngx_cached_time->sec > 17 | bw->intl_end + NGX_RTMP_BANDWIDTH_INTERVAL 18 | ? 0 19 | : bw->intl_bytes / NGX_RTMP_BANDWIDTH_INTERVAL; 20 | bw->intl_bytes = 0; 21 | bw->intl_end = ngx_cached_time->sec + NGX_RTMP_BANDWIDTH_INTERVAL; 22 | } 23 | 24 | bw->bytes += bytes; 25 | bw->intl_bytes += bytes; 26 | } 27 | -------------------------------------------------------------------------------- /test/rtmp-publisher/player.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | RTMP Player 5 | 6 | 16 | 17 | 18 |
19 |

Flash not installed

20 |
21 | 22 | 23 | -------------------------------------------------------------------------------- /ngx_rtmp_bandwidth.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_BANDWIDTH_H_INCLUDED_ 8 | #define _NGX_RTMP_BANDWIDTH_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | 14 | 15 | /* Bandwidth update interval in seconds */ 16 | #define NGX_RTMP_BANDWIDTH_INTERVAL 10 17 | 18 | 19 | typedef struct { 20 | uint64_t bytes; 21 | uint64_t bandwidth; /* bytes/sec */ 22 | 23 | time_t intl_end; 24 | uint64_t intl_bytes; 25 | } ngx_rtmp_bandwidth_t; 26 | 27 | 28 | void ngx_rtmp_update_bandwidth(ngx_rtmp_bandwidth_t *bw, uint32_t bytes); 29 | 30 | 31 | #endif /* _NGX_RTMP_BANDWIDTH_H_INCLUDED_ */ 32 | -------------------------------------------------------------------------------- /doc/faq.md: -------------------------------------------------------------------------------- 1 | # FAQ 2 | 3 | #### RTMP stream is not played normally in IE, stream stops after several seconds. 4 | 5 | Add this directive to fix the problem 6 | ```sh 7 | wait_video on; 8 | ``` 9 | 10 | #### I use `pull` directive to get stream from remote location. That works for RTMP clients but does not work for HLS. 11 | 12 | Currently HLS clients do not trigger any events. You cannot pull or exec when HLS client connects to server. However you can use static directives `exec_static`, `pull ... static` to pull the stream always. 13 | 14 | #### Seek does not work with flv files recorded by the module. 15 | 16 | To make the files seekable add flv metadata with external software like yamdi, flvmeta or ffmpeg. 17 | ```sh 18 | exec_record_done yamdi -i $path -o /var/videos/$basename; 19 | ``` 20 | 21 | #### Published stream is missing from stats page after some time and clients fail to connect 22 | 23 | Check if you use multiple workers in nginx (`worker_processes`). In such case you have to enable: 24 | ```sh 25 | rtmp_auto_push on; 26 | ``` 27 | -------------------------------------------------------------------------------- /ngx_rtmp_eval.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_EVAL_H_INCLUDED_ 8 | #define _NGX_RTMP_EVAL_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include "ngx_rtmp.h" 14 | 15 | 16 | typedef struct ngx_rtmp_eval_s ngx_rtmp_eval_t; 17 | 18 | 19 | typedef void (* ngx_rtmp_eval_pt)(void *ctx, ngx_rtmp_eval_t *e, 20 | ngx_str_t *ret); 21 | 22 | 23 | struct ngx_rtmp_eval_s { 24 | ngx_str_t name; 25 | ngx_rtmp_eval_pt handler; 26 | ngx_uint_t offset; 27 | }; 28 | 29 | 30 | #define ngx_rtmp_null_eval { ngx_null_string, NULL, 0 } 31 | 32 | 33 | /* standard session eval variables */ 34 | extern ngx_rtmp_eval_t ngx_rtmp_eval_session[]; 35 | 36 | 37 | ngx_int_t ngx_rtmp_eval(void *ctx, ngx_str_t *in, ngx_rtmp_eval_t **e, 38 | ngx_str_t *out, ngx_log_t *log); 39 | 40 | 41 | ngx_int_t ngx_rtmp_eval_streams(ngx_str_t *in); 42 | 43 | 44 | #endif /* _NGX_RTMP_EVAL_H_INCLUDED_ */ 45 | -------------------------------------------------------------------------------- /doc/installing_ubuntu_using_ppas.md: -------------------------------------------------------------------------------- 1 | # Installing on Ubuntu using PPAs 2 | ```sh 3 | $ sudo apt-get install dpkg-dev 4 | $ sudo apt-get source nginx 5 | $ cd /usr/src/nginx 6 | $ sudo git clone https://github.com/arut/nginx-rtmp-module.git 7 | $ cd nginx-[version-number] 8 | $ sudo vi debian/rules 9 | ``` 10 | 11 | Edit the rules and at then end of the add-modules configuration string add 12 | ```sh 13 | --add-module=/usr/src/nginx/nginx-rtmp-module \ 14 | ``` 15 | 16 | If installing for the first time build nginx dependancies. 17 | ```sh 18 | $ sudo apt-get build-dep nginx 19 | $ dpkg-buildpackage -b 20 | ``` 21 | 22 | (wait for a while while it builds... a really long while... like you might want to go grab a meal) 23 | 24 | ```sh 25 | $ cd .. && sudo dpkg --install nginx-common_1.3.13-1chl1~quantal1_all.deb nginx-full_1.3.13-1chl1~quantal1_amd64.deb 26 | $ sudo service nginx status 27 | $ sudo service nginx start (if nginx isn't running) 28 | ``` 29 | 30 | [Source](http://serverfault.com/questions/227480/installing-optional-nginx-modules-with-apt-get) 31 | -------------------------------------------------------------------------------- /doc/README.md: -------------------------------------------------------------------------------- 1 | # Welcome to the nginx-rtmp-module documentation! 2 | 3 | ## Pages 4 | 5 | * [Control module](control_modul.md) 6 | * [Debug log](debug_log.md) 7 | * [Directives](directives.md) 8 | * [Examples](examples.md) 9 | * [Exec wrapper in bash](exec_wrapper_in_bash.md) 10 | * [FAQ](faq.md) 11 | * [Getting number of subscribers](getting_number_of_subscribers.md) 12 | * [Getting started with nginx rtmp](getting_started.md) 13 | * [Installing in Gentoo](Installing_in_gentoo.md) 14 | * [Installing on Ubuntu using PPAs](installing_ubuntu_using_ppas.md) 15 | * [Tutorial](tutorial.md) 16 | 17 | *Source: https://github.com/arut/nginx-rtmp-module/wiki* 18 | 19 | ## Updates 20 | 21 | * Directives 22 | * Notify 23 | * [on_playlist](directives.md#on_playlist) 24 | * [notify_send_redirect](directives.md#notify_send_redirect) 25 | * Client Caching 26 | * [hls_allow_client_cache](directives.md#hls_allow_client_cache) 27 | * Dash MPD generation 28 | * [dash_clock_compensation](directives.md#dash_clock_compensation) 29 | * [dash_clock_helper_uri](directives.md#dash_clock_helper_uri) 30 | -------------------------------------------------------------------------------- /doc/installing_in_gentoo.md: -------------------------------------------------------------------------------- 1 | # Installing in Gentoo 2 | 3 | ## Download module source code 4 | You have many options: 5 | * Get the zip at https://github.com/arut/nginx-rtmp-module/archive/master.zip 6 | * Or much better, do a git clone (see options in top of https://github.com/arut/nginx-rtmp-module) 7 | * Or get an ebuild from [fem-overlay](http://subversion.fem.tu-ilmenau.de/repository/fem-overlay/trunk/www-servers/nginx/nginx-1.2.5-r1.ebuild). And set the USE flag "nginx_modules_rtmp" or "nginx_modules_rtmp_hls". 8 | 9 | ## Emerge nginx with nginx-rtmp-module 10 | > NGINX_ADD_MODULES="/path/to/nginx-rtmp-module" emerge -va nginx 11 | 12 | Replace `/path/to/` with the actual module's source path. 13 | You can add with this method any number of custom modules. 14 | 15 | To make this change permanent see: 16 | http://wiki.gentoo.org/wiki/Knowledge_Base:Overriding_environment_variables_per_package 17 | 18 | ## Configure nginx 19 | Don't forget to include a rtmp section inside your nginx configuration file located at `/etc/nginx/nginx.conf`. 20 | 21 | See: 22 | * [Getting started](getting_started.md) We already have done _Download, build and install_ Gentoo style ;-) 23 | * [More Examples](examples.md) 24 | * [Reference of all directives](directives.md) 25 | -------------------------------------------------------------------------------- /doc/getting_number_of_subscribers.md: -------------------------------------------------------------------------------- 1 | # Getting number of subscribers 2 | 3 | There's an easy way to display number of clients watching the stream. You need to 4 | 5 | Set up statistics page at location `/stat` 6 | ```sh 7 | location /stat { 8 | rtmp_stat all; 9 | allow 127.0.0.1; 10 | } 11 | ``` 12 | 13 | Create a simple xsl stylesheet `nclients.xsl` extracting number of stream subscribers 14 | ```xsl 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | ``` 28 | 29 | Set up a location returning number of suscribers 30 | ```sh 31 | location /nclients { 32 | proxy_pass http://127.0.0.1/stat; 33 | xslt_stylesheet /www/nclients.xsl app='$arg_app' name='$arg_name'; 34 | add_header Refresh "3; $request_uri"; 35 | } 36 | ``` 37 | 38 | Use HTTP request `http://myserver.com/nclients?app=myapp&name=mystream` to get the number of stream subscribers. This number will be automatically refreshed every 3 seconds when opened in browser or iframe. 39 | -------------------------------------------------------------------------------- /doc/exec_wrapper_in_bash.md: -------------------------------------------------------------------------------- 1 | # Exec wrapper in bash 2 | 3 | You can write exec wrapper in any language. However you should pay attention to termination process. When publisher closes the stream all executed processed get terminated. If you specify wrapper in ```exec``` directive instead of real ffmpeg then you might end up with your ffmpeg still alive and orphaned until it times out reading input data. 4 | 5 | The solution is using signal traps. Here's an example of such wrapper in bash. 6 | 7 | ```sh 8 | #!/bin/bash 9 | 10 | on_die () 11 | { 12 | # kill all children 13 | pkill -KILL -P $$ 14 | } 15 | 16 | trap 'on_die' TERM 17 | ffmpeg -i rtmp://localhost/myapp/$1 -c copy -f flv rtmp://localhost/myapp2/$1 & 18 | wait 19 | ``` 20 | 21 | The script registers SIGTERM handler which terminates child ffmpeg. Default signal sent by nginx-rtmp is SIGKILL which cannot be caught. For the above script to behave as expected you need to change exec kill signal with ```exec_kill_signal``` directive. It accept numeric or symbolic signal name (for POSIX.1-1990 signals). Here's example application. 22 | ```sh 23 | application myapp { 24 | live on; 25 | 26 | exec /var/scripts/exec_wrapper.sh $name; 27 | exec_kill_signal term; 28 | } 29 | 30 | application myapp2 { 31 | live on; 32 | } 33 | ``` 34 | -------------------------------------------------------------------------------- /hls/ngx_rtmp_mpegts.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_MPEGTS_H_INCLUDED_ 8 | #define _NGX_RTMP_MPEGTS_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | #include 16 | 17 | 18 | typedef struct { 19 | ngx_fd_t fd; 20 | ngx_log_t *log; 21 | unsigned encrypt:1; 22 | unsigned size:4; 23 | u_char buf[16]; 24 | u_char iv[16]; 25 | AES_KEY key; 26 | } ngx_rtmp_mpegts_file_t; 27 | 28 | 29 | typedef struct { 30 | uint64_t pts; 31 | uint64_t dts; 32 | ngx_uint_t pid; 33 | ngx_uint_t sid; 34 | ngx_uint_t cc; 35 | unsigned key:1; 36 | } ngx_rtmp_mpegts_frame_t; 37 | 38 | 39 | ngx_int_t ngx_rtmp_mpegts_init_encryption(ngx_rtmp_mpegts_file_t *file, 40 | u_char *key, size_t key_len, uint64_t iv); 41 | ngx_int_t ngx_rtmp_mpegts_open_file(ngx_rtmp_mpegts_file_t *file, u_char *path, 42 | ngx_log_t *log, ngx_rtmp_codec_ctx_t *codec_ctx, ngx_uint_t mpegts_cc); 43 | ngx_int_t ngx_rtmp_mpegts_close_file(ngx_rtmp_mpegts_file_t *file); 44 | ngx_int_t ngx_rtmp_mpegts_write_frame(ngx_rtmp_mpegts_file_t *file, 45 | ngx_rtmp_mpegts_frame_t *f, ngx_buf_t *b); 46 | 47 | 48 | #endif /* _NGX_RTMP_MPEGTS_H_INCLUDED_ */ 49 | -------------------------------------------------------------------------------- /ngx_rtmp_bitop.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | #include "ngx_rtmp_bitop.h" 10 | 11 | 12 | void 13 | ngx_rtmp_bit_init_reader(ngx_rtmp_bit_reader_t *br, u_char *pos, u_char *last) 14 | { 15 | ngx_memzero(br, sizeof(ngx_rtmp_bit_reader_t)); 16 | 17 | br->pos = pos; 18 | br->last = last; 19 | } 20 | 21 | 22 | uint64_t 23 | ngx_rtmp_bit_read(ngx_rtmp_bit_reader_t *br, ngx_uint_t n) 24 | { 25 | uint64_t v; 26 | ngx_uint_t d; 27 | 28 | v = 0; 29 | 30 | while (n) { 31 | 32 | if (br->pos >= br->last) { 33 | br->err = 1; 34 | return 0; 35 | } 36 | 37 | d = (br->offs + n > 8 ? (ngx_uint_t) (8 - br->offs) : n); 38 | 39 | v <<= d; 40 | v += (*br->pos >> (8 - br->offs - d)) & ((u_char) 0xff >> (8 - d)); 41 | 42 | br->offs += d; 43 | n -= d; 44 | 45 | if (br->offs == 8) { 46 | br->pos++; 47 | br->offs = 0; 48 | } 49 | } 50 | 51 | return v; 52 | } 53 | 54 | 55 | uint64_t 56 | ngx_rtmp_bit_read_golomb(ngx_rtmp_bit_reader_t *br) 57 | { 58 | ngx_uint_t n; 59 | 60 | for (n = 0; ngx_rtmp_bit_read(br, 1) == 0 && !br->err; n++); 61 | 62 | return ((uint64_t) 1 << n) + ngx_rtmp_bit_read(br, n) - 1; 63 | } 64 | -------------------------------------------------------------------------------- /ngx_rtmp_bitop.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_BITOP_H_INCLUDED_ 8 | #define _NGX_RTMP_BITOP_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | 14 | 15 | typedef struct { 16 | u_char *pos; 17 | u_char *last; 18 | ngx_uint_t offs; 19 | ngx_uint_t err; 20 | } ngx_rtmp_bit_reader_t; 21 | 22 | 23 | void ngx_rtmp_bit_init_reader(ngx_rtmp_bit_reader_t *br, u_char *pos, 24 | u_char *last); 25 | uint64_t ngx_rtmp_bit_read(ngx_rtmp_bit_reader_t *br, ngx_uint_t n); 26 | uint64_t ngx_rtmp_bit_read_golomb(ngx_rtmp_bit_reader_t *br); 27 | 28 | 29 | #define ngx_rtmp_bit_read_err(br) ((br)->err) 30 | 31 | #define ngx_rtmp_bit_read_eof(br) ((br)->pos == (br)->last) 32 | 33 | #define ngx_rtmp_bit_read_8(br) \ 34 | ((uint8_t) ngx_rtmp_bit_read(br, 8)) 35 | 36 | #define ngx_rtmp_bit_read_16(br) \ 37 | ((uint16_t) ngx_rtmp_bit_read(br, 16)) 38 | 39 | #define ngx_rtmp_bit_read_32(br) \ 40 | ((uint32_t) ngx_rtmp_bit_read(br, 32)) 41 | 42 | #define ngx_rtmp_bit_read_64(br) \ 43 | ((uint64_t) ngx_rtmp_read(br, 64)) 44 | 45 | 46 | #endif /* _NGX_RTMP_BITOP_H_INCLUDED_ */ 47 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2012-2014, Roman Arutyunyan 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are met: 6 | 7 | 1. Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | 2. Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | 13 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 14 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 15 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 16 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 17 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 18 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 19 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 20 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 21 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 22 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 23 | -------------------------------------------------------------------------------- /doc/examples.md: -------------------------------------------------------------------------------- 1 | # Exampled 2 | 3 | ### Simple Video-on-Demand 4 | 5 | ```sh 6 | rtmp { 7 | server { 8 | listen 1935; 9 | application vod { 10 | play /var/flvs; 11 | } 12 | } 13 | } 14 | ``` 15 | 16 | ### Simple live broadcast service 17 | ```sh 18 | rtmp { 19 | server { 20 | listen 1935; 21 | application live { 22 | live on; 23 | } 24 | } 25 | } 26 | ``` 27 | 28 | ### Re-translate remote stream 29 | ```sh 30 | rtmp { 31 | server { 32 | listen 1935; 33 | application tv { 34 | live on; 35 | pull rtmp://cdn.example.com:443/programs/main pageUrl=http://www.example.com/index.html name=maintv; 36 | } 37 | } 38 | } 39 | ``` 40 | 41 | ### Re-translate remote stream with HLS support 42 | ```sh 43 | rtmp { 44 | server { 45 | listen 1935; 46 | application tv { 47 | live on; 48 | hls on; 49 | hls_path /tmp/tv2; 50 | hls_fragment 15s; 51 | 52 | pull rtmp://tv2.example.com:443/root/new name=tv2; 53 | } 54 | } 55 | } 56 | http { 57 | server { 58 | listen 80; 59 | location /tv2 { 60 | alias /tmp/tv2; 61 | } 62 | } 63 | } 64 | ``` 65 | 66 | ### Stream your X screen through RTMP 67 | ```sh 68 | $ ffmpeg -f x11grab -follow_mouse centered -r 25 -s cif -i :0.0 -f flv rtmp://localhost/myapp/screen 69 | ``` 70 | -------------------------------------------------------------------------------- /test/nginx.conf: -------------------------------------------------------------------------------- 1 | worker_processes 1; 2 | 3 | error_log logs/error.log debug; 4 | 5 | events { 6 | worker_connections 1024; 7 | } 8 | 9 | rtmp { 10 | server { 11 | listen 1935; 12 | 13 | application myapp { 14 | live on; 15 | 16 | #record keyframes; 17 | #record_path /tmp; 18 | #record_max_size 128K; 19 | #record_interval 30s; 20 | #record_suffix .this.is.flv; 21 | 22 | #on_publish http://localhost:8080/publish; 23 | #on_play http://localhost:8080/play; 24 | #on_record_done http://localhost:8080/record_done; 25 | } 26 | } 27 | } 28 | 29 | http { 30 | server { 31 | listen 8080; 32 | 33 | location /stat { 34 | rtmp_stat all; 35 | rtmp_stat_stylesheet stat.xsl; 36 | } 37 | 38 | location /stat.xsl { 39 | root /path/to/nginx-rtmp-module/; 40 | } 41 | 42 | location /control { 43 | rtmp_control all; 44 | } 45 | 46 | #location /publish { 47 | # return 201; 48 | #} 49 | 50 | #location /play { 51 | # return 202; 52 | #} 53 | 54 | #location /record_done { 55 | # return 203; 56 | #} 57 | 58 | location /rtmp-publisher { 59 | root /path/to/nginx-rtmp-module/test; 60 | } 61 | 62 | location / { 63 | root /path/to/nginx-rtmp-module/test/www; 64 | } 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /dash/ngx_rtmp_mp4.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | #ifndef _NGX_RTMP_MP4_H_INCLUDED_ 4 | #define _NGX_RTMP_MP4_H_INCLUDED_ 5 | 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | 12 | #define NGX_RTMP_MP4_SAMPLE_SIZE 0x01 13 | #define NGX_RTMP_MP4_SAMPLE_DURATION 0x02 14 | #define NGX_RTMP_MP4_SAMPLE_DELAY 0x04 15 | #define NGX_RTMP_MP4_SAMPLE_KEY 0x08 16 | 17 | 18 | typedef struct { 19 | uint32_t size; 20 | uint32_t duration; 21 | uint32_t delay; 22 | uint32_t timestamp; 23 | unsigned key:1; 24 | } ngx_rtmp_mp4_sample_t; 25 | 26 | 27 | typedef enum { 28 | NGX_RTMP_MP4_FILETYPE_INIT, 29 | NGX_RTMP_MP4_FILETYPE_SEG 30 | } ngx_rtmp_mp4_file_type_t; 31 | 32 | 33 | typedef enum { 34 | NGX_RTMP_MP4_VIDEO_TRACK, 35 | NGX_RTMP_MP4_AUDIO_TRACK 36 | } ngx_rtmp_mp4_track_type_t; 37 | 38 | 39 | ngx_int_t ngx_rtmp_mp4_write_ftyp(ngx_buf_t *b); 40 | ngx_int_t ngx_rtmp_mp4_write_styp(ngx_buf_t *b); 41 | ngx_int_t ngx_rtmp_mp4_write_moov(ngx_rtmp_session_t *s, ngx_buf_t *b, 42 | ngx_rtmp_mp4_track_type_t ttype); 43 | ngx_int_t ngx_rtmp_mp4_write_moof(ngx_buf_t *b, uint32_t earliest_pres_time, 44 | uint32_t sample_count, ngx_rtmp_mp4_sample_t *samples, 45 | ngx_uint_t sample_mask, uint32_t index); 46 | ngx_int_t ngx_rtmp_mp4_write_sidx(ngx_buf_t *b, 47 | ngx_uint_t reference_size, uint32_t earliest_pres_time, 48 | uint32_t latest_pres_time); 49 | ngx_uint_t ngx_rtmp_mp4_write_mdat(ngx_buf_t *b, ngx_uint_t size); 50 | 51 | 52 | #endif /* _NGX_RTMP_MP4_H_INCLUDED_ */ 53 | -------------------------------------------------------------------------------- /test/www/record.html: -------------------------------------------------------------------------------- 1 | Play | Record 2 |
3 | 4 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | -------------------------------------------------------------------------------- /ngx_rtmp_amf.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_AMF_H_INCLUDED_ 8 | #define _NGX_RTMP_AMF_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | 14 | 15 | /* basic types */ 16 | #define NGX_RTMP_AMF_NUMBER 0x00 17 | #define NGX_RTMP_AMF_BOOLEAN 0x01 18 | #define NGX_RTMP_AMF_STRING 0x02 19 | #define NGX_RTMP_AMF_OBJECT 0x03 20 | #define NGX_RTMP_AMF_NULL 0x05 21 | #define NGX_RTMP_AMF_ARRAY_NULL 0x06 22 | #define NGX_RTMP_AMF_MIXED_ARRAY 0x08 23 | #define NGX_RTMP_AMF_END 0x09 24 | #define NGX_RTMP_AMF_ARRAY 0x0a 25 | 26 | /* extended types */ 27 | #define NGX_RTMP_AMF_INT8 0x0100 28 | #define NGX_RTMP_AMF_INT16 0x0101 29 | #define NGX_RTMP_AMF_INT32 0x0102 30 | #define NGX_RTMP_AMF_VARIANT_ 0x0103 31 | 32 | /* r/w flags */ 33 | #define NGX_RTMP_AMF_OPTIONAL 0x1000 34 | #define NGX_RTMP_AMF_TYPELESS 0x2000 35 | #define NGX_RTMP_AMF_CONTEXT 0x4000 36 | 37 | #define NGX_RTMP_AMF_VARIANT (NGX_RTMP_AMF_VARIANT_\ 38 | |NGX_RTMP_AMF_TYPELESS) 39 | 40 | 41 | typedef struct { 42 | ngx_int_t type; 43 | ngx_str_t name; 44 | void *data; 45 | size_t len; 46 | } ngx_rtmp_amf_elt_t; 47 | 48 | 49 | typedef ngx_chain_t * (*ngx_rtmp_amf_alloc_pt)(void *arg); 50 | 51 | 52 | typedef struct { 53 | ngx_chain_t *link, *first; 54 | size_t offset; 55 | ngx_rtmp_amf_alloc_pt alloc; 56 | void *arg; 57 | ngx_log_t *log; 58 | } ngx_rtmp_amf_ctx_t; 59 | 60 | 61 | /* reading AMF */ 62 | ngx_int_t ngx_rtmp_amf_read(ngx_rtmp_amf_ctx_t *ctx, 63 | ngx_rtmp_amf_elt_t *elts, size_t nelts); 64 | 65 | /* writing AMF */ 66 | ngx_int_t ngx_rtmp_amf_write(ngx_rtmp_amf_ctx_t *ctx, 67 | ngx_rtmp_amf_elt_t *elts, size_t nelts); 68 | 69 | 70 | #endif /* _NGX_RTMP_AMF_H_INCLUDED_ */ 71 | 72 | -------------------------------------------------------------------------------- /ngx_rtmp_netcall_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_NETCALL_H_INCLUDED_ 8 | #define _NGX_RTMP_NETCALL_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include "ngx_rtmp.h" 14 | 15 | 16 | typedef ngx_chain_t * (*ngx_rtmp_netcall_create_pt)(ngx_rtmp_session_t *s, 17 | void *arg, ngx_pool_t *pool); 18 | typedef ngx_int_t (*ngx_rtmp_netcall_filter_pt)(ngx_chain_t *in); 19 | typedef ngx_int_t (*ngx_rtmp_netcall_sink_pt)(ngx_rtmp_session_t *s, 20 | ngx_chain_t *in); 21 | typedef ngx_int_t (*ngx_rtmp_netcall_handle_pt)(ngx_rtmp_session_t *s, 22 | void *arg, ngx_chain_t *in); 23 | 24 | #define NGX_RTMP_NETCALL_HTTP_GET 0 25 | #define NGX_RTMP_NETCALL_HTTP_POST 1 26 | 27 | 28 | /* If handle is NULL then netcall is created detached 29 | * which means it's completely independent of RTMP 30 | * session and its result is never visible to anyone. 31 | * 32 | * WARNING: It's not recommended to create non-detached 33 | * netcalls from disconect handlers. Netcall disconnect 34 | * handler which detaches active netcalls is executed 35 | * BEFORE your handler. It leads to a crash 36 | * after netcall connection is closed */ 37 | typedef struct { 38 | ngx_url_t *url; 39 | ngx_rtmp_netcall_create_pt create; 40 | ngx_rtmp_netcall_filter_pt filter; 41 | ngx_rtmp_netcall_sink_pt sink; 42 | ngx_rtmp_netcall_handle_pt handle; 43 | void *arg; 44 | size_t argsize; 45 | } ngx_rtmp_netcall_init_t; 46 | 47 | 48 | ngx_int_t ngx_rtmp_netcall_create(ngx_rtmp_session_t *s, 49 | ngx_rtmp_netcall_init_t *ci); 50 | 51 | 52 | /* HTTP handling */ 53 | ngx_chain_t * ngx_rtmp_netcall_http_format_session(ngx_rtmp_session_t *s, 54 | ngx_pool_t *pool); 55 | ngx_chain_t * ngx_rtmp_netcall_http_format_request(ngx_int_t method, 56 | ngx_str_t *host, ngx_str_t *uri, ngx_chain_t *args, ngx_chain_t *body, 57 | ngx_pool_t *pool, ngx_str_t *content_type); 58 | ngx_chain_t * ngx_rtmp_netcall_http_skip_header(ngx_chain_t *in); 59 | 60 | 61 | /* Memcache handling */ 62 | ngx_chain_t * ngx_rtmp_netcall_memcache_set(ngx_rtmp_session_t *s, 63 | ngx_pool_t *pool, ngx_str_t *key, ngx_str_t *value, 64 | ngx_uint_t flags, ngx_uint_t sec); 65 | 66 | 67 | #endif /* _NGX_RTMP_NETCALL_H_INCLUDED_ */ 68 | -------------------------------------------------------------------------------- /test/rtmp-publisher/RtmpPlayer.mxml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 8 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | -------------------------------------------------------------------------------- /ngx_rtmp_relay_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_RELAY_H_INCLUDED_ 8 | #define _NGX_RTMP_RELAY_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include "ngx_rtmp.h" 14 | 15 | 16 | typedef struct { 17 | ngx_url_t url; 18 | ngx_str_t app; 19 | ngx_str_t name; 20 | ngx_str_t tc_url; 21 | ngx_str_t page_url; 22 | ngx_str_t swf_url; 23 | ngx_str_t flash_ver; 24 | ngx_str_t play_path; 25 | ngx_int_t live; 26 | ngx_int_t start; 27 | ngx_int_t stop; 28 | 29 | void *tag; /* usually module reference */ 30 | void *data; /* module-specific data */ 31 | ngx_uint_t counter; /* mutable connection counter */ 32 | } ngx_rtmp_relay_target_t; 33 | 34 | 35 | typedef struct ngx_rtmp_relay_ctx_s ngx_rtmp_relay_ctx_t; 36 | 37 | struct ngx_rtmp_relay_ctx_s { 38 | ngx_str_t name; 39 | ngx_str_t url; 40 | ngx_log_t log; 41 | ngx_rtmp_session_t *session; 42 | ngx_rtmp_relay_ctx_t *publish; 43 | ngx_rtmp_relay_ctx_t *play; 44 | ngx_rtmp_relay_ctx_t *next; 45 | 46 | ngx_str_t app; 47 | ngx_str_t tc_url; 48 | ngx_str_t page_url; 49 | ngx_str_t swf_url; 50 | ngx_str_t flash_ver; 51 | ngx_str_t play_path; 52 | ngx_int_t live; 53 | ngx_int_t start; 54 | ngx_int_t stop; 55 | 56 | ngx_event_t push_evt; 57 | ngx_event_t *static_evt; 58 | void *tag; 59 | void *data; 60 | }; 61 | 62 | 63 | extern ngx_module_t ngx_rtmp_relay_module; 64 | 65 | 66 | ngx_int_t ngx_rtmp_relay_pull(ngx_rtmp_session_t *s, ngx_str_t *name, 67 | ngx_rtmp_relay_target_t *target); 68 | ngx_int_t ngx_rtmp_relay_push(ngx_rtmp_session_t *s, ngx_str_t *name, 69 | ngx_rtmp_relay_target_t *target); 70 | 71 | 72 | #endif /* _NGX_RTMP_RELAY_H_INCLUDED_ */ 73 | -------------------------------------------------------------------------------- /hls/ngx_rtmp_mpegts_crc.h: -------------------------------------------------------------------------------- 1 | /** 2 | * \file crc.h 3 | * Functions and types for CRC checks. 4 | * 5 | * Generated on Thu May 5 15:32:22 2016, 6 | * by pycrc v0.9, https://pycrc.org 7 | * using the configuration: 8 | * Width = 32 9 | * Poly = 0x04c11db7 10 | * Xor_In = 0xffffffff 11 | * ReflectIn = False 12 | * Xor_Out = 0x00000000 13 | * ReflectOut = False 14 | * Algorithm = table-driven 15 | *****************************************************************************/ 16 | #ifndef _NGX_RTMP_MPEGTS_CRC_H_INCLUDED_ 17 | #define _NGX_RTMP_MPEGTS_CRC_H_INCLUDED_ 18 | 19 | 20 | #include 21 | #include 22 | 23 | #ifdef __cplusplus 24 | extern "C" { 25 | #endif 26 | 27 | 28 | /** 29 | * The definition of the used algorithm. 30 | * 31 | * This is not used anywhere in the generated code, but it may be used by the 32 | * application code to call algoritm-specific code, is desired. 33 | *****************************************************************************/ 34 | #define CRC_ALGO_TABLE_DRIVEN 1 35 | 36 | 37 | /** 38 | * The type of the CRC values. 39 | * 40 | * This type must be big enough to contain at least 32 bits. 41 | *****************************************************************************/ 42 | typedef uint_fast32_t ngx_rtmp_mpegts_crc_t; 43 | 44 | 45 | /** 46 | * Calculate the initial crc value. 47 | * 48 | * \return The initial crc value. 49 | *****************************************************************************/ 50 | static inline ngx_rtmp_mpegts_crc_t ngx_rtmp_mpegts_crc_init(void) 51 | { 52 | return 0xffffffff; 53 | } 54 | 55 | 56 | /** 57 | * Update the crc value with new data. 58 | * 59 | * \param crc The current crc value. 60 | * \param data Pointer to a buffer of \a data_len bytes. 61 | * \param data_len Number of bytes in the \a data buffer. 62 | * \return The updated crc value. 63 | *****************************************************************************/ 64 | ngx_rtmp_mpegts_crc_t ngx_rtmp_mpegts_crc_update(ngx_rtmp_mpegts_crc_t crc, const void *data, size_t data_len); 65 | 66 | 67 | /** 68 | * Calculate the final crc value. 69 | * 70 | * \param crc The current crc value. 71 | * \return The final crc value. 72 | *****************************************************************************/ 73 | static inline ngx_rtmp_mpegts_crc_t ngx_rtmp_mpegts_crc_finalize(ngx_rtmp_mpegts_crc_t crc) 74 | { 75 | return crc ^ 0x00000000; 76 | } 77 | 78 | 79 | #ifdef __cplusplus 80 | } /* closing brace for extern "C" */ 81 | #endif 82 | 83 | #endif /* _NGX_RTMP_MPEGTS_CRC_H_INCLUDED_ */ 84 | -------------------------------------------------------------------------------- /ngx_rtmp_play_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_PLAY_H_INCLUDED_ 8 | #define _NGX_RTMP_PLAY_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include "ngx_rtmp.h" 14 | #include "ngx_rtmp_cmd_module.h" 15 | 16 | 17 | typedef ngx_int_t (*ngx_rtmp_play_init_pt) (ngx_rtmp_session_t *s, 18 | ngx_file_t *f, ngx_int_t aindex, ngx_int_t vindex); 19 | typedef ngx_int_t (*ngx_rtmp_play_done_pt) (ngx_rtmp_session_t *s, 20 | ngx_file_t *f); 21 | typedef ngx_int_t (*ngx_rtmp_play_start_pt) (ngx_rtmp_session_t *s, 22 | ngx_file_t *f); 23 | typedef ngx_int_t (*ngx_rtmp_play_seek_pt) (ngx_rtmp_session_t *s, 24 | ngx_file_t *f, ngx_uint_t offs); 25 | typedef ngx_int_t (*ngx_rtmp_play_stop_pt) (ngx_rtmp_session_t *s, 26 | ngx_file_t *f); 27 | typedef ngx_int_t (*ngx_rtmp_play_send_pt) (ngx_rtmp_session_t *s, 28 | ngx_file_t *f, ngx_uint_t *ts); 29 | 30 | 31 | typedef struct { 32 | ngx_str_t name; 33 | ngx_str_t pfx; 34 | ngx_str_t sfx; 35 | 36 | ngx_rtmp_play_init_pt init; 37 | ngx_rtmp_play_done_pt done; 38 | ngx_rtmp_play_start_pt start; 39 | ngx_rtmp_play_seek_pt seek; 40 | ngx_rtmp_play_stop_pt stop; 41 | ngx_rtmp_play_send_pt send; 42 | } ngx_rtmp_play_fmt_t; 43 | 44 | 45 | typedef struct ngx_rtmp_play_ctx_s ngx_rtmp_play_ctx_t; 46 | 47 | 48 | struct ngx_rtmp_play_ctx_s { 49 | ngx_rtmp_session_t *session; 50 | ngx_file_t file; 51 | ngx_rtmp_play_fmt_t *fmt; 52 | ngx_event_t send_evt; 53 | unsigned playing:1; 54 | unsigned opened:1; 55 | unsigned joined:1; 56 | ngx_uint_t ncrs; 57 | ngx_uint_t nheader; 58 | ngx_uint_t nbody; 59 | size_t pfx_size; 60 | ngx_str_t sfx; 61 | ngx_uint_t file_id; 62 | ngx_int_t aindex, vindex; 63 | ngx_uint_t nentry; 64 | ngx_uint_t post_seek; 65 | u_char name[NGX_RTMP_MAX_NAME]; 66 | ngx_rtmp_play_ctx_t *next; 67 | }; 68 | 69 | 70 | typedef struct { 71 | ngx_str_t *root; 72 | ngx_url_t *url; 73 | } ngx_rtmp_play_entry_t; 74 | 75 | 76 | typedef struct { 77 | ngx_str_t temp_path; 78 | ngx_str_t local_path; 79 | ngx_array_t entries; /* ngx_rtmp_play_entry_t * */ 80 | ngx_uint_t nbuckets; 81 | ngx_rtmp_play_ctx_t **ctx; 82 | } ngx_rtmp_play_app_conf_t; 83 | 84 | 85 | typedef struct { 86 | ngx_array_t fmts; /* ngx_rtmp_play_fmt_t * */ 87 | } ngx_rtmp_play_main_conf_t; 88 | 89 | 90 | extern ngx_module_t ngx_rtmp_play_module; 91 | 92 | 93 | #endif /* _NGX_RTMP_PLAY_H_INCLUDED_ */ 94 | -------------------------------------------------------------------------------- /ngx_rtmp_codec_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_CODEC_H_INCLUDED_ 8 | #define _NGX_RTMP_CODEC_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include "ngx_rtmp.h" 14 | 15 | 16 | /* Audio codecs */ 17 | enum { 18 | /* Uncompressed codec id is actually 0, 19 | * but we use another value for consistency */ 20 | NGX_RTMP_AUDIO_UNCOMPRESSED = 16, 21 | NGX_RTMP_AUDIO_ADPCM = 1, 22 | NGX_RTMP_AUDIO_MP3 = 2, 23 | NGX_RTMP_AUDIO_LINEAR_LE = 3, 24 | NGX_RTMP_AUDIO_NELLY16 = 4, 25 | NGX_RTMP_AUDIO_NELLY8 = 5, 26 | NGX_RTMP_AUDIO_NELLY = 6, 27 | NGX_RTMP_AUDIO_G711A = 7, 28 | NGX_RTMP_AUDIO_G711U = 8, 29 | NGX_RTMP_AUDIO_AAC = 10, 30 | NGX_RTMP_AUDIO_SPEEX = 11, 31 | NGX_RTMP_AUDIO_MP3_8 = 14, 32 | NGX_RTMP_AUDIO_DEVSPEC = 15, 33 | }; 34 | 35 | 36 | /* Video codecs */ 37 | enum { 38 | NGX_RTMP_VIDEO_JPEG = 1, 39 | NGX_RTMP_VIDEO_SORENSON_H263 = 2, 40 | NGX_RTMP_VIDEO_SCREEN = 3, 41 | NGX_RTMP_VIDEO_ON2_VP6 = 4, 42 | NGX_RTMP_VIDEO_ON2_VP6_ALPHA = 5, 43 | NGX_RTMP_VIDEO_SCREEN2 = 6, 44 | NGX_RTMP_VIDEO_H264 = 7 45 | }; 46 | 47 | 48 | u_char * ngx_rtmp_get_audio_codec_name(ngx_uint_t id); 49 | u_char * ngx_rtmp_get_video_codec_name(ngx_uint_t id); 50 | 51 | 52 | typedef struct { 53 | ngx_uint_t width; 54 | ngx_uint_t height; 55 | double duration; 56 | double frame_rate; 57 | double video_data_rate; 58 | double video_keyframe_frequency; 59 | ngx_uint_t video_codec_id; 60 | double audio_data_rate; 61 | ngx_uint_t audio_codec_id; 62 | ngx_uint_t aac_profile; 63 | ngx_uint_t aac_chan_conf; 64 | ngx_uint_t aac_sbr; 65 | ngx_uint_t aac_ps; 66 | ngx_uint_t avc_profile; 67 | ngx_uint_t avc_compat; 68 | ngx_uint_t avc_level; 69 | ngx_uint_t avc_nal_bytes; 70 | ngx_uint_t avc_ref_frames; 71 | ngx_uint_t sample_rate; /* 5512, 11025, 22050, 44100 */ 72 | ngx_uint_t sample_size; /* 1=8bit, 2=16bit */ 73 | ngx_uint_t audio_channels; /* 1, 2 */ 74 | u_char profile[32]; 75 | u_char level[32]; 76 | 77 | ngx_chain_t *avc_header; 78 | ngx_chain_t *aac_header; 79 | 80 | ngx_chain_t *meta; 81 | ngx_uint_t meta_version; 82 | } ngx_rtmp_codec_ctx_t; 83 | 84 | 85 | extern ngx_module_t ngx_rtmp_codec_module; 86 | 87 | 88 | #endif /* _NGX_RTMP_LIVE_H_INCLUDED_ */ 89 | -------------------------------------------------------------------------------- /ngx_rtmp_live_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_LIVE_H_INCLUDED_ 8 | #define _NGX_RTMP_LIVE_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include "ngx_rtmp.h" 14 | #include "ngx_rtmp_cmd_module.h" 15 | #include "ngx_rtmp_bandwidth.h" 16 | #include "ngx_rtmp_streams.h" 17 | 18 | 19 | typedef struct ngx_rtmp_live_ctx_s ngx_rtmp_live_ctx_t; 20 | typedef struct ngx_rtmp_live_stream_s ngx_rtmp_live_stream_t; 21 | 22 | 23 | typedef struct { 24 | unsigned active:1; 25 | uint32_t timestamp; 26 | uint32_t csid; 27 | uint32_t dropped; 28 | } ngx_rtmp_live_chunk_stream_t; 29 | 30 | 31 | struct ngx_rtmp_live_ctx_s { 32 | ngx_rtmp_session_t *session; 33 | ngx_rtmp_live_stream_t *stream; 34 | ngx_rtmp_live_ctx_t *next; 35 | ngx_uint_t ndropped; 36 | ngx_rtmp_live_chunk_stream_t cs[3]; 37 | ngx_uint_t meta_version; 38 | ngx_event_t idle_evt; 39 | unsigned active:1; 40 | unsigned publishing:1; 41 | unsigned silent:1; 42 | unsigned paused:1; 43 | }; 44 | 45 | 46 | struct ngx_rtmp_live_stream_s { 47 | u_char name[NGX_RTMP_MAX_NAME]; 48 | ngx_rtmp_live_stream_t *next; 49 | ngx_rtmp_live_ctx_t *ctx; 50 | ngx_rtmp_bandwidth_t bw_in; 51 | ngx_rtmp_bandwidth_t bw_in_audio; 52 | ngx_rtmp_bandwidth_t bw_in_video; 53 | ngx_rtmp_bandwidth_t bw_in_data; 54 | ngx_rtmp_bandwidth_t bw_out; 55 | ngx_msec_t epoch; 56 | unsigned active:1; 57 | unsigned publishing:1; 58 | }; 59 | 60 | 61 | typedef struct { 62 | ngx_int_t nbuckets; 63 | ngx_rtmp_live_stream_t **streams; 64 | ngx_flag_t live; 65 | ngx_flag_t meta; 66 | ngx_msec_t sync; 67 | ngx_msec_t idle_timeout; 68 | ngx_flag_t atc; 69 | ngx_flag_t interleave; 70 | ngx_flag_t wait_key; 71 | ngx_flag_t wait_video; 72 | ngx_flag_t publish_notify; 73 | ngx_flag_t play_restart; 74 | ngx_flag_t idle_streams; 75 | ngx_flag_t buffer; 76 | ngx_pool_t *pool; 77 | ngx_rtmp_live_stream_t *free_streams; 78 | } ngx_rtmp_live_app_conf_t; 79 | 80 | 81 | extern ngx_module_t ngx_rtmp_live_module; 82 | 83 | 84 | #endif /* _NGX_RTMP_LIVE_H_INCLUDED_ */ 85 | -------------------------------------------------------------------------------- /test/rtmp-publisher/RtmpPublisher.mxml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 8 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | -------------------------------------------------------------------------------- /doc/tutorial.md: -------------------------------------------------------------------------------- 1 | # Tutorial 2 | 3 | [This article is not finished yet] 4 | 5 | ## RTMP 6 | RTMP is a proprietary protocol developed by Adobe (Macromedia) for use 7 | in flash player. Until 2009 it had no public specification. 8 | A number of third-party RTMP-related products started in that period 9 | were based on the results of reverse engineering. In 2009 10 | [RTMP specification](http://www.adobe.com/devnet/rtmp.html) has been 11 | published which made developing such applications easier. However 12 | the spec is not full and misses significant issues concerning streaming H264. 13 | 14 | ## System requirements 15 | The module has been tested on Linux x86-family platforms. 16 | However it should work on FreeBSD too. 17 | 18 | ## Licence 19 | The module is distributed under BSD license. 20 | 21 | ## Building NGINX with the module 22 | Building is pretty obvious. Just cd to nginx source directory 23 | and configure nginx this way: 24 | ```sh 25 | $ ./configure --add-module=/path/to/nginx-rtmp-module 26 | ``` 27 | 28 | Then `make` and `make install`. 29 | 30 | ## Configuration 31 | 32 | ## Simple live application 33 | Simple live application configuration: 34 | ```sh 35 | application live { 36 | 37 | live on; 38 | 39 | } 40 | ``` 41 | 42 | You can add access list control: 43 | ```sh 44 | application live { 45 | 46 | live on; 47 | 48 | allow publish 127.0.0.1; 49 | deny publish all; 50 | allow play all; 51 | 52 | } 53 | ``` 54 | 55 | And you can add record support for live streams: 56 | ```sh 57 | application live { 58 | 59 | live on; 60 | 61 | allow publish 127.0.0.1; 62 | deny publish all; 63 | allow play all; 64 | 65 | record all; 66 | record_path /path/to/record/dir; 67 | record_max_size 100M; 68 | record_unique off; 69 | 70 | } 71 | ``` 72 | 73 | ## HLS (HTTP Live Streaming) 74 | 75 | ## Choosing flash player 76 | To watch RTMP stream in browser one should either develop 77 | flash application for that or use one of available flash 78 | players. The most popular players which are proved to have 79 | no problems with the module are: 80 | 81 | * [JWPlayer](http://www.longtailvideo.com/) 82 | * [FlowPlayer](http://flowplayer.org/) 83 | * [Strobe Media Playback](http://www.osmf.org/strobe_mediaplayback.html) 84 | * [Clappr](https://github.com/globocom/clappr) 85 | 86 | Old versions of JWPlayer (<=4.4) supported capturing video 87 | from webcam. You can find that version in test/ subdirectory. 88 | However audio is not captured by this version of player. 89 | Recent free versions of JWPlayer have no capture capability at 90 | all. 91 | 92 | ## Transcoding streams 93 | You can use exec directive and ffmpeg for transcoding streams. For example: 94 | ```sh 95 | application big { 96 | live on; 97 | exec /usr/bin/ffmpeg -re -i rtmp://localhost:1935/$app/$name -vcodec flv -acodec copy -s 32x32 -f flv rtmp://localhost:1935/small/${name}; 98 | } 99 | application small { 100 | live on; 101 | } 102 | ``` 103 | 104 | ## Video on demand 105 | 106 | ## Distributed streaming 107 | 108 | ## Notifications & access control 109 | 110 | ## Statistics 111 | 112 | ## Verifying session 113 | 114 | ## Utilizing multi-core CPUs 115 | -------------------------------------------------------------------------------- /doc/control_modul.md: -------------------------------------------------------------------------------- 1 | # Control module 2 | 3 | Control module is HTTP module which makes it possible to control rtmp module from outside using HTTP protocol. Here's an example of how to enable control. 4 | ```sh 5 | http { 6 | ... 7 | server { 8 | listen 8080; 9 | server_name localhost; 10 | .... 11 | location /control { 12 | rtmp_control all; 13 | } 14 | } 15 | } 16 | ``` 17 | 18 | There are several sub-modules within control module each controlling a different feature. 19 | 20 | # Record 21 | This sub-module starts and stops recordings created with _manual_ flag. 22 | Syntax: 23 | ```sh 24 | http://server.com/control/record/start|stop?srv=SRV&app=APP&name=NAME&rec=REC 25 | ``` 26 | 27 | * srv=SRV - optional server{} block number within rtmp{} block, default to first server{} block 28 | * app=APP - required application name 29 | * name=NAME - required stream name 30 | * rec=REC - optional recorder name, defaults to root (unnamed) recorder 31 | 32 | Example 33 | ```sh 34 | rtmp { 35 | server { 36 | listen 1935; 37 | application myapp { 38 | live on; 39 | recorder rec1 { 40 | record all manual; 41 | record_suffix all.flv; 42 | record_path /tmp/rec; 43 | record_unique on; 44 | } 45 | } 46 | } 47 | } 48 | ``` 49 | 50 | Publish the stream with the following command 51 | ```sh 52 | $ ffmpeg -i http://someserver.com/mychannel.ts -c:v copy -c:a nellymoser -ar 44100 -ac 1 -f flv rtmp://localhost/myapp/mystream 53 | ``` 54 | 55 | Use the following commands to start and stop recording 56 | ```sh 57 | $ curl "http://localhost:8080/control/record/start?app=myapp&name=mystream&rec=rec1" 58 | § curl "http://localhost:8080/control/record/stop?app=myapp&name=mystream&rec=rec1" 59 | ``` 60 | 61 | if the record start/stop request returns nothing sometimes, you should check if you use multi workers. one worker works great. 62 | 63 | # Drop 64 | This sub-module provides a simple way to drop client connection. 65 | Syntax: 66 | ```sh 67 | http://server.com/control/drop/publisher|subscriber|client? 68 | srv=SRV&app=APP&name=NAME&addr=ADDR&clientid=CLIENTID 69 | ``` 70 | 71 | * srv, app, name - the same as above 72 | * addr - optional client address (the same as returned by rtmp_stat) 73 | * clientid - optional nginx client id (displayed in log and stat) 74 | 75 | The first method ```drop/publisher``` drops publisher connection. The second ```drop/client``` drops every connection matching ```addr``` argument or all clients (including publisher) if ```addr``` is not specified. 76 | 77 | Examples 78 | ```sh 79 | $ curl http://localhost:8080/control/drop/publisher?app=myapp&name=mystream 80 | $ curl http://localhost:8080/control/drop/client?app=myapp&name=mystream 81 | $ curl http://localhost:8080/control/drop/client?app=myapp&name=mystream&addr=192.168.0.1 82 | $ curl http://localhost:8080/control/drop/client?app=myapp&name=mystream&clientid=1 83 | ``` 84 | 85 | # Redirect 86 | Redirect play/publish client to a new stream. 87 | Syntax: 88 | ```sh 89 | http://server.com/control/redirect/publisher|subscriber|client? 90 | srv=SRV&app=APP&name=NAME&addr=ADDR&clientid=CLIENTID&newname=NEWNAME 91 | ``` 92 | 93 | * srv, app, name, addr, clients - the same as above 94 | * newname - new stream name to redirect to 95 | -------------------------------------------------------------------------------- /test/rtmp-publisher/RtmpPlayerLight.mxml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 8 | 97 | 98 | 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /ngx_rtmp_shared.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | #include "ngx_rtmp.h" 10 | 11 | 12 | ngx_chain_t * 13 | ngx_rtmp_alloc_shared_buf(ngx_rtmp_core_srv_conf_t *cscf) 14 | { 15 | u_char *p; 16 | ngx_chain_t *out; 17 | ngx_buf_t *b; 18 | size_t size; 19 | 20 | if (cscf->free) { 21 | out = cscf->free; 22 | cscf->free = out->next; 23 | 24 | } else { 25 | 26 | size = cscf->chunk_size + NGX_RTMP_MAX_CHUNK_HEADER; 27 | 28 | p = ngx_pcalloc(cscf->pool, NGX_RTMP_REFCOUNT_BYTES 29 | + sizeof(ngx_chain_t) 30 | + sizeof(ngx_buf_t) 31 | + size); 32 | if (p == NULL) { 33 | return NULL; 34 | } 35 | 36 | p += NGX_RTMP_REFCOUNT_BYTES; 37 | out = (ngx_chain_t *)p; 38 | 39 | p += sizeof(ngx_chain_t); 40 | out->buf = (ngx_buf_t *)p; 41 | 42 | p += sizeof(ngx_buf_t); 43 | out->buf->start = p; 44 | out->buf->end = p + size; 45 | } 46 | 47 | out->next = NULL; 48 | b = out->buf; 49 | b->pos = b->last = b->start + NGX_RTMP_MAX_CHUNK_HEADER; 50 | b->memory = 1; 51 | 52 | /* buffer has refcount =1 when created! */ 53 | ngx_rtmp_ref_set(out, 1); 54 | 55 | return out; 56 | } 57 | 58 | 59 | void 60 | ngx_rtmp_free_shared_chain(ngx_rtmp_core_srv_conf_t *cscf, ngx_chain_t *in) 61 | { 62 | ngx_chain_t *cl; 63 | 64 | if (ngx_rtmp_ref_put(in)) { 65 | return; 66 | } 67 | 68 | for (cl = in; ; cl = cl->next) { 69 | /* FIXME: Don't create circular chains in the first place */ 70 | if (cl->next == NULL || cl->next == in) { 71 | cl->next = cscf->free; 72 | cscf->free = in; 73 | return; 74 | } 75 | } 76 | } 77 | 78 | 79 | ngx_chain_t * 80 | ngx_rtmp_append_shared_bufs(ngx_rtmp_core_srv_conf_t *cscf, 81 | ngx_chain_t *head, ngx_chain_t *in) 82 | { 83 | ngx_chain_t *l, **ll; 84 | u_char *p; 85 | size_t size; 86 | 87 | ll = &head; 88 | p = in->buf->pos; 89 | l = head; 90 | 91 | if (l) { 92 | for(; l->next; l = l->next); 93 | ll = &l->next; 94 | } 95 | 96 | for ( ;; ) { 97 | 98 | if (l == NULL || l->buf->last == l->buf->end) { 99 | l = ngx_rtmp_alloc_shared_buf(cscf); 100 | if (l == NULL || l->buf == NULL) { 101 | break; 102 | } 103 | 104 | *ll = l; 105 | ll = &l->next; 106 | } 107 | 108 | while (l->buf->end - l->buf->last >= in->buf->last - p) { 109 | l->buf->last = ngx_cpymem(l->buf->last, p, 110 | in->buf->last - p); 111 | in = in->next; 112 | if (in == NULL) { 113 | goto done; 114 | } 115 | p = in->buf->pos; 116 | } 117 | 118 | size = l->buf->end - l->buf->last; 119 | l->buf->last = ngx_cpymem(l->buf->last, p, size); 120 | p += size; 121 | } 122 | 123 | done: 124 | *ll = NULL; 125 | 126 | return head; 127 | } 128 | -------------------------------------------------------------------------------- /ngx_rtmp_record_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_RECORD_H_INCLUDED_ 8 | #define _NGX_RTMP_RECORD_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include "ngx_rtmp.h" 14 | 15 | 16 | #define NGX_RTMP_RECORD_OFF 0x01 17 | #define NGX_RTMP_RECORD_AUDIO 0x02 18 | #define NGX_RTMP_RECORD_VIDEO 0x04 19 | #define NGX_RTMP_RECORD_DATA 0x08 20 | #define NGX_RTMP_RECORD_KEYFRAMES 0x10 21 | #define NGX_RTMP_RECORD_MANUAL 0x20 22 | 23 | typedef struct { 24 | ngx_str_t id; 25 | ngx_uint_t flags; 26 | ngx_str_t path; 27 | size_t max_size; 28 | size_t interval_size; 29 | size_t max_frames; 30 | ngx_msec_t interval; 31 | ngx_str_t suffix; 32 | ngx_flag_t unique; 33 | ngx_flag_t append; 34 | ngx_flag_t lock_file; 35 | ngx_flag_t notify; 36 | ngx_url_t *url; 37 | 38 | void **rec_conf; 39 | ngx_array_t rec; /* ngx_rtmp_record_app_conf_t * */ 40 | } ngx_rtmp_record_app_conf_t; 41 | 42 | 43 | typedef struct { 44 | ngx_rtmp_record_app_conf_t *conf; 45 | ngx_file_t file; 46 | ngx_uint_t nframes; 47 | uint32_t epoch, time_shift; 48 | ngx_time_t last; 49 | time_t timestamp; 50 | unsigned failed:1; 51 | unsigned initialized:1; 52 | unsigned aac_header_sent:1; 53 | unsigned avc_header_sent:1; 54 | unsigned video_key_sent:1; 55 | unsigned audio:1; 56 | unsigned video:1; 57 | unsigned record_started:1; 58 | } ngx_rtmp_record_rec_ctx_t; 59 | 60 | 61 | typedef struct { 62 | ngx_array_t rec; /* ngx_rtmp_record_rec_ctx_t */ 63 | u_char name[NGX_RTMP_MAX_NAME]; 64 | u_char args[NGX_RTMP_MAX_ARGS]; 65 | } ngx_rtmp_record_ctx_t; 66 | 67 | 68 | ngx_uint_t ngx_rtmp_record_find(ngx_rtmp_record_app_conf_t *racf, 69 | ngx_str_t *id); 70 | 71 | 72 | /* Manual recording control, 73 | * 'n' is record node index in config array. 74 | * Note: these functions allocate path in static buffer */ 75 | 76 | ngx_int_t ngx_rtmp_record_open(ngx_rtmp_session_t *s, ngx_uint_t n, 77 | ngx_str_t *path); 78 | ngx_int_t ngx_rtmp_record_close(ngx_rtmp_session_t *s, ngx_uint_t n, 79 | ngx_str_t *path); 80 | 81 | 82 | typedef struct { 83 | ngx_str_t recorder; 84 | ngx_str_t path; 85 | } ngx_rtmp_record_done_t; 86 | 87 | 88 | typedef struct { 89 | ngx_str_t recorder; 90 | ngx_str_t path; 91 | } ngx_rtmp_record_started_t; 92 | 93 | 94 | typedef ngx_int_t (*ngx_rtmp_record_started_pt)(ngx_rtmp_session_t *s, 95 | ngx_rtmp_record_started_t *v); 96 | 97 | 98 | typedef ngx_int_t (*ngx_rtmp_record_done_pt)(ngx_rtmp_session_t *s, 99 | ngx_rtmp_record_done_t *v); 100 | 101 | 102 | extern ngx_rtmp_record_started_pt ngx_rtmp_record_started; 103 | 104 | 105 | extern ngx_rtmp_record_done_pt ngx_rtmp_record_done; 106 | 107 | 108 | extern ngx_module_t ngx_rtmp_record_module; 109 | 110 | 111 | #endif /* _NGX_RTMP_RECORD_H_INCLUDED_ */ 112 | -------------------------------------------------------------------------------- /ngx_rtmp_proxy_protocol.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | #include 10 | #include "ngx_rtmp_proxy_protocol.h" 11 | 12 | 13 | static void ngx_rtmp_proxy_protocol_recv(ngx_event_t *rev); 14 | 15 | 16 | void 17 | ngx_rtmp_proxy_protocol(ngx_rtmp_session_t *s) 18 | { 19 | ngx_event_t *rev; 20 | ngx_connection_t *c; 21 | 22 | c = s->connection; 23 | rev = c->read; 24 | rev->handler = ngx_rtmp_proxy_protocol_recv; 25 | 26 | ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, 27 | "proxy_protocol: start"); 28 | 29 | if (rev->ready) { 30 | /* the deferred accept(), rtsig, aio, iocp */ 31 | 32 | if (ngx_use_accept_mutex) { 33 | ngx_post_event(rev, &ngx_posted_events); 34 | return; 35 | } 36 | 37 | rev->handler(rev); 38 | return; 39 | } 40 | 41 | ngx_add_timer(rev, s->timeout); 42 | 43 | if (ngx_handle_read_event(rev, 0) != NGX_OK) { 44 | ngx_rtmp_finalize_session(s); 45 | return; 46 | } 47 | } 48 | 49 | 50 | static void 51 | ngx_rtmp_proxy_protocol_recv(ngx_event_t *rev) 52 | { 53 | u_char buf[107], *p, *pp, *text; 54 | size_t len; 55 | ssize_t n; 56 | ngx_err_t err; 57 | ngx_int_t i; 58 | ngx_addr_t addr; 59 | ngx_connection_t *c; 60 | ngx_rtmp_session_t *s; 61 | 62 | c = rev->data; 63 | s = c->data; 64 | 65 | if (c->destroyed) { 66 | return; 67 | } 68 | 69 | if (rev->timedout) { 70 | ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, 71 | "proxy_protocol: recv: client timed out"); 72 | c->timedout = 1; 73 | ngx_rtmp_finalize_session(s); 74 | return; 75 | } 76 | 77 | if (rev->timer_set) { 78 | ngx_del_timer(rev); 79 | } 80 | 81 | n = recv(c->fd, (char *) buf, sizeof(buf), MSG_PEEK); 82 | 83 | err = ngx_socket_errno; 84 | 85 | ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0, "recv(): %d", n); 86 | 87 | if (n == -1) { 88 | 89 | if (err == NGX_EAGAIN) { 90 | ngx_add_timer(rev, s->timeout); 91 | 92 | if (ngx_handle_read_event(c->read, 0) != NGX_OK) { 93 | ngx_rtmp_finalize_session(s); 94 | } 95 | 96 | return; 97 | } 98 | 99 | ngx_rtmp_finalize_session(s); 100 | 101 | return; 102 | } 103 | 104 | p = buf; 105 | 106 | if (n <= 8 && ngx_strncmp(p, "PROXY ", 6) != 0) { 107 | goto bad_header; 108 | } 109 | 110 | n -= 6; 111 | p += 6; 112 | 113 | ngx_memzero(&addr, sizeof(ngx_addr_t)); 114 | 115 | if (n >= 7 && ngx_strncmp(p, "UNKNOWN", 7) == 0) { 116 | n -= 7; 117 | p += 7; 118 | goto skip; 119 | } 120 | 121 | if (n < 5 || ngx_strncmp(p, "TCP", 3) != 0 122 | || (p[3] != '4' && p[3] != '6') || p[4] != ' ') 123 | { 124 | goto bad_header; 125 | } 126 | 127 | n -= 5; 128 | p += 5; 129 | 130 | pp = ngx_strlchr(p, p + n, ' '); 131 | 132 | if (pp == NULL) { 133 | goto bad_header; 134 | } 135 | 136 | if (ngx_parse_addr(s->connection->pool, &addr, p, pp - p) != NGX_OK) { 137 | goto bad_header; 138 | } 139 | 140 | n -= pp - p; 141 | p = pp; 142 | 143 | skip: 144 | 145 | for (i = 0; i + 1 < n; i++) { 146 | if (p[i] == CR && p[i + 1] == LF) { 147 | break; 148 | } 149 | } 150 | 151 | if (i + 1 >= n) { 152 | goto bad_header; 153 | } 154 | 155 | n = p - buf + i + 2; 156 | 157 | if (c->recv(c, buf, n) != n) { 158 | goto failed; 159 | } 160 | 161 | if (addr.socklen) { 162 | text = ngx_palloc(s->connection->pool, NGX_SOCKADDR_STRLEN); 163 | 164 | if (text == NULL) { 165 | goto failed; 166 | } 167 | 168 | len = ngx_sock_ntop(addr.sockaddr, 169 | #if (nginx_version >= 1005003) 170 | addr.socklen, 171 | #endif 172 | text, NGX_SOCKADDR_STRLEN, 0); 173 | if (len == 0) { 174 | goto failed; 175 | } 176 | 177 | c->sockaddr = addr.sockaddr; 178 | c->socklen = addr.socklen; 179 | c->addr_text.data = text; 180 | c->addr_text.len = len; 181 | 182 | ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0, 183 | "proxy_protocol: remote_addr:'%V'", &c->addr_text); 184 | } 185 | 186 | ngx_rtmp_handshake(s); 187 | 188 | return; 189 | 190 | bad_header: 191 | 192 | ngx_log_error(NGX_LOG_INFO, c->log, 0, "proxy_protocol: bad header"); 193 | 194 | failed: 195 | 196 | ngx_rtmp_finalize_session(s); 197 | } 198 | -------------------------------------------------------------------------------- /hls/ngx_rtmp_mpegts_crc.c: -------------------------------------------------------------------------------- 1 | /** 2 | * \file crc.c 3 | * Functions and types for CRC checks. 4 | * 5 | * Generated on Thu May 5 15:32:31 2016, 6 | * by pycrc v0.9, https://pycrc.org 7 | * using the configuration: 8 | * Width = 32 9 | * Poly = 0x04c11db7 10 | * Xor_In = 0xffffffff 11 | * ReflectIn = False 12 | * Xor_Out = 0x00000000 13 | * ReflectOut = False 14 | * Algorithm = table-driven 15 | *****************************************************************************/ 16 | #include "ngx_rtmp_mpegts_crc.h" /* include the header file generated with pycrc */ 17 | #include 18 | #include 19 | 20 | /** 21 | * Static table used for the table_driven implementation. 22 | *****************************************************************************/ 23 | static const ngx_rtmp_mpegts_crc_t ngx_rtmp_mpegts_crc_table[256] = { 24 | 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 25 | 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 26 | 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 27 | 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 28 | 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 29 | 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 30 | 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 31 | 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 32 | 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 33 | 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 34 | 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 35 | 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 36 | 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 37 | 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 38 | 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 39 | 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 40 | 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 41 | 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 42 | 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 43 | 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 44 | 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 45 | 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 46 | 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 47 | 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 48 | 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 49 | 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 50 | 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 51 | 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 52 | 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 53 | 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 54 | 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 55 | 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 56 | }; 57 | 58 | /** 59 | * Update the crc value with new data. 60 | * 61 | * \param crc The current crc value. 62 | * \param data Pointer to a buffer of \a data_len bytes. 63 | * \param data_len Number of bytes in the \a data buffer. 64 | * \return The updated crc value. 65 | *****************************************************************************/ 66 | ngx_rtmp_mpegts_crc_t ngx_rtmp_mpegts_crc_update(ngx_rtmp_mpegts_crc_t crc, const void *data, size_t data_len) 67 | { 68 | const unsigned char *d = (const unsigned char *)data; 69 | unsigned int tbl_idx; 70 | 71 | while (data_len--) { 72 | tbl_idx = ((crc >> 24) ^ *d) & 0xff; 73 | crc = (ngx_rtmp_mpegts_crc_table[tbl_idx] ^ (crc << 8)) & 0xffffffff; 74 | 75 | d++; 76 | } 77 | return crc & 0xffffffff; 78 | } 79 | 80 | 81 | -------------------------------------------------------------------------------- /doc/getting_started.md: -------------------------------------------------------------------------------- 1 | # Getting started with nginx rtmp 2 | 3 | ## Download, build and install 4 | 5 | CD to build directory (home) 6 | ```sh 7 | $ cd /usr/build 8 | ``` 9 | 10 | Download & unpack latest nginx-rtmp (you can also use http) 11 | ```sh 12 | $ git clone git://github.com/sergey-dryabzhinsky/nginx-rtmp-module 13 | ``` 14 | 15 | Download & unpack nginx (you can also use svn) 16 | 17 | ```sh 18 | $ wget http://nginx.org/download/nginx-1.2.4.tar.gz 19 | $ tar xzf nginx-1.2.4.tar.gz 20 | $ cd nginx-1.2.4 21 | ``` 22 | 23 | Build nginx with nginx-rtmp 24 | ```sh 25 | $ ./configure --add-module=/usr/build/nginx-rtmp-module 26 | $ make 27 | $ make install 28 | ``` 29 | 30 | For nginx 1.3.4-1.5.0 more options are needed 31 | ```sh 32 | $ ./configure --add-module=/usr/build/nginx-rtmp-module --with-http_ssl_module 33 | $ make 34 | $ make install 35 | ``` 36 | 37 | ## Set up live streaming 38 | 39 | To set up RTMP support you need to add `rtmp{}` section to `nginx.conf` (can be found in PREFIX/conf/nginx.conf). Stock `nginx.conf` contains only `http{}` section. 40 | 41 | Use this `nginx.conf` instead of stock config: 42 | ```sh 43 | #user nobody; 44 | worker_processes 1; 45 | 46 | error_log logs/error.log debug; 47 | 48 | events { 49 | worker_connections 1024; 50 | } 51 | 52 | http { 53 | include mime.types; 54 | default_type application/octet-stream; 55 | 56 | sendfile on; 57 | keepalive_timeout 65; 58 | 59 | server { 60 | listen 8080; 61 | server_name localhost; 62 | 63 | # sample handlers 64 | #location /on_play { 65 | # if ($arg_pageUrl ~* localhost) { 66 | # return 201; 67 | # } 68 | # return 202; 69 | #} 70 | #location /on_publish { 71 | # return 201; 72 | #} 73 | 74 | #location /vod { 75 | # alias /var/myvideos; 76 | #} 77 | 78 | # rtmp stat 79 | location /stat { 80 | rtmp_stat all; 81 | rtmp_stat_stylesheet stat.xsl; 82 | } 83 | location /stat.xsl { 84 | # you can move stat.xsl to a different location 85 | root /usr/build/nginx-rtmp-module; 86 | } 87 | 88 | # rtmp control 89 | location /control { 90 | rtmp_control all; 91 | } 92 | error_page 500 502 503 504 /50x.html; 93 | location = /50x.html { 94 | root html; 95 | } 96 | } 97 | } 98 | rtmp { 99 | server { 100 | listen 1935; 101 | ping 30s; 102 | notify_method get; 103 | 104 | application myapp { 105 | live on; 106 | 107 | # sample play/publish handlers 108 | #on_play http://localhost:8080/on_play; 109 | #on_publish http://localhost:8080/on_publish; 110 | 111 | # sample recorder 112 | #recorder rec1 { 113 | # record all; 114 | # record_interval 30s; 115 | # record_path /tmp; 116 | # record_unique on; 117 | #} 118 | 119 | # sample HLS 120 | #hls on; 121 | #hls_path /tmp/hls; 122 | #hls_sync 100ms; 123 | } 124 | 125 | # Video on demand 126 | #application vod { 127 | # play /var/Videos; 128 | #} 129 | 130 | # Video on demand over HTTP 131 | #application vod_http { 132 | # play http://localhost:8080/vod/; 133 | #} 134 | } 135 | } 136 | ``` 137 | 138 | ## Statistics 139 | 140 | Navigate your browser to `http://localhost:8080/stat` to see current 141 | streaming statistics, connected clients, bandwidth etc. 142 | 143 | ## Publishing with ffmpeg 144 | 145 | The easiest way to publish live video stream is using ffmpeg (or avconv). 146 | It's already installed on most systems and easy to install on others. 147 | 148 | RTMP supports only a limited number of codecs. The most popular RTMP video 149 | codecs are H264, Sorenson-H263 (aka flv) and audio codecs AAC, MP3, 150 | Nellymoser, Speex. If your video is encoded with these codecs 151 | (the most common pair is H264/AAC) then you do not need any conversion. 152 | Otherwise you need to convert video to one of supported codecs. 153 | 154 | We'll stream test file `/var/videos/test.mp4` to server with ffmpeg. 155 | 156 | Streaming without conversion (given `test.mp4` codecs are compatible with RTMP) 157 | ```sh 158 | $ ffmpeg -re -i /var/Videos/test.mp4 -c copy -f flv rtmp://localhost/myapp/mystream 159 | ``` 160 | 161 | Streaming and encoding audio (AAC) and video (H264), need `libx264` and `libfaac` 162 | ```sh 163 | $ ffmpeg -re -i /var/Videos/test.mp4 -c:v libx264 -c:a libfaac -ar 44100 -ac 1 -f flv rtmp://localhost/myapp/mystream 164 | ``` 165 | 166 | Streaming and encoding audio (MP3) and video (H264), need `libx264` and `libmp3lame` 167 | ```sh 168 | $ ffmpeg -re -i /var/Videos/test.mp4 -c:v libx264 -c:a libmp3lame -ar 44100 -ac 1 -f flv rtmp://localhost/myapp/mystream 169 | ``` 170 | 171 | Streaming and encoding audio (Nellymoser) and video (Sorenson H263) 172 | ```sh 173 | $ ffmpeg -re -i /var/Videos/test.mp4 -c:v flv -c:a nellymoser -ar 44100 -ac 1 -f flv rtmp://localhost/myapp/mystream 174 | ``` 175 | 176 | ## Publishing video from webcam 177 | ```sh 178 | $ ffmpeg -f video4linux2 -i /dev/video0 -c:v libx264 -an -f flv rtmp://localhost/myapp/mystream 179 | ``` 180 | 181 | ## Playing with ffplay 182 | ```sh 183 | $ ffplay rtmp://localhost/myapp/mystream 184 | ``` 185 | 186 | ## Publishing and playing with flash 187 | 188 | See `test/rtmp-publisher` directory for test flash applets and html. 189 | -------------------------------------------------------------------------------- /ngx_rtmp_cmd_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #ifndef _NGX_RTMP_CMD_H_INCLUDED_ 8 | #define _NGX_RTMP_CMD_H_INCLUDED_ 9 | 10 | 11 | #include 12 | #include 13 | #include 14 | #include "ngx_rtmp.h" 15 | 16 | 17 | #define NGX_RTMP_MAX_NAME 2048 18 | #define NGX_RTMP_MAX_URL 4096 19 | #define NGX_RTMP_MAX_ARGS NGX_RTMP_MAX_NAME 20 | 21 | 22 | /* Basic RTMP call support */ 23 | 24 | typedef struct { 25 | double trans; 26 | u_char app[NGX_RTMP_MAX_NAME]; 27 | u_char args[NGX_RTMP_MAX_ARGS]; 28 | u_char flashver[64]; 29 | u_char swf_url[NGX_RTMP_MAX_URL]; 30 | u_char tc_url[NGX_RTMP_MAX_URL]; 31 | double acodecs; 32 | double vcodecs; 33 | u_char page_url[NGX_RTMP_MAX_URL]; 34 | double object_encoding; 35 | } ngx_rtmp_connect_t; 36 | 37 | 38 | typedef struct { 39 | double trans; 40 | double stream; 41 | } ngx_rtmp_create_stream_t; 42 | 43 | 44 | typedef struct { 45 | double stream; 46 | } ngx_rtmp_delete_stream_t; 47 | 48 | 49 | typedef struct { 50 | double stream; 51 | } ngx_rtmp_close_stream_t; 52 | 53 | 54 | typedef struct { 55 | u_char name[NGX_RTMP_MAX_NAME]; 56 | u_char args[NGX_RTMP_MAX_ARGS]; 57 | u_char type[16]; 58 | int silent; 59 | } ngx_rtmp_publish_t; 60 | 61 | 62 | typedef struct { 63 | ngx_str_t playlist; 64 | ngx_str_t module; 65 | } ngx_rtmp_playlist_t; 66 | 67 | 68 | typedef struct { 69 | u_char name[NGX_RTMP_MAX_NAME]; 70 | u_char args[NGX_RTMP_MAX_ARGS]; 71 | double start; 72 | double duration; 73 | int reset; 74 | int silent; 75 | } ngx_rtmp_play_t; 76 | 77 | 78 | typedef struct { 79 | double offset; 80 | } ngx_rtmp_seek_t; 81 | 82 | 83 | typedef struct { 84 | uint8_t pause; 85 | double position; 86 | } ngx_rtmp_pause_t; 87 | 88 | 89 | typedef struct { 90 | uint32_t msid; 91 | } ngx_rtmp_msid_t; 92 | 93 | 94 | typedef ngx_rtmp_msid_t ngx_rtmp_stream_begin_t; 95 | typedef ngx_rtmp_msid_t ngx_rtmp_stream_eof_t; 96 | typedef ngx_rtmp_msid_t ngx_rtmp_stream_dry_t; 97 | typedef ngx_rtmp_msid_t ngx_rtmp_recorded_t; 98 | 99 | 100 | typedef struct { 101 | uint32_t msid; 102 | uint32_t buflen; 103 | } ngx_rtmp_set_buflen_t; 104 | 105 | 106 | void ngx_rtmp_cmd_fill_args(u_char name[NGX_RTMP_MAX_NAME], 107 | u_char args[NGX_RTMP_MAX_ARGS]); 108 | 109 | 110 | typedef ngx_int_t (*ngx_rtmp_connect_pt)(ngx_rtmp_session_t *s, 111 | ngx_rtmp_connect_t *v); 112 | typedef ngx_int_t (*ngx_rtmp_disconnect_pt)(ngx_rtmp_session_t *s); 113 | typedef ngx_int_t (*ngx_rtmp_create_stream_pt)(ngx_rtmp_session_t *s, 114 | ngx_rtmp_create_stream_t *v); 115 | typedef ngx_int_t (*ngx_rtmp_close_stream_pt)(ngx_rtmp_session_t *s, 116 | ngx_rtmp_close_stream_t *v); 117 | typedef ngx_int_t (*ngx_rtmp_delete_stream_pt)(ngx_rtmp_session_t *s, 118 | ngx_rtmp_delete_stream_t *v); 119 | typedef ngx_int_t (*ngx_rtmp_publish_pt)(ngx_rtmp_session_t *s, 120 | ngx_rtmp_publish_t *v); 121 | typedef ngx_int_t (*ngx_rtmp_play_pt)(ngx_rtmp_session_t *s, 122 | ngx_rtmp_play_t *v); 123 | typedef ngx_int_t (*ngx_rtmp_seek_pt)(ngx_rtmp_session_t *s, 124 | ngx_rtmp_seek_t *v); 125 | typedef ngx_int_t (*ngx_rtmp_pause_pt)(ngx_rtmp_session_t *s, 126 | ngx_rtmp_pause_t *v); 127 | 128 | typedef ngx_int_t (*ngx_rtmp_stream_begin_pt)(ngx_rtmp_session_t *s, 129 | ngx_rtmp_stream_begin_t *v); 130 | typedef ngx_int_t (*ngx_rtmp_stream_eof_pt)(ngx_rtmp_session_t *s, 131 | ngx_rtmp_stream_eof_t *v); 132 | typedef ngx_int_t (*ngx_rtmp_stream_dry_pt)(ngx_rtmp_session_t *s, 133 | ngx_rtmp_stream_dry_t *v); 134 | typedef ngx_int_t (*ngx_rtmp_recorded_pt)(ngx_rtmp_session_t *s, 135 | ngx_rtmp_recorded_t *v); 136 | typedef ngx_int_t (*ngx_rtmp_set_buflen_pt)(ngx_rtmp_session_t *s, 137 | ngx_rtmp_set_buflen_t *v); 138 | 139 | typedef ngx_int_t (*ngx_rtmp_playlist_pt)(ngx_rtmp_session_t *s, ngx_rtmp_playlist_t *v); 140 | 141 | extern ngx_rtmp_connect_pt ngx_rtmp_connect; 142 | extern ngx_rtmp_disconnect_pt ngx_rtmp_disconnect; 143 | extern ngx_rtmp_create_stream_pt ngx_rtmp_create_stream; 144 | extern ngx_rtmp_close_stream_pt ngx_rtmp_close_stream; 145 | extern ngx_rtmp_delete_stream_pt ngx_rtmp_delete_stream; 146 | extern ngx_rtmp_publish_pt ngx_rtmp_publish; 147 | extern ngx_rtmp_play_pt ngx_rtmp_play; 148 | extern ngx_rtmp_seek_pt ngx_rtmp_seek; 149 | extern ngx_rtmp_pause_pt ngx_rtmp_pause; 150 | 151 | extern ngx_rtmp_stream_begin_pt ngx_rtmp_stream_begin; 152 | extern ngx_rtmp_stream_eof_pt ngx_rtmp_stream_eof; 153 | extern ngx_rtmp_stream_dry_pt ngx_rtmp_stream_dry; 154 | extern ngx_rtmp_set_buflen_pt ngx_rtmp_set_buflen; 155 | extern ngx_rtmp_recorded_pt ngx_rtmp_recorded; 156 | 157 | extern ngx_rtmp_playlist_pt ngx_rtmp_playlist; 158 | 159 | #endif /*_NGX_RTMP_CMD_H_INCLUDED_ */ 160 | -------------------------------------------------------------------------------- /config: -------------------------------------------------------------------------------- 1 | ngx_addon_name="ngx_rtmp_module" 2 | RTMP_CORE_MODULES=" \ 3 | ngx_rtmp_module \ 4 | ngx_rtmp_core_module \ 5 | ngx_rtmp_cmd_module \ 6 | ngx_rtmp_codec_module \ 7 | ngx_rtmp_access_module \ 8 | ngx_rtmp_record_module \ 9 | ngx_rtmp_live_module \ 10 | ngx_rtmp_play_module \ 11 | ngx_rtmp_flv_module \ 12 | ngx_rtmp_mp4_module \ 13 | ngx_rtmp_netcall_module \ 14 | ngx_rtmp_relay_module \ 15 | ngx_rtmp_exec_module \ 16 | ngx_rtmp_auto_push_module \ 17 | ngx_rtmp_auto_push_index_module \ 18 | ngx_rtmp_notify_module \ 19 | ngx_rtmp_log_module \ 20 | ngx_rtmp_limit_module \ 21 | ngx_rtmp_hls_module \ 22 | ngx_rtmp_dash_module \ 23 | " 24 | RTMP_HTTP_MODULES=" \ 25 | ngx_rtmp_stat_module \ 26 | ngx_rtmp_control_module \ 27 | " 28 | RTMP_DEPS=" \ 29 | $ngx_addon_dir/ngx_rtmp_amf.h \ 30 | $ngx_addon_dir/ngx_rtmp_bandwidth.h \ 31 | $ngx_addon_dir/ngx_rtmp_cmd_module.h \ 32 | $ngx_addon_dir/ngx_rtmp_codec_module.h \ 33 | $ngx_addon_dir/ngx_rtmp_eval.h \ 34 | $ngx_addon_dir/ngx_rtmp.h \ 35 | $ngx_addon_dir/ngx_rtmp_version.h \ 36 | $ngx_addon_dir/ngx_rtmp_live_module.h \ 37 | $ngx_addon_dir/ngx_rtmp_netcall_module.h \ 38 | $ngx_addon_dir/ngx_rtmp_play_module.h \ 39 | $ngx_addon_dir/ngx_rtmp_record_module.h \ 40 | $ngx_addon_dir/ngx_rtmp_relay_module.h \ 41 | $ngx_addon_dir/ngx_rtmp_streams.h \ 42 | $ngx_addon_dir/ngx_rtmp_bitop.h \ 43 | $ngx_addon_dir/ngx_rtmp_proxy_protocol.h \ 44 | $ngx_addon_dir/hls/ngx_rtmp_mpegts.h \ 45 | $ngx_addon_dir/dash/ngx_rtmp_mp4.h \ 46 | " 47 | RTMP_CORE_SRCS=" \ 48 | $ngx_addon_dir/ngx_rtmp.c \ 49 | $ngx_addon_dir/ngx_rtmp_init.c \ 50 | $ngx_addon_dir/ngx_rtmp_handshake.c \ 51 | $ngx_addon_dir/ngx_rtmp_handler.c \ 52 | $ngx_addon_dir/ngx_rtmp_amf.c \ 53 | $ngx_addon_dir/ngx_rtmp_send.c \ 54 | $ngx_addon_dir/ngx_rtmp_shared.c \ 55 | $ngx_addon_dir/ngx_rtmp_eval.c \ 56 | $ngx_addon_dir/ngx_rtmp_receive.c \ 57 | $ngx_addon_dir/ngx_rtmp_core_module.c \ 58 | $ngx_addon_dir/ngx_rtmp_cmd_module.c \ 59 | $ngx_addon_dir/ngx_rtmp_codec_module.c \ 60 | $ngx_addon_dir/ngx_rtmp_access_module.c \ 61 | $ngx_addon_dir/ngx_rtmp_record_module.c \ 62 | $ngx_addon_dir/ngx_rtmp_live_module.c \ 63 | $ngx_addon_dir/ngx_rtmp_play_module.c \ 64 | $ngx_addon_dir/ngx_rtmp_flv_module.c \ 65 | $ngx_addon_dir/ngx_rtmp_mp4_module.c \ 66 | $ngx_addon_dir/ngx_rtmp_netcall_module.c \ 67 | $ngx_addon_dir/ngx_rtmp_relay_module.c \ 68 | $ngx_addon_dir/ngx_rtmp_bandwidth.c \ 69 | $ngx_addon_dir/ngx_rtmp_exec_module.c \ 70 | $ngx_addon_dir/ngx_rtmp_auto_push_module.c \ 71 | $ngx_addon_dir/ngx_rtmp_notify_module.c \ 72 | $ngx_addon_dir/ngx_rtmp_log_module.c \ 73 | $ngx_addon_dir/ngx_rtmp_limit_module.c \ 74 | $ngx_addon_dir/ngx_rtmp_bitop.c \ 75 | $ngx_addon_dir/ngx_rtmp_proxy_protocol.c \ 76 | $ngx_addon_dir/hls/ngx_rtmp_hls_module.c \ 77 | $ngx_addon_dir/dash/ngx_rtmp_dash_module.c \ 78 | $ngx_addon_dir/hls/ngx_rtmp_mpegts.c \ 79 | $ngx_addon_dir/hls/ngx_rtmp_mpegts_crc.c \ 80 | $ngx_addon_dir/dash/ngx_rtmp_mp4.c \ 81 | " 82 | RTMP_HTTP_SRCS=" \ 83 | $ngx_addon_dir/ngx_rtmp_stat_module.c \ 84 | $ngx_addon_dir/ngx_rtmp_control_module.c \ 85 | " 86 | ngx_module_incs=$ngx_addon_dir 87 | ngx_module_deps=$RTMP_DEPS 88 | 89 | if [ "$ngx_module_link" = "" ] ; then 90 | # Old nginx version 91 | ngx_module_link=NONE 92 | 93 | EVENT_MODULES="$EVENT_MODULES $RTMP_CORE_MODULES" 94 | HTTP_MODULES="$HTTP_MODULES $RTMP_HTTP_MODULES" 95 | NGX_ADDON_DEPS="$NGX_ADDON_DEPS $RTMP_DEPS" 96 | NGX_ADDON_SRCS="$NGX_ADDON_SRCS $RTMP_CORE_SRCS $RTMP_HTTP_SRCS" 97 | fi 98 | 99 | if [ $ngx_module_link = DYNAMIC ] ; then 100 | ngx_module_name="$RTMP_CORE_MODULES $RTMP_HTTP_MODULES" 101 | ngx_module_srcs="$RTMP_CORE_SRCS $RTMP_HTTP_SRCS" 102 | . auto/module 103 | elif [ $ngx_module_link = ADDON ] ; then 104 | ngx_module_type=EVENT 105 | ngx_module_name=$RTMP_CORE_MODULES 106 | ngx_module_srcs=$RTMP_CORE_SRCS 107 | . auto/module 108 | ngx_module_type=HTTP 109 | ngx_module_name=$RTMP_HTTP_MODULES 110 | ngx_module_srcs=$RTMP_HTTP_SRCS 111 | . auto/module 112 | fi 113 | 114 | USE_OPENSSL=YES 115 | 116 | CFLAGS="$CFLAGS -I$ngx_addon_dir" 117 | # Debug build with all warnings as errors 118 | # CFLAGS="$CFLAGS -I$ngx_addon_dir -Wall -Wpointer-arith -Wno-unused-parameter -Werror" 119 | -------------------------------------------------------------------------------- /ngx_rtmp_limit_module.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | #include "ngx_rtmp.h" 10 | 11 | 12 | typedef struct { 13 | ngx_int_t max_conn; 14 | ngx_shm_zone_t *shm_zone; 15 | } ngx_rtmp_limit_main_conf_t; 16 | 17 | 18 | static ngx_str_t shm_name = ngx_string("rtmp_limit"); 19 | 20 | 21 | static ngx_int_t ngx_rtmp_limit_postconfiguration(ngx_conf_t *cf); 22 | static void *ngx_rtmp_limit_create_main_conf(ngx_conf_t *cf); 23 | 24 | 25 | static ngx_command_t ngx_rtmp_limit_commands[] = { 26 | 27 | { ngx_string("max_connections"), 28 | NGX_RTMP_MAIN_CONF|NGX_RTMP_SRV_CONF|NGX_RTMP_APP_CONF|NGX_CONF_TAKE1, 29 | ngx_conf_set_num_slot, 30 | NGX_RTMP_MAIN_CONF_OFFSET, 31 | offsetof(ngx_rtmp_limit_main_conf_t, max_conn), 32 | NULL }, 33 | 34 | ngx_null_command 35 | }; 36 | 37 | 38 | static ngx_rtmp_module_t ngx_rtmp_limit_module_ctx = { 39 | NULL, /* preconfiguration */ 40 | ngx_rtmp_limit_postconfiguration, /* postconfiguration */ 41 | ngx_rtmp_limit_create_main_conf, /* create main configuration */ 42 | NULL, /* init main configuration */ 43 | NULL, /* create server configuration */ 44 | NULL, /* merge server configuration */ 45 | NULL, /* create app configuration */ 46 | NULL /* merge app configuration */ 47 | }; 48 | 49 | 50 | ngx_module_t ngx_rtmp_limit_module = { 51 | NGX_MODULE_V1, 52 | &ngx_rtmp_limit_module_ctx, /* module context */ 53 | ngx_rtmp_limit_commands, /* module directives */ 54 | NGX_RTMP_MODULE, /* module type */ 55 | NULL, /* init master */ 56 | NULL, /* init module */ 57 | NULL, /* init process */ 58 | NULL, /* init thread */ 59 | NULL, /* exit thread */ 60 | NULL, /* exit process */ 61 | NULL, /* exit master */ 62 | NGX_MODULE_V1_PADDING 63 | }; 64 | 65 | 66 | static void * 67 | ngx_rtmp_limit_create_main_conf(ngx_conf_t *cf) 68 | { 69 | ngx_rtmp_limit_main_conf_t *lmcf; 70 | 71 | lmcf = ngx_pcalloc(cf->pool, sizeof(ngx_rtmp_limit_main_conf_t)); 72 | if (lmcf == NULL) { 73 | return NULL; 74 | } 75 | 76 | lmcf->max_conn = NGX_CONF_UNSET; 77 | 78 | return lmcf; 79 | } 80 | 81 | 82 | static ngx_int_t 83 | ngx_rtmp_limit_connect(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h, 84 | ngx_chain_t *in) 85 | { 86 | ngx_rtmp_limit_main_conf_t *lmcf; 87 | ngx_slab_pool_t *shpool; 88 | ngx_shm_zone_t *shm_zone; 89 | uint32_t *nconn, n; 90 | ngx_int_t rc; 91 | 92 | lmcf = ngx_rtmp_get_module_main_conf(s, ngx_rtmp_limit_module); 93 | if (lmcf->max_conn == NGX_CONF_UNSET) { 94 | return NGX_OK; 95 | } 96 | 97 | shm_zone = lmcf->shm_zone; 98 | shpool = (ngx_slab_pool_t *) shm_zone->shm.addr; 99 | nconn = shm_zone->data; 100 | 101 | ngx_shmtx_lock(&shpool->mutex); 102 | n = ++*nconn; 103 | ngx_shmtx_unlock(&shpool->mutex); 104 | 105 | rc = n > (ngx_uint_t) lmcf->max_conn ? NGX_ERROR : NGX_OK; 106 | 107 | ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, 108 | "limit: inc conection counter: %uD", n); 109 | 110 | if (rc != NGX_OK) { 111 | ngx_log_error(NGX_LOG_ERR, s->connection->log, 0, 112 | "limit: too many connections: %uD > %i", 113 | n, lmcf->max_conn); 114 | } 115 | 116 | return rc; 117 | } 118 | 119 | 120 | static ngx_int_t 121 | ngx_rtmp_limit_disconnect(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h, 122 | ngx_chain_t *in) 123 | { 124 | ngx_rtmp_limit_main_conf_t *lmcf; 125 | ngx_slab_pool_t *shpool; 126 | ngx_shm_zone_t *shm_zone; 127 | uint32_t *nconn, n; 128 | 129 | lmcf = ngx_rtmp_get_module_main_conf(s, ngx_rtmp_limit_module); 130 | if (lmcf->max_conn == NGX_CONF_UNSET) { 131 | return NGX_OK; 132 | } 133 | 134 | shm_zone = lmcf->shm_zone; 135 | shpool = (ngx_slab_pool_t *) shm_zone->shm.addr; 136 | nconn = shm_zone->data; 137 | 138 | ngx_shmtx_lock(&shpool->mutex); 139 | n = --*nconn; 140 | ngx_shmtx_unlock(&shpool->mutex); 141 | 142 | (void) n; 143 | ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0, 144 | "limit: dec conection counter: %uD", n); 145 | 146 | return NGX_OK; 147 | } 148 | 149 | 150 | static ngx_int_t 151 | ngx_rtmp_limit_shm_init(ngx_shm_zone_t *shm_zone, void *data) 152 | { 153 | ngx_slab_pool_t *shpool; 154 | uint32_t *nconn; 155 | 156 | if (data) { 157 | shm_zone->data = data; 158 | return NGX_OK; 159 | } 160 | 161 | shpool = (ngx_slab_pool_t *) shm_zone->shm.addr; 162 | 163 | nconn = ngx_slab_alloc(shpool, 4); 164 | if (nconn == NULL) { 165 | return NGX_ERROR; 166 | } 167 | 168 | *nconn = 0; 169 | 170 | shm_zone->data = nconn; 171 | 172 | return NGX_OK; 173 | } 174 | 175 | 176 | static ngx_int_t 177 | ngx_rtmp_limit_postconfiguration(ngx_conf_t *cf) 178 | { 179 | ngx_rtmp_core_main_conf_t *cmcf; 180 | ngx_rtmp_limit_main_conf_t *lmcf; 181 | ngx_rtmp_handler_pt *h; 182 | 183 | cmcf = ngx_rtmp_conf_get_module_main_conf(cf, ngx_rtmp_core_module); 184 | 185 | h = ngx_array_push(&cmcf->events[NGX_RTMP_CONNECT]); 186 | *h = ngx_rtmp_limit_connect; 187 | 188 | h = ngx_array_push(&cmcf->events[NGX_RTMP_DISCONNECT]); 189 | *h = ngx_rtmp_limit_disconnect; 190 | 191 | lmcf = ngx_rtmp_conf_get_module_main_conf(cf, ngx_rtmp_limit_module); 192 | if (lmcf->max_conn == NGX_CONF_UNSET) { 193 | return NGX_OK; 194 | } 195 | 196 | lmcf->shm_zone = ngx_shared_memory_add(cf, &shm_name, ngx_pagesize * 2, 197 | &ngx_rtmp_limit_module); 198 | if (lmcf->shm_zone == NULL) { 199 | return NGX_ERROR; 200 | } 201 | 202 | lmcf->shm_zone->init = ngx_rtmp_limit_shm_init; 203 | 204 | return NGX_OK; 205 | } 206 | -------------------------------------------------------------------------------- /ngx_rtmp_eval.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | #include "ngx_rtmp_eval.h" 10 | 11 | 12 | #define NGX_RTMP_EVAL_BUFLEN 16 13 | 14 | 15 | static void 16 | ngx_rtmp_eval_session_str(void *ctx, ngx_rtmp_eval_t *e, ngx_str_t *ret) 17 | { 18 | *ret = *(ngx_str_t *) ((u_char *) ctx + e->offset); 19 | } 20 | 21 | 22 | static void 23 | ngx_rtmp_eval_connection_str(void *ctx, ngx_rtmp_eval_t *e, ngx_str_t *ret) 24 | { 25 | ngx_rtmp_session_t *s = ctx; 26 | 27 | *ret = *(ngx_str_t *) ((u_char *) s->connection + e->offset); 28 | } 29 | 30 | 31 | ngx_rtmp_eval_t ngx_rtmp_eval_session[] = { 32 | 33 | { ngx_string("app"), 34 | ngx_rtmp_eval_session_str, 35 | offsetof(ngx_rtmp_session_t, app) }, 36 | 37 | { ngx_string("flashver"), 38 | ngx_rtmp_eval_session_str, 39 | offsetof(ngx_rtmp_session_t, flashver) }, 40 | 41 | { ngx_string("swfurl"), 42 | ngx_rtmp_eval_session_str, 43 | offsetof(ngx_rtmp_session_t, swf_url) }, 44 | 45 | { ngx_string("tcurl"), 46 | ngx_rtmp_eval_session_str, 47 | offsetof(ngx_rtmp_session_t, tc_url) }, 48 | 49 | { ngx_string("pageurl"), 50 | ngx_rtmp_eval_session_str, 51 | offsetof(ngx_rtmp_session_t, page_url) }, 52 | 53 | { ngx_string("addr"), 54 | ngx_rtmp_eval_connection_str, 55 | offsetof(ngx_connection_t, addr_text) }, 56 | 57 | ngx_rtmp_null_eval 58 | }; 59 | 60 | 61 | static void 62 | ngx_rtmp_eval_append(ngx_buf_t *b, void *data, size_t len, ngx_log_t *log) 63 | { 64 | size_t buf_len; 65 | 66 | if (b->last + len > b->end) { 67 | buf_len = 2 * (b->last - b->pos) + len; 68 | 69 | b->start = ngx_alloc(buf_len, log); 70 | if (b->start == NULL) { 71 | return; 72 | } 73 | 74 | b->last = ngx_cpymem(b->start, b->pos, b->last - b->pos); 75 | b->pos = b->start; 76 | b->end = b->start + buf_len; 77 | } 78 | 79 | b->last = ngx_cpymem(b->last, data, len); 80 | } 81 | 82 | 83 | static void 84 | ngx_rtmp_eval_append_var(void *ctx, ngx_buf_t *b, ngx_rtmp_eval_t **e, 85 | ngx_str_t *name, ngx_log_t *log) 86 | { 87 | ngx_uint_t k; 88 | ngx_str_t v; 89 | ngx_rtmp_eval_t *ee; 90 | 91 | for (; *e; ++e) { 92 | for (k = 0, ee = *e; ee->handler; ++k, ++ee) { 93 | if (ee->name.len == name->len && 94 | ngx_memcmp(ee->name.data, name->data, name->len) == 0) 95 | { 96 | ee->handler(ctx, ee, &v); 97 | ngx_rtmp_eval_append(b, v.data, v.len, log); 98 | } 99 | } 100 | } 101 | } 102 | 103 | 104 | ngx_int_t 105 | ngx_rtmp_eval(void *ctx, ngx_str_t *in, ngx_rtmp_eval_t **e, ngx_str_t *out, 106 | ngx_log_t *log) 107 | { 108 | u_char c, *p; 109 | ngx_str_t name; 110 | ngx_buf_t b; 111 | ngx_uint_t n; 112 | 113 | enum { 114 | NORMAL, 115 | ESCAPE, 116 | NAME, 117 | SNAME 118 | } state = NORMAL; 119 | 120 | b.pos = b.last = b.start = ngx_alloc(NGX_RTMP_EVAL_BUFLEN, log); 121 | if (b.pos == NULL) { 122 | return NGX_ERROR; 123 | } 124 | 125 | b.end = b.pos + NGX_RTMP_EVAL_BUFLEN; 126 | name.data = NULL; 127 | 128 | for (n = 0; n < in->len; ++n) { 129 | p = &in->data[n]; 130 | c = *p; 131 | 132 | switch (state) { 133 | case SNAME: 134 | if (c != '}') { 135 | continue; 136 | } 137 | 138 | name.len = p - name.data; 139 | ngx_rtmp_eval_append_var(ctx, &b, e, &name, log); 140 | 141 | state = NORMAL; 142 | 143 | continue; 144 | 145 | case NAME: 146 | if (c == '{' && name.data == p) { 147 | ++name.data; 148 | state = SNAME; 149 | continue; 150 | } 151 | if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) { 152 | continue; 153 | } 154 | 155 | name.len = p - name.data; 156 | ngx_rtmp_eval_append_var(ctx, &b, e, &name, log); 157 | /* fall through */ 158 | 159 | case NORMAL: 160 | switch (c) { 161 | case '$': 162 | name.data = p + 1; 163 | state = NAME; 164 | continue; 165 | case '\\': 166 | state = ESCAPE; 167 | continue; 168 | /* fall through */ 169 | default: 170 | break; 171 | } 172 | /* fall through */ 173 | 174 | case ESCAPE: 175 | ngx_rtmp_eval_append(&b, &c, 1, log); 176 | state = NORMAL; 177 | break; 178 | 179 | } 180 | } 181 | 182 | if (state == NAME) { 183 | p = &in->data[n]; 184 | name.len = p - name.data; 185 | ngx_rtmp_eval_append_var(ctx, &b, e, &name, log); 186 | } 187 | 188 | c = 0; 189 | ngx_rtmp_eval_append(&b, &c, 1, log); 190 | 191 | out->data = b.pos; 192 | out->len = b.last - b.pos - 1; 193 | 194 | return NGX_OK; 195 | } 196 | 197 | 198 | ngx_int_t 199 | ngx_rtmp_eval_streams(ngx_str_t *in) 200 | { 201 | #if !(NGX_WIN32) 202 | ngx_int_t mode, create, v, close_src; 203 | ngx_fd_t dst, src; 204 | u_char *path; 205 | 206 | path = in->data; 207 | 208 | while (*path >= '0' && *path <= '9') { 209 | path++; 210 | } 211 | 212 | switch ((char) *path) { 213 | 214 | case '>': 215 | 216 | v = (path == in->data ? 1 : ngx_atoi(in->data, path - in->data)); 217 | if (v == NGX_ERROR) { 218 | return NGX_ERROR; 219 | } 220 | 221 | dst = (ngx_fd_t) v; 222 | mode = NGX_FILE_WRONLY; 223 | create = NGX_FILE_TRUNCATE; 224 | path++; 225 | 226 | if (*path == (u_char) '>') { 227 | mode = NGX_FILE_APPEND; 228 | create = NGX_FILE_CREATE_OR_OPEN; 229 | path++; 230 | } 231 | 232 | break; 233 | 234 | case '<': 235 | 236 | v = (path == in->data ? 0 : ngx_atoi(in->data, path - in->data)); 237 | if (v == NGX_ERROR) { 238 | return NGX_ERROR; 239 | } 240 | 241 | dst = (ngx_fd_t) v; 242 | mode = NGX_FILE_RDONLY; 243 | create = NGX_FILE_OPEN; 244 | path++; 245 | 246 | break; 247 | 248 | default: 249 | 250 | return NGX_DONE; 251 | } 252 | 253 | if (*path == (u_char) '&') { 254 | 255 | path++; 256 | v = ngx_atoi(path, in->data + in->len - path); 257 | if (v == NGX_ERROR) { 258 | return NGX_ERROR; 259 | } 260 | src = (ngx_fd_t) v; 261 | close_src = 0; 262 | 263 | } else { 264 | 265 | src = ngx_open_file(path, mode, create, NGX_FILE_DEFAULT_ACCESS); 266 | if (src == NGX_INVALID_FILE) { 267 | return NGX_ERROR; 268 | } 269 | close_src = 1; 270 | 271 | } 272 | 273 | if (src == dst) { 274 | return NGX_OK; 275 | } 276 | 277 | dup2(src, dst); 278 | 279 | if (close_src) { 280 | ngx_close_file(src); 281 | } 282 | return NGX_OK; 283 | 284 | #else 285 | return NGX_DONE; 286 | #endif 287 | } 288 | -------------------------------------------------------------------------------- /ngx_rtmp_init.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | #include "ngx_rtmp.h" 10 | #include "ngx_rtmp_proxy_protocol.h" 11 | 12 | 13 | static void ngx_rtmp_close_connection(ngx_connection_t *c); 14 | static u_char * ngx_rtmp_log_error(ngx_log_t *log, u_char *buf, size_t len); 15 | 16 | 17 | void 18 | ngx_rtmp_init_connection(ngx_connection_t *c) 19 | { 20 | ngx_uint_t i; 21 | ngx_rtmp_port_t *port; 22 | struct sockaddr *sa; 23 | struct sockaddr_in *sin; 24 | ngx_rtmp_in_addr_t *addr; 25 | ngx_rtmp_session_t *s; 26 | ngx_rtmp_addr_conf_t *addr_conf; 27 | ngx_int_t unix_socket; 28 | #if (NGX_HAVE_INET6) 29 | struct sockaddr_in6 *sin6; 30 | ngx_rtmp_in6_addr_t *addr6; 31 | #endif 32 | 33 | ++ngx_rtmp_naccepted; 34 | 35 | /* find the server configuration for the address:port */ 36 | 37 | /* AF_INET only */ 38 | 39 | port = c->listening->servers; 40 | unix_socket = 0; 41 | 42 | if (port->naddrs > 1) { 43 | 44 | /* 45 | * There are several addresses on this port and one of them 46 | * is the "*:port" wildcard so getsockname() is needed to determine 47 | * the server address. 48 | * 49 | * AcceptEx() already gave this address. 50 | */ 51 | 52 | if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) { 53 | ngx_rtmp_close_connection(c); 54 | return; 55 | } 56 | 57 | sa = c->local_sockaddr; 58 | 59 | switch (sa->sa_family) { 60 | 61 | #if (NGX_HAVE_INET6) 62 | case AF_INET6: 63 | sin6 = (struct sockaddr_in6 *) sa; 64 | 65 | addr6 = port->addrs; 66 | 67 | /* the last address is "*" */ 68 | 69 | for (i = 0; i < port->naddrs - 1; i++) { 70 | if (ngx_memcmp(&addr6[i].addr6, &sin6->sin6_addr, 16) == 0) { 71 | break; 72 | } 73 | } 74 | 75 | addr_conf = &addr6[i].conf; 76 | 77 | break; 78 | #endif 79 | case AF_UNIX: 80 | unix_socket = 1; 81 | /* fall through */ 82 | 83 | default: /* AF_INET */ 84 | sin = (struct sockaddr_in *) sa; 85 | 86 | addr = port->addrs; 87 | 88 | /* the last address is "*" */ 89 | 90 | for (i = 0; i < port->naddrs - 1; i++) { 91 | if (addr[i].addr == sin->sin_addr.s_addr) { 92 | break; 93 | } 94 | } 95 | 96 | addr_conf = &addr[i].conf; 97 | 98 | break; 99 | } 100 | 101 | } else { 102 | switch (c->local_sockaddr->sa_family) { 103 | 104 | #if (NGX_HAVE_INET6) 105 | case AF_INET6: 106 | addr6 = port->addrs; 107 | addr_conf = &addr6[0].conf; 108 | break; 109 | #endif 110 | 111 | case AF_UNIX: 112 | unix_socket = 1; 113 | /* fall through */ 114 | 115 | default: /* AF_INET */ 116 | addr = port->addrs; 117 | addr_conf = &addr[0].conf; 118 | break; 119 | } 120 | } 121 | 122 | ngx_log_error(NGX_LOG_INFO, c->log, 0, "*%ui client connected '%V'", 123 | c->number, &c->addr_text); 124 | 125 | s = ngx_rtmp_init_session(c, addr_conf); 126 | if (s == NULL) { 127 | return; 128 | } 129 | 130 | /* only auto-pushed connections are 131 | * done through unix socket */ 132 | 133 | s->auto_pushed = unix_socket; 134 | 135 | if (addr_conf->proxy_protocol) { 136 | ngx_rtmp_proxy_protocol(s); 137 | 138 | } else { 139 | ngx_rtmp_handshake(s); 140 | } 141 | } 142 | 143 | 144 | ngx_rtmp_session_t * 145 | ngx_rtmp_init_session(ngx_connection_t *c, ngx_rtmp_addr_conf_t *addr_conf) 146 | { 147 | ngx_rtmp_session_t *s; 148 | ngx_rtmp_core_srv_conf_t *cscf; 149 | ngx_rtmp_error_log_ctx_t *ctx; 150 | 151 | s = ngx_pcalloc(c->pool, sizeof(ngx_rtmp_session_t) + 152 | sizeof(ngx_chain_t *) * ((ngx_rtmp_core_srv_conf_t *) 153 | addr_conf->ctx-> srv_conf[ngx_rtmp_core_module 154 | .ctx_index])->out_queue); 155 | if (s == NULL) { 156 | ngx_rtmp_close_connection(c); 157 | return NULL; 158 | } 159 | 160 | s->main_conf = addr_conf->ctx->main_conf; 161 | s->srv_conf = addr_conf->ctx->srv_conf; 162 | 163 | s->addr_text = &addr_conf->addr_text; 164 | 165 | c->data = s; 166 | s->connection = c; 167 | 168 | ctx = ngx_palloc(c->pool, sizeof(ngx_rtmp_error_log_ctx_t)); 169 | if (ctx == NULL) { 170 | ngx_rtmp_close_connection(c); 171 | return NULL; 172 | } 173 | 174 | ctx->client = &c->addr_text; 175 | ctx->session = s; 176 | 177 | c->log->connection = c->number; 178 | c->log->handler = ngx_rtmp_log_error; 179 | c->log->data = ctx; 180 | c->log->action = NULL; 181 | 182 | c->log_error = NGX_ERROR_INFO; 183 | 184 | s->ctx = ngx_pcalloc(c->pool, sizeof(void *) * ngx_rtmp_max_module); 185 | if (s->ctx == NULL) { 186 | ngx_rtmp_close_connection(c); 187 | return NULL; 188 | } 189 | 190 | cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module); 191 | 192 | s->out_queue = cscf->out_queue; 193 | s->out_cork = cscf->out_cork; 194 | s->in_streams = ngx_pcalloc(c->pool, sizeof(ngx_rtmp_stream_t) 195 | * cscf->max_streams); 196 | if (s->in_streams == NULL) { 197 | ngx_rtmp_close_connection(c); 198 | return NULL; 199 | } 200 | 201 | #if (nginx_version >= 1007005) 202 | ngx_queue_init(&s->posted_dry_events); 203 | #endif 204 | 205 | s->epoch = ngx_current_msec; 206 | s->timeout = cscf->timeout; 207 | s->buflen = cscf->buflen; 208 | ngx_rtmp_set_chunk_size(s, NGX_RTMP_DEFAULT_CHUNK_SIZE); 209 | 210 | 211 | if (ngx_rtmp_fire_event(s, NGX_RTMP_CONNECT, NULL, NULL) != NGX_OK) { 212 | ngx_rtmp_finalize_session(s); 213 | return NULL; 214 | } 215 | 216 | return s; 217 | } 218 | 219 | 220 | static u_char * 221 | ngx_rtmp_log_error(ngx_log_t *log, u_char *buf, size_t len) 222 | { 223 | u_char *p; 224 | ngx_rtmp_session_t *s; 225 | ngx_rtmp_error_log_ctx_t *ctx; 226 | 227 | if (log->action) { 228 | p = ngx_snprintf(buf, len, " while %s", log->action); 229 | len -= p - buf; 230 | buf = p; 231 | } 232 | 233 | ctx = log->data; 234 | 235 | p = ngx_snprintf(buf, len, ", client: %V", ctx->client); 236 | len -= p - buf; 237 | buf = p; 238 | 239 | s = ctx->session; 240 | 241 | if (s == NULL) { 242 | return p; 243 | } 244 | 245 | p = ngx_snprintf(buf, len, ", server: %V", s->addr_text); 246 | len -= p - buf; 247 | buf = p; 248 | 249 | return p; 250 | } 251 | 252 | 253 | static void 254 | ngx_rtmp_close_connection(ngx_connection_t *c) 255 | { 256 | ngx_pool_t *pool; 257 | 258 | ngx_log_debug0(NGX_LOG_DEBUG_RTMP, c->log, 0, "close connection"); 259 | 260 | #if (NGX_STAT_STUB) 261 | (void) ngx_atomic_fetch_add(ngx_stat_active, -1); 262 | #endif 263 | 264 | pool = c->pool; 265 | ngx_close_connection(c); 266 | ngx_destroy_pool(pool); 267 | } 268 | 269 | 270 | static void 271 | ngx_rtmp_close_session_handler(ngx_event_t *e) 272 | { 273 | ngx_rtmp_session_t *s; 274 | ngx_connection_t *c; 275 | ngx_rtmp_core_srv_conf_t *cscf; 276 | 277 | s = e->data; 278 | c = s->connection; 279 | 280 | cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module); 281 | 282 | ngx_log_debug0(NGX_LOG_DEBUG_RTMP, c->log, 0, "close session"); 283 | 284 | ngx_rtmp_fire_event(s, NGX_RTMP_DISCONNECT, NULL, NULL); 285 | 286 | if (s->ping_evt.timer_set) { 287 | ngx_del_timer(&s->ping_evt); 288 | } 289 | 290 | if (s->in_old_pool) { 291 | ngx_destroy_pool(s->in_old_pool); 292 | } 293 | 294 | if (s->in_pool) { 295 | ngx_destroy_pool(s->in_pool); 296 | } 297 | 298 | ngx_rtmp_free_handshake_buffers(s); 299 | 300 | while (s->out_pos != s->out_last) { 301 | ngx_rtmp_free_shared_chain(cscf, s->out[s->out_pos++]); 302 | s->out_pos %= s->out_queue; 303 | } 304 | 305 | ngx_rtmp_close_connection(c); 306 | } 307 | 308 | 309 | void 310 | ngx_rtmp_finalize_session(ngx_rtmp_session_t *s) 311 | { 312 | ngx_event_t *e; 313 | ngx_connection_t *c; 314 | 315 | c = s->connection; 316 | if (c->destroyed) { 317 | return; 318 | } 319 | 320 | ngx_log_debug0(NGX_LOG_DEBUG_RTMP, c->log, 0, "finalize session"); 321 | 322 | c->destroyed = 1; 323 | e = &s->close; 324 | e->data = s; 325 | e->handler = ngx_rtmp_close_session_handler; 326 | e->log = c->log; 327 | 328 | ngx_post_event(e, &ngx_posted_events); 329 | } 330 | 331 | -------------------------------------------------------------------------------- /test/www/jwplayer_old/swfobject.js: -------------------------------------------------------------------------------- 1 | /* SWFObject v2.1 2 | Copyright (c) 2007-2008 Geoff Stearns, Michael Williams, and Bobby van der Sluis 3 | This software is released under the MIT License 4 | */ 5 | var swfobject=function(){var b="undefined",Q="object",n="Shockwave Flash",p="ShockwaveFlash.ShockwaveFlash",P="application/x-shockwave-flash",m="SWFObjectExprInst",j=window,K=document,T=navigator,o=[],N=[],i=[],d=[],J,Z=null,M=null,l=null,e=false,A=false;var h=function(){var v=typeof K.getElementById!=b&&typeof K.getElementsByTagName!=b&&typeof K.createElement!=b,AC=[0,0,0],x=null;if(typeof T.plugins!=b&&typeof T.plugins[n]==Q){x=T.plugins[n].description;if(x&&!(typeof T.mimeTypes!=b&&T.mimeTypes[P]&&!T.mimeTypes[P].enabledPlugin)){x=x.replace(/^.*\s+(\S+\s+\S+$)/,"$1");AC[0]=parseInt(x.replace(/^(.*)\..*$/,"$1"),10);AC[1]=parseInt(x.replace(/^.*\.(.*)\s.*$/,"$1"),10);AC[2]=/r/.test(x)?parseInt(x.replace(/^.*r(.*)$/,"$1"),10):0}}else{if(typeof j.ActiveXObject!=b){var y=null,AB=false;try{y=new ActiveXObject(p+".7")}catch(t){try{y=new ActiveXObject(p+".6");AC=[6,0,21];y.AllowScriptAccess="always"}catch(t){if(AC[0]==6){AB=true}}if(!AB){try{y=new ActiveXObject(p)}catch(t){}}}if(!AB&&y){try{x=y.GetVariable("$version");if(x){x=x.split(" ")[1].split(",");AC=[parseInt(x[0],10),parseInt(x[1],10),parseInt(x[2],10)]}}catch(t){}}}}var AD=T.userAgent.toLowerCase(),r=T.platform.toLowerCase(),AA=/webkit/.test(AD)?parseFloat(AD.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):false,q=false,z=r?/win/.test(r):/win/.test(AD),w=r?/mac/.test(r):/mac/.test(AD);/*@cc_on q=true;@if(@_win32)z=true;@elif(@_mac)w=true;@end@*/return{w3cdom:v,pv:AC,webkit:AA,ie:q,win:z,mac:w}}();var L=function(){if(!h.w3cdom){return }f(H);if(h.ie&&h.win){try{K.write("