One Level Up Top Level

src/http/modules/ngx_http_mp4_module.c - nginx

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */

  7. #include <ngx_config.h>
  8. #include <ngx_core.h>
  9. #include <ngx_http.h>


  12. ‌#define NGX_HTTP_MP4_TRAK_ATOM     0
  13. ‌#define NGX_HTTP_MP4_TKHD_ATOM     1
  14. ‌#define NGX_HTTP_MP4_EDTS_ATOM     2
  15. ‌#define NGX_HTTP_MP4_ELST_ATOM     3
  16. ‌#define NGX_HTTP_MP4_MDIA_ATOM     4
  17. ‌#define NGX_HTTP_MP4_MDHD_ATOM     5
  18. ‌#define NGX_HTTP_MP4_HDLR_ATOM     6
  19. ‌#define NGX_HTTP_MP4_MINF_ATOM     7
  20. ‌#define NGX_HTTP_MP4_VMHD_ATOM     8
  21. ‌#define NGX_HTTP_MP4_SMHD_ATOM     9
  22. ‌#define NGX_HTTP_MP4_DINF_ATOM    10
  23. ‌#define NGX_HTTP_MP4_STBL_ATOM    11
  24. ‌#define NGX_HTTP_MP4_STSD_ATOM    12
  25. ‌#define NGX_HTTP_MP4_STTS_ATOM    13
  26. ‌#define NGX_HTTP_MP4_STTS_DATA    14
  27. ‌#define NGX_HTTP_MP4_STSS_ATOM    15
  28. ‌#define NGX_HTTP_MP4_STSS_DATA    16
  29. ‌#define NGX_HTTP_MP4_CTTS_ATOM    17
  30. ‌#define NGX_HTTP_MP4_CTTS_DATA    18
  31. ‌#define NGX_HTTP_MP4_STSC_ATOM    19
  32. ‌#define NGX_HTTP_MP4_STSC_START   20
  33. ‌#define NGX_HTTP_MP4_STSC_DATA    21
  34. ‌#define NGX_HTTP_MP4_STSC_END     22
  35. ‌#define NGX_HTTP_MP4_STSZ_ATOM    23
  36. ‌#define NGX_HTTP_MP4_STSZ_DATA    24
  37. ‌#define NGX_HTTP_MP4_STCO_ATOM    25
  38. ‌#define NGX_HTTP_MP4_STCO_DATA    26
  39. ‌#define NGX_HTTP_MP4_CO64_ATOM    27
  40. ‌#define NGX_HTTP_MP4_CO64_DATA    28

  42. ‌#define NGX_HTTP_MP4_LAST_ATOM    NGX_HTTP_MP4_CO64_DATA


  45. ‌typedef struct {
  46.     size_t                buffer_size;
  47.     size_t                max_buffer_size;
  48.     ngx_flag_t            start_key_frame;
  49. ‌} ngx_http_mp4_conf_t;


  52. ‌typedef struct {
  53.     u_char                chunk[4];
  54.     u_char                samples[4];
  55.     u_char                id[4];
  56. ‌} ngx_mp4_stsc_entry_t;


  59. ‌typedef struct {
  60.     u_char                size[4];
  61.     u_char                name[4];
  62. ‌} ngx_mp4_edts_atom_t;


  65. ‌typedef struct {
  66.     u_char                size[4];
  67.     u_char                name[4];
  68.     u_char                version[1];
  69.     u_char                flags[3];
  70.     u_char                entries[4];
  71.     u_char                duration[8];
  72.     u_char                media_time[8];
  73.     u_char                media_rate[2];
  74.     u_char                reserved[2];
  75. ‌} ngx_mp4_elst_atom_t;


  78. ‌typedef struct {
  79.     uint32_t              timescale;
  80.     uint32_t              time_to_sample_entries;
  81.     uint32_t              sample_to_chunk_entries;
  82.     uint32_t              sync_samples_entries;
  83.     uint32_t              composition_offset_entries;
  84.     uint32_t              sample_sizes_entries;
  85.     uint32_t              chunks;

  87.     ngx_uint_t            start_sample;
  88.     ngx_uint_t            end_sample;
  89.     ngx_uint_t            start_chunk;
  90.     ngx_uint_t            end_chunk;
  91.     ngx_uint_t            start_chunk_samples;
  92.     ngx_uint_t            end_chunk_samples;
  93.     uint64_t              start_chunk_samples_size;
  94.     uint64_t              end_chunk_samples_size;
  95.     uint64_t              duration;
  96.     uint64_t              prefix;
  97.     uint64_t              movie_duration;
  98.     off_t                 start_offset;
  99.     off_t                 end_offset;

  101.     size_t                tkhd_size;
  102.     size_t                mdhd_size;
  103.     size_t                hdlr_size;
  104.     size_t                vmhd_size;
  105.     size_t                smhd_size;
  106.     size_t                dinf_size;
  107.     size_t                size;

  109.     ngx_chain_t           out[NGX_HTTP_MP4_LAST_ATOM + 1];

  111.     ngx_buf_t             trak_atom_buf;
  112.     ngx_buf_t             tkhd_atom_buf;
  113.     ngx_buf_t             edts_atom_buf;
  114.     ngx_buf_t             elst_atom_buf;
  115.     ngx_buf_t             mdia_atom_buf;
  116.     ngx_buf_t             mdhd_atom_buf;
  117.     ngx_buf_t             hdlr_atom_buf;
  118.     ngx_buf_t             minf_atom_buf;
  119.     ngx_buf_t             vmhd_atom_buf;
  120.     ngx_buf_t             smhd_atom_buf;
  121.     ngx_buf_t             dinf_atom_buf;
  122.     ngx_buf_t             stbl_atom_buf;
  123.     ngx_buf_t             stsd_atom_buf;
  124.     ngx_buf_t             stts_atom_buf;
  125.     ngx_buf_t             stts_data_buf;
  126.     ngx_buf_t             stss_atom_buf;
  127.     ngx_buf_t             stss_data_buf;
  128.     ngx_buf_t             ctts_atom_buf;
  129.     ngx_buf_t             ctts_data_buf;
  130.     ngx_buf_t             stsc_atom_buf;
  131.     ngx_buf_t             stsc_start_chunk_buf;
  132.     ngx_buf_t             stsc_end_chunk_buf;
  133.     ngx_buf_t             stsc_data_buf;
  134.     ngx_buf_t             stsz_atom_buf;
  135.     ngx_buf_t             stsz_data_buf;
  136.     ngx_buf_t             stco_atom_buf;
  137.     ngx_buf_t             stco_data_buf;
  138.     ngx_buf_t             co64_atom_buf;
  139.     ngx_buf_t             co64_data_buf;

  141.     ngx_mp4_edts_atom_t   edts_atom;
  142.     ngx_mp4_elst_atom_t   elst_atom;
  143.     ngx_mp4_stsc_entry_t  stsc_start_chunk_entry;
  144.     ngx_mp4_stsc_entry_t  stsc_end_chunk_entry;
  145. ‌} ngx_http_mp4_trak_t;


  148. ‌typedef struct {
  149.     ngx_file_t            file;

  151.     u_char               *buffer;
  152.     u_char               *buffer_start;
  153.     u_char               *buffer_pos;
  154.     u_char               *buffer_end;
  155.     size_t                buffer_size;

  157.     off_t                 offset;
  158.     off_t                 end;
  159.     off_t                 content_length;
  160.     ngx_uint_t            start;
  161.     ngx_uint_t            length;
  162.     uint32_t              timescale;
  163.     ngx_http_request_t   *request;
  164.     ngx_array_t           trak;
  165.     ngx_http_mp4_trak_t   traks[2];

  167.     size_t                ftyp_size;
  168.     size_t                moov_size;

  170.     ngx_chain_t          *out;
  171.     ngx_chain_t           ftyp_atom;
  172.     ngx_chain_t           moov_atom;
  173.     ngx_chain_t           mvhd_atom;
  174.     ngx_chain_t           mdat_atom;
  175.     ngx_chain_t           mdat_data;

  177.     ngx_buf_t             ftyp_atom_buf;
  178.     ngx_buf_t             moov_atom_buf;
  179.     ngx_buf_t             mvhd_atom_buf;
  180.     ngx_buf_t             mdat_atom_buf;
  181.     ngx_buf_t             mdat_data_buf;

  183.     u_char                moov_atom_header[8];
  184.     u_char                mdat_atom_header[16];
  185. ‌} ngx_http_mp4_file_t;


  188. ‌typedef struct {
  189.     char                 *name;
  190.     ngx_int_t           (*handler)(ngx_http_mp4_file_t *mp4,
  191.                                    uint64_t atom_data_size);
  192. ‌} ngx_http_mp4_atom_handler_t;


  195. ‌#define ngx_mp4_atom_header(mp4)   (mp4->buffer_pos - 8)
  196. ‌#define ngx_mp4_atom_data(mp4)     mp4->buffer_pos
  197. ‌#define ngx_mp4_atom_data_size(t)  (uint64_t) (sizeof(t) - 8)


  200. ‌#define ngx_mp4_atom_next(mp4, n)                                             \
  201.                                                                               \
  202.     if (n > (size_t) (mp4->buffer_end - mp4->buffer_pos)) {                   \
  203.         mp4->buffer_pos = mp4->buffer_end;                                    \
  204.                                                                               \
  205.     } else {                                                                  \
  206.         mp4->buffer_pos += (size_t) n;                                        \
  207.     }                                                                         \
  208.                                                                               \
  209.     mp4->offset += n


  212. ‌#define ngx_mp4_set_atom_name(p, n1, n2, n3, n4)                              \
  213.     ((u_char *) (p))[4] = n1;                                                 \
  214.     ((u_char *) (p))[5] = n2;                                                 \
  215.     ((u_char *) (p))[6] = n3;                                                 \
  216.     ((u_char *) (p))[7] = n4

  218. ‌#define ngx_mp4_get_16value(p)                                                \
  219.     ( ((uint16_t) ((u_char *) (p))[0] << 8)                                   \
  220.     + (           ((u_char *) (p))[1]) )

  222. ‌#define ngx_mp4_set_16value(p, n)                                             \
  223.     ((u_char *) (p))[0] = (u_char) ((n) >> 8);                                \
  224.     ((u_char *) (p))[1] = (u_char)  (n)

  226. ‌#define ngx_mp4_get_32value(p)                                                \
  227.     ( ((uint32_t) ((u_char *) (p))[0] << 24)                                  \
  228.     + (           ((u_char *) (p))[1] << 16)                                  \
  229.     + (           ((u_char *) (p))[2] << 8)                                   \
  230.     + (           ((u_char *) (p))[3]) )

  232. ‌#define ngx_mp4_set_32value(p, n)                                             \
  233.     ((u_char *) (p))[0] = (u_char) ((n) >> 24);                               \
  234.     ((u_char *) (p))[1] = (u_char) ((n) >> 16);                               \
  235.     ((u_char *) (p))[2] = (u_char) ((n) >> 8);                                \
  236.     ((u_char *) (p))[3] = (u_char)  (n)

  238. ‌#define ngx_mp4_get_64value(p)                                                \
  239.     ( ((uint64_t) ((u_char *) (p))[0] << 56)                                  \
  240.     + ((uint64_t) ((u_char *) (p))[1] << 48)                                  \
  241.     + ((uint64_t) ((u_char *) (p))[2] << 40)                                  \
  242.     + ((uint64_t) ((u_char *) (p))[3] << 32)                                  \
  243.     + ((uint64_t) ((u_char *) (p))[4] << 24)                                  \
  244.     + (           ((u_char *) (p))[5] << 16)                                  \
  245.     + (           ((u_char *) (p))[6] << 8)                                   \
  246.     + (           ((u_char *) (p))[7]) )

  248. ‌#define ngx_mp4_set_64value(p, n)                                             \
  249.     ((u_char *) (p))[0] = (u_char) ((uint64_t) (n) >> 56);                    \
  250.     ((u_char *) (p))[1] = (u_char) ((uint64_t) (n) >> 48);                    \
  251.     ((u_char *) (p))[2] = (u_char) ((uint64_t) (n) >> 40);                    \
  252.     ((u_char *) (p))[3] = (u_char) ((uint64_t) (n) >> 32);                    \
  253.     ((u_char *) (p))[4] = (u_char) (           (n) >> 24);                    \
  254.     ((u_char *) (p))[5] = (u_char) (           (n) >> 16);                    \
  255.     ((u_char *) (p))[6] = (u_char) (           (n) >> 8);                     \
  256.     ((u_char *) (p))[7] = (u_char)             (n)

  258. ‌#define ngx_mp4_last_trak(mp4)                                                \
  259.     &((ngx_http_mp4_trak_t *) mp4->trak.elts)[mp4->trak.nelts - 1]


  262. static ngx_int_t ngx_http_mp4_handler(ngx_http_request_t *r);
  263. static ngx_int_t ngx_http_mp4_atofp(u_char *line, size_t n, size_t point);

  265. static ngx_int_t ngx_http_mp4_process(ngx_http_mp4_file_t *mp4);
  266. static ngx_int_t ngx_http_mp4_read_atom(ngx_http_mp4_file_t *mp4,
  267.     ngx_http_mp4_atom_handler_t *atom, uint64_t atom_data_size);
  268. static ngx_int_t ngx_http_mp4_read(ngx_http_mp4_file_t *mp4, size_t size);
  269. static ngx_int_t ngx_http_mp4_read_ftyp_atom(ngx_http_mp4_file_t *mp4,
  270.     uint64_t atom_data_size);
  271. static ngx_int_t ngx_http_mp4_read_moov_atom(ngx_http_mp4_file_t *mp4,
  272.     uint64_t atom_data_size);
  273. static ngx_int_t ngx_http_mp4_read_mdat_atom(ngx_http_mp4_file_t *mp4,
  274.     uint64_t atom_data_size);
  275. static size_t ngx_http_mp4_update_mdat_atom(ngx_http_mp4_file_t *mp4,
  276.     off_t start_offset, off_t end_offset);
  277. static ngx_int_t ngx_http_mp4_read_mvhd_atom(ngx_http_mp4_file_t *mp4,
  278.     uint64_t atom_data_size);
  279. static ngx_int_t ngx_http_mp4_read_trak_atom(ngx_http_mp4_file_t *mp4,
  280.     uint64_t atom_data_size);
  281. static void ngx_http_mp4_update_trak_atom(ngx_http_mp4_file_t *mp4,
  282.     ngx_http_mp4_trak_t *trak);
  283. static ngx_int_t ngx_http_mp4_read_cmov_atom(ngx_http_mp4_file_t *mp4,
  284.     uint64_t atom_data_size);
  285. static ngx_int_t ngx_http_mp4_read_tkhd_atom(ngx_http_mp4_file_t *mp4,
  286.     uint64_t atom_data_size);
  287. static ngx_int_t ngx_http_mp4_read_mdia_atom(ngx_http_mp4_file_t *mp4,
  288.     uint64_t atom_data_size);
  289. static void ngx_http_mp4_update_mdia_atom(ngx_http_mp4_file_t *mp4,
  290.     ngx_http_mp4_trak_t *trak);
  291. static ngx_int_t ngx_http_mp4_read_mdhd_atom(ngx_http_mp4_file_t *mp4,
  292.     uint64_t atom_data_size);
  293. static void ngx_http_mp4_update_mdhd_atom(ngx_http_mp4_file_t *mp4,
  294.     ngx_http_mp4_trak_t *trak);
  295. static ngx_int_t ngx_http_mp4_read_hdlr_atom(ngx_http_mp4_file_t *mp4,
  296.     uint64_t atom_data_size);
  297. static ngx_int_t ngx_http_mp4_read_minf_atom(ngx_http_mp4_file_t *mp4,
  298.     uint64_t atom_data_size);
  299. static void ngx_http_mp4_update_minf_atom(ngx_http_mp4_file_t *mp4,
  300.     ngx_http_mp4_trak_t *trak);
  301. static ngx_int_t ngx_http_mp4_read_dinf_atom(ngx_http_mp4_file_t *mp4,
  302.     uint64_t atom_data_size);
  303. static ngx_int_t ngx_http_mp4_read_vmhd_atom(ngx_http_mp4_file_t *mp4,
  304.     uint64_t atom_data_size);
  305. static ngx_int_t ngx_http_mp4_read_smhd_atom(ngx_http_mp4_file_t *mp4,
  306.     uint64_t atom_data_size);
  307. static ngx_int_t ngx_http_mp4_read_stbl_atom(ngx_http_mp4_file_t *mp4,
  308.     uint64_t atom_data_size);
  309. static void ngx_http_mp4_update_edts_atom(ngx_http_mp4_file_t *mp4,
  310.     ngx_http_mp4_trak_t *trak);
  311. static void ngx_http_mp4_update_stbl_atom(ngx_http_mp4_file_t *mp4,
  312.     ngx_http_mp4_trak_t *trak);
  313. static ngx_int_t ngx_http_mp4_read_stsd_atom(ngx_http_mp4_file_t *mp4,
  314.     uint64_t atom_data_size);
  315. static ngx_int_t ngx_http_mp4_read_stts_atom(ngx_http_mp4_file_t *mp4,
  316.     uint64_t atom_data_size);
  317. static ngx_int_t ngx_http_mp4_update_stts_atom(ngx_http_mp4_file_t *mp4,
  318.     ngx_http_mp4_trak_t *trak);
  319. static ngx_int_t ngx_http_mp4_crop_stts_data(ngx_http_mp4_file_t *mp4,
  320.     ngx_http_mp4_trak_t *trak, ngx_uint_t start);
  321. static ngx_int_t ngx_http_mp4_seek_key_frame(ngx_http_mp4_file_t *mp4,
  322.     ngx_http_mp4_trak_t *trak, uint32_t start_sample, uint32_t *key_prefix);
  323. static ngx_int_t ngx_http_mp4_read_stss_atom(ngx_http_mp4_file_t *mp4,
  324.     uint64_t atom_data_size);
  325. static ngx_int_t ngx_http_mp4_update_stss_atom(ngx_http_mp4_file_t *mp4,
  326.     ngx_http_mp4_trak_t *trak);
  327. static void ngx_http_mp4_crop_stss_data(ngx_http_mp4_file_t *mp4,
  328.     ngx_http_mp4_trak_t *trak, ngx_uint_t start);
  329. static ngx_int_t ngx_http_mp4_read_ctts_atom(ngx_http_mp4_file_t *mp4,
  330.     uint64_t atom_data_size);
  331. static void ngx_http_mp4_update_ctts_atom(ngx_http_mp4_file_t *mp4,
  332.     ngx_http_mp4_trak_t *trak);
  333. static void ngx_http_mp4_crop_ctts_data(ngx_http_mp4_file_t *mp4,
  334.     ngx_http_mp4_trak_t *trak, ngx_uint_t start);
  335. static ngx_int_t ngx_http_mp4_read_stsc_atom(ngx_http_mp4_file_t *mp4,
  336.     uint64_t atom_data_size);
  337. static ngx_int_t ngx_http_mp4_update_stsc_atom(ngx_http_mp4_file_t *mp4,
  338.     ngx_http_mp4_trak_t *trak);
  339. static ngx_int_t ngx_http_mp4_crop_stsc_data(ngx_http_mp4_file_t *mp4,
  340.     ngx_http_mp4_trak_t *trak, ngx_uint_t start);
  341. static ngx_int_t ngx_http_mp4_read_stsz_atom(ngx_http_mp4_file_t *mp4,
  342.     uint64_t atom_data_size);
  343. static ngx_int_t ngx_http_mp4_update_stsz_atom(ngx_http_mp4_file_t *mp4,
  344.     ngx_http_mp4_trak_t *trak);
  345. static ngx_int_t ngx_http_mp4_read_stco_atom(ngx_http_mp4_file_t *mp4,
  346.     uint64_t atom_data_size);
  347. static ngx_int_t ngx_http_mp4_update_stco_atom(ngx_http_mp4_file_t *mp4,
  348.     ngx_http_mp4_trak_t *trak);
  349. static void ngx_http_mp4_adjust_stco_atom(ngx_http_mp4_file_t *mp4,
  350.     ngx_http_mp4_trak_t *trak, int32_t adjustment);
  351. static ngx_int_t ngx_http_mp4_read_co64_atom(ngx_http_mp4_file_t *mp4,
  352.     uint64_t atom_data_size);
  353. static ngx_int_t ngx_http_mp4_update_co64_atom(ngx_http_mp4_file_t *mp4,
  354.     ngx_http_mp4_trak_t *trak);
  355. static void ngx_http_mp4_adjust_co64_atom(ngx_http_mp4_file_t *mp4,
  356.     ngx_http_mp4_trak_t *trak, off_t adjustment);

  358. static char *ngx_http_mp4(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  359. static void *ngx_http_mp4_create_conf(ngx_conf_t *cf);
  360. static char *ngx_http_mp4_merge_conf(ngx_conf_t *cf, void *parent, void *child);


  363. ‌static ngx_command_t  ngx_http_mp4_commands[] = {

  365.     { ngx_string("mp4"),
  366.       NGX_HTTP_LOC_CONF|NGX_CONF_NOARGS,
  367.       ngx_http_mp4,
  368.       0,
  369.       0,
  370.       NULL },

  372.     { ngx_string("mp4_buffer_size"),
  373.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  374.       ngx_conf_set_size_slot,
  375.       NGX_HTTP_LOC_CONF_OFFSET,
  376.       offsetof(ngx_http_mp4_conf_t, buffer_size),
  377.       NULL },

  379.     { ngx_string("mp4_max_buffer_size"),
  380.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  381.       ngx_conf_set_size_slot,
  382.       NGX_HTTP_LOC_CONF_OFFSET,
  383.       offsetof(ngx_http_mp4_conf_t, max_buffer_size),
  384.       NULL },

  386.     { ngx_string("mp4_start_key_frame"),
  387.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  388.       ngx_conf_set_flag_slot,
  389.       NGX_HTTP_LOC_CONF_OFFSET,
  390.       offsetof(ngx_http_mp4_conf_t, start_key_frame),
  391.       NULL },

  393.       ngx_null_command
  394. };


  397. ‌static ngx_http_module_t  ngx_http_mp4_module_ctx = {
  398.     NULL,                          /* preconfiguration */
  399.     NULL,                          /* postconfiguration */

  401.     NULL,                          /* create main configuration */
  402.     NULL,                          /* init main configuration */

  404.     NULL,                          /* create server configuration */
  405.     NULL,                          /* merge server configuration */

  407.     ngx_http_mp4_create_conf,      /* create location configuration */
  408.     ngx_http_mp4_merge_conf        /* merge location configuration */
  409. };


  412. ‌ngx_module_t  ngx_http_mp4_module = {
  413.     NGX_MODULE_V1,
  414.     &ngx_http_mp4_module_ctx,      /* module context */
  415.     ngx_http_mp4_commands,         /* module directives */
  416.     NGX_HTTP_MODULE,               /* module type */
  417.     NULL,                          /* init master */
  418.     NULL,                          /* init module */
  419.     NULL,                          /* init process */
  420.     NULL,                          /* init thread */
  421.     NULL,                          /* exit thread */
  422.     NULL,                          /* exit process */
  423.     NULL,                          /* exit master */
  424.     NGX_MODULE_V1_PADDING
  425. };


  428. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_atoms[] = {
  429.     { "ftyp", ngx_http_mp4_read_ftyp_atom },
  430.     { "moov", ngx_http_mp4_read_moov_atom },
  431.     { "mdat", ngx_http_mp4_read_mdat_atom },
  432.     { NULL, NULL }
  433. };

  435. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_moov_atoms[] = {
  436.     { "mvhd", ngx_http_mp4_read_mvhd_atom },
  437.     { "trak", ngx_http_mp4_read_trak_atom },
  438.     { "cmov", ngx_http_mp4_read_cmov_atom },
  439.     { NULL, NULL }
  440. };

  442. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_trak_atoms[] = {
  443.     { "tkhd", ngx_http_mp4_read_tkhd_atom },
  444.     { "mdia", ngx_http_mp4_read_mdia_atom },
  445.     { NULL, NULL }
  446. };

  448. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_mdia_atoms[] = {
  449.     { "mdhd", ngx_http_mp4_read_mdhd_atom },
  450.     { "hdlr", ngx_http_mp4_read_hdlr_atom },
  451.     { "minf", ngx_http_mp4_read_minf_atom },
  452.     { NULL, NULL }
  453. };

  455. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_minf_atoms[] = {
  456.     { "vmhd", ngx_http_mp4_read_vmhd_atom },
  457.     { "smhd", ngx_http_mp4_read_smhd_atom },
  458.     { "dinf", ngx_http_mp4_read_dinf_atom },
  459.     { "stbl", ngx_http_mp4_read_stbl_atom },
  460.     { NULL, NULL }
  461. };

  463. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_stbl_atoms[] = {
  464.     { "stsd", ngx_http_mp4_read_stsd_atom },
  465.     { "stts", ngx_http_mp4_read_stts_atom },
  466.     { "stss", ngx_http_mp4_read_stss_atom },
  467.     { "ctts", ngx_http_mp4_read_ctts_atom },
  468.     { "stsc", ngx_http_mp4_read_stsc_atom },
  469.     { "stsz", ngx_http_mp4_read_stsz_atom },
  470.     { "stco", ngx_http_mp4_read_stco_atom },
  471.     { "co64", ngx_http_mp4_read_co64_atom },
  472.     { NULL, NULL }
  473. };


  476. static ngx_int_t
  477. ‌ngx_http_mp4_handler(ngx_http_request_t *r)
  478. {
  479.     u_char                    *last;
  480.     size_t                     root;
  481.     ngx_int_t                  rc, start, end;
  482.     ngx_uint_t                 level, length;
  483.     ngx_str_t                  path, value;
  484.     ngx_log_t                 *log;
  485.     ngx_buf_t                 *b;
  486.     ngx_chain_t                out;
  487.     ngx_http_mp4_file_t       *mp4;
  488.     ngx_open_file_info_t       of;
  489.     ngx_http_core_loc_conf_t  *clcf;

  491.     if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD))) {
  492.         return NGX_HTTP_NOT_ALLOWED;
  493.     }

  495.     if (r->uri.data[r->uri.len - 1] == '/') {
  496.         return NGX_DECLINED;
  497.     }

  499.     rc = ngx_http_discard_request_body(r);

  501.     if (rc != NGX_OK) {
  502.         return rc;
  503.     }

  505.     last = ngx_http_map_uri_to_path(r, &path, &root, 0);
  506.     if (last == NULL) {
  507.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  508.     }

  510.     log = r->connection->log;

  512.     path.len = last - path.data;

  514.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
  515.                    "http mp4 filename: \"%V\"", &path);

  517.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  519.     ngx_memzero(&of, sizeof(ngx_open_file_info_t));

  521.     of.read_ahead = clcf->read_ahead;
  522.     of.directio = NGX_MAX_OFF_T_VALUE;
  523.     of.valid = clcf->open_file_cache_valid;
  524.     of.min_uses = clcf->open_file_cache_min_uses;
  525.     of.errors = clcf->open_file_cache_errors;
  526.     of.events = clcf->open_file_cache_events;

  528.     if (ngx_http_set_disable_symlinks(r, clcf, &path, &of) != NGX_OK) {
  529.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  530.     }

  532.     if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
  533.         != NGX_OK)
  534.     {
  535.         switch (of.err) {

  537.         case 0:
  538.             return NGX_HTTP_INTERNAL_SERVER_ERROR;

  540.         case NGX_ENOENT:
  541.         case NGX_ENOTDIR:
  542.         case NGX_ENAMETOOLONG:

  544.             level = NGX_LOG_ERR;
  545.             rc = NGX_HTTP_NOT_FOUND;
  546.             break;

  548.         case NGX_EACCES:
  549. #if (NGX_HAVE_OPENAT)
  550.         case NGX_EMLINK:
  551.         case NGX_ELOOP:
  552. #endif

  554.             level = NGX_LOG_ERR;
  555.             rc = NGX_HTTP_FORBIDDEN;
  556.             break;

  558.         default:

  560.             level = NGX_LOG_CRIT;
  561.             rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  562.             break;
  563.         }

  565.         if (rc != NGX_HTTP_NOT_FOUND || clcf->log_not_found) {
  566.             ngx_log_error(level, log, of.err,
  567.                           "%s \"%s\" failed", of.failed, path.data);
  568.         }

  570.         return rc;
  571.     }

  573.     if (!of.is_file) {
  574.         return NGX_DECLINED;
  575.     }

  577.     r->root_tested = !r->error_page;
  578.     r->allow_ranges = 1;

  580.     start = -1;
  581.     length = 0;
  582.     r->headers_out.content_length_n = of.size;
  583.     mp4 = NULL;
  584.     b = NULL;

  586.     if (r->args.len) {

  588.         if (ngx_http_arg(r, (u_char *) "start", 5, &value) == NGX_OK) {

  590.             /*
  591.              * A Flash player may send start value with a lot of digits
  592.              * after dot so a custom function is used instead of ngx_atofp().
  593.              */

  595.             start = ngx_http_mp4_atofp(value.data, value.len, 3);
  596.         }

  598.         if (ngx_http_arg(r, (u_char *) "end", 3, &value) == NGX_OK) {

  600.             end = ngx_http_mp4_atofp(value.data, value.len, 3);

  602.             if (end > 0) {
  603.                 if (start < 0) {
  604.                     start = 0;
  605.                 }

  607.                 if (end > start) {
  608.                     length = end - start;
  609.                 }
  610.             }
  611.         }
  612.     }

  614.     if (start >= 0) {
  615.         r->single_range = 1;

  617.         mp4 = ngx_pcalloc(r->pool, sizeof(ngx_http_mp4_file_t));
  618.         if (mp4 == NULL) {
  619.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  620.         }

  622.         mp4->file.fd = of.fd;
  623.         mp4->file.name = path;
  624.         mp4->file.log = r->connection->log;
  625.         mp4->end = of.size;
  626.         mp4->start = (ngx_uint_t) start;
  627.         mp4->length = length;
  628.         mp4->request = r;

  630.         switch (ngx_http_mp4_process(mp4)) {

  632.         case NGX_DECLINED:
  633.             if (mp4->buffer) {
  634.                 ngx_pfree(r->pool, mp4->buffer);
  635.             }

  637.             ngx_pfree(r->pool, mp4);
  638.             mp4 = NULL;

  640.             break;

  642.         case NGX_OK:
  643.             r->headers_out.content_length_n = mp4->content_length;
  644.             break;

  646.         default: /* NGX_ERROR */
  647.             if (mp4->buffer) {
  648.                 ngx_pfree(r->pool, mp4->buffer);
  649.             }

  651.             ngx_pfree(r->pool, mp4);

  653.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  654.         }
  655.     }

  657.     log->action = "sending mp4 to client";

  659.     if (clcf->directio <= of.size) {

  661.         /*
  662.          * DIRECTIO is set on transfer only
  663.          * to allow kernel to cache "moov" atom
  664.          */

  666.         if (ngx_directio_on(of.fd) == NGX_FILE_ERROR) {
  667.             ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
  668.                           ngx_directio_on_n " \"%s\" failed", path.data);
  669.         }

  671.         of.is_directio = 1;

  673.         if (mp4) {
  674.             mp4->file.directio = 1;
  675.         }
  676.     }

  678.     r->headers_out.status = NGX_HTTP_OK;
  679.     r->headers_out.last_modified_time = of.mtime;

  681.     if (ngx_http_set_etag(r) != NGX_OK) {
  682.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  683.     }

  685.     if (ngx_http_set_content_type(r) != NGX_OK) {
  686.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  687.     }

  689.     if (mp4 == NULL) {
  690.         b = ngx_calloc_buf(r->pool);
  691.         if (b == NULL) {
  692.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  693.         }

  695.         b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
  696.         if (b->file == NULL) {
  697.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  698.         }
  699.     }

  701.     rc = ngx_http_send_header(r);

  703.     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  704.         return rc;
  705.     }

  707.     if (mp4) {
  708.         return ngx_http_output_filter(r, mp4->out);
  709.     }

  711.     b->file_pos = 0;
  712.     b->file_last = of.size;

  714.     b->in_file = b->file_last ? 1 : 0;
  715.     b->last_buf = (r == r->main) ? 1 : 0;
  716.     b->last_in_chain = 1;
  717.     b->sync = (b->last_buf || b->in_file) ? 0 : 1;

  719.     b->file->fd = of.fd;
  720.     b->file->name = path;
  721.     b->file->log = log;
  722.     b->file->directio = of.is_directio;

  724.     out.buf = b;
  725.     out.next = NULL;

  727.     return ngx_http_output_filter(r, &out);
  728. }


  731. static ngx_int_t
  732. ‌ngx_http_mp4_atofp(u_char *line, size_t n, size_t point)
  733. {
  734.     ngx_int_t   value, cutoff, cutlim;
  735.     ngx_uint_t  dot;

  737.     /* same as ngx_atofp(), but allows additional digits */

  739.     if (n == 0) {
  740.         return NGX_ERROR;
  741.     }

  743.     cutoff = NGX_MAX_INT_T_VALUE / 10;
  744.     cutlim = NGX_MAX_INT_T_VALUE % 10;

  746.     dot = 0;

  748.     for (value = 0; n--; line++) {

  750.         if (*line == '.') {
  751.             if (dot) {
  752.                 return NGX_ERROR;
  753.             }

  755.             dot = 1;
  756.             continue;
  757.         }

  759.         if (*line < '0' || *line > '9') {
  760.             return NGX_ERROR;
  761.         }

  763.         if (point == 0) {
  764.             continue;
  765.         }

  767.         if (value >= cutoff && (value > cutoff || *line - '0' > cutlim)) {
  768.             return NGX_ERROR;
  769.         }

  771.         value = value * 10 + (*line - '0');
  772.         point -= dot;
  773.     }

  775.     while (point--) {
  776.         if (value > cutoff) {
  777.             return NGX_ERROR;
  778.         }

  780.         value = value * 10;
  781.     }

  783.     return value;
  784. }


  787. static ngx_int_t
  788. ‌ngx_http_mp4_process(ngx_http_mp4_file_t *mp4)
  789. {
  790.     off_t                  start_offset, end_offset, adjustment;
  791.     ngx_int_t              rc;
  792.     ngx_uint_t             i, j;
  793.     ngx_chain_t          **prev;
  794.     ngx_http_mp4_trak_t   *trak;
  795.     ngx_http_mp4_conf_t   *conf;

  797.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  798.                    "mp4 start:%ui, length:%ui", mp4->start, mp4->length);

  800.     conf = ngx_http_get_module_loc_conf(mp4->request, ngx_http_mp4_module);

  802.     mp4->buffer_size = conf->buffer_size;

  804.     rc = ngx_http_mp4_read_atom(mp4, ngx_http_mp4_atoms, mp4->end);
  805.     if (rc != NGX_OK) {
  806.         return rc;
  807.     }

  809.     if (mp4->trak.nelts == 0) {
  810.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  811.                       "no mp4 trak atoms were found in \"%s\"",
  812.                       mp4->file.name.data);
  813.         return NGX_ERROR;
  814.     }

  816.     if (mp4->mdat_atom.buf == NULL) {
  817.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  818.                       "no mp4 mdat atom was found in \"%s\"",
  819.                       mp4->file.name.data);
  820.         return NGX_ERROR;
  821.     }

  823.     prev = &mp4->out;

  825.     if (mp4->ftyp_atom.buf) {
  826.         *prev = &mp4->ftyp_atom;
  827.         prev = &mp4->ftyp_atom.next;
  828.     }

  830.     *prev = &mp4->moov_atom;
  831.     prev = &mp4->moov_atom.next;

  833.     if (mp4->mvhd_atom.buf) {
  834.         mp4->moov_size += mp4->mvhd_atom_buf.last - mp4->mvhd_atom_buf.pos;
  835.         *prev = &mp4->mvhd_atom;
  836.         prev = &mp4->mvhd_atom.next;
  837.     }

  839.     start_offset = mp4->end;
  840.     end_offset = 0;
  841.     trak = mp4->trak.elts;

  843.     for (i = 0; i < mp4->trak.nelts; i++) {

  845.         if (ngx_http_mp4_update_stts_atom(mp4, &trak[i]) != NGX_OK) {
  846.             return NGX_ERROR;
  847.         }

  849.         if (ngx_http_mp4_update_stss_atom(mp4, &trak[i]) != NGX_OK) {
  850.             return NGX_ERROR;
  851.         }

  853.         ngx_http_mp4_update_ctts_atom(mp4, &trak[i]);

  855.         if (ngx_http_mp4_update_stsc_atom(mp4, &trak[i]) != NGX_OK) {
  856.             return NGX_ERROR;
  857.         }

  859.         if (ngx_http_mp4_update_stsz_atom(mp4, &trak[i]) != NGX_OK) {
  860.             return NGX_ERROR;
  861.         }

  863.         if (trak[i].out[NGX_HTTP_MP4_CO64_DATA].buf) {
  864.             if (ngx_http_mp4_update_co64_atom(mp4, &trak[i]) != NGX_OK) {
  865.                 return NGX_ERROR;
  866.             }

  868.         } else {
  869.             if (ngx_http_mp4_update_stco_atom(mp4, &trak[i]) != NGX_OK) {
  870.                 return NGX_ERROR;
  871.             }
  872.         }

  874.         ngx_http_mp4_update_stbl_atom(mp4, &trak[i]);
  875.         ngx_http_mp4_update_minf_atom(mp4, &trak[i]);
  876.         ngx_http_mp4_update_mdhd_atom(mp4, &trak[i]);
  877.         trak[i].size += trak[i].hdlr_size;
  878.         ngx_http_mp4_update_mdia_atom(mp4, &trak[i]);
  879.         trak[i].size += trak[i].tkhd_size;
  880.         ngx_http_mp4_update_edts_atom(mp4, &trak[i]);
  881.         ngx_http_mp4_update_trak_atom(mp4, &trak[i]);

  883.         mp4->moov_size += trak[i].size;

  885.         if (start_offset > trak[i].start_offset) {
  886.             start_offset = trak[i].start_offset;
  887.         }

  889.         if (end_offset < trak[i].end_offset) {
  890.             end_offset = trak[i].end_offset;
  891.         }

  893.         *prev = &trak[i].out[NGX_HTTP_MP4_TRAK_ATOM];
  894.         prev = &trak[i].out[NGX_HTTP_MP4_TRAK_ATOM].next;

  896.         for (j = 0; j < NGX_HTTP_MP4_LAST_ATOM + 1; j++) {
  897.             if (trak[i].out[j].buf) {
  898.                 *prev = &trak[i].out[j];
  899.                 prev = &trak[i].out[j].next;
  900.             }
  901.         }
  902.     }

  904.     if (end_offset <= start_offset) {
  905.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  906.                       "no data between start time and end time in \"%s\"",
  907.                       mp4->file.name.data);
  908.         return NGX_ERROR;
  909.     }

  911.     mp4->moov_size += 8;

  913.     ngx_mp4_set_32value(mp4->moov_atom_header, mp4->moov_size);
  914.     ngx_mp4_set_atom_name(mp4->moov_atom_header, 'm', 'o', 'o', 'v');
  915.     mp4->content_length += mp4->moov_size;

  917.     *prev = &mp4->mdat_atom;

  919.     if (start_offset >= mp4->mdat_data.buf->file_last) {
  920.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  921.                       "start time is out mp4 mdat atom in \"%s\"",
  922.                       mp4->file.name.data);
  923.         return NGX_ERROR;
  924.     }

  926.     adjustment = mp4->ftyp_size + mp4->moov_size
  927.                  + ngx_http_mp4_update_mdat_atom(mp4, start_offset, end_offset)
  928.                  - start_offset;

  930.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  931.                    "mp4 adjustment:%O", adjustment);

  933.     for (i = 0; i < mp4->trak.nelts; i++) {
  934.         if (trak[i].out[NGX_HTTP_MP4_CO64_DATA].buf) {
  935.             ngx_http_mp4_adjust_co64_atom(mp4, &trak[i], adjustment);
  936.         } else {
  937.             ngx_http_mp4_adjust_stco_atom(mp4, &trak[i], (int32_t) adjustment);
  938.         }
  939.     }

  941.     return NGX_OK;
  942. }


  945. ‌typedef struct {
  946.     u_char    size[4];
  947.     u_char    name[4];
  948. ‌} ngx_mp4_atom_header_t;

  950. ‌typedef struct {
  951.     u_char    size[4];
  952.     u_char    name[4];
  953.     u_char    size64[8];
  954. ‌} ngx_mp4_atom_header64_t;


  957. static ngx_int_t
  958. ‌ngx_http_mp4_read_atom(ngx_http_mp4_file_t *mp4,
  959.     ngx_http_mp4_atom_handler_t *atom, uint64_t atom_data_size)
  960. {
  961.     off_t        end;
  962.     size_t       atom_header_size;
  963.     u_char      *atom_header, *atom_name;
  964.     uint64_t     atom_size;
  965.     ngx_int_t    rc;
  966.     ngx_uint_t   n;

  968.     end = mp4->offset + atom_data_size;

  970.     while (mp4->offset < end) {

  972.         if (ngx_http_mp4_read(mp4, sizeof(uint32_t)) != NGX_OK) {
  973.             return NGX_ERROR;
  974.         }

  976.         atom_header = mp4->buffer_pos;
  977.         atom_size = ngx_mp4_get_32value(atom_header);
  978.         atom_header_size = sizeof(ngx_mp4_atom_header_t);

  980.         if (atom_size == 0) {
  981.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  982.                            "mp4 atom end");
  983.             return NGX_OK;
  984.         }

  986.         if (atom_size < sizeof(ngx_mp4_atom_header_t)) {

  988.             if (atom_size == 1) {

  990.                 if (ngx_http_mp4_read(mp4, sizeof(ngx_mp4_atom_header64_t))
  991.                     != NGX_OK)
  992.                 {
  993.                     return NGX_ERROR;
  994.                 }

  996.                 /* 64-bit atom size */
  997.                 atom_header = mp4->buffer_pos;
  998.                 atom_size = ngx_mp4_get_64value(atom_header + 8);
  999.                 atom_header_size = sizeof(ngx_mp4_atom_header64_t);

  1001.                 if (atom_size < sizeof(ngx_mp4_atom_header64_t)) {
  1002.                     ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1003.                                   "\"%s\" mp4 atom is too small:%uL",
  1004.                                   mp4->file.name.data, atom_size);
  1005.                     return NGX_ERROR;
  1006.                 }

  1008.             } else {
  1009.                 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1010.                               "\"%s\" mp4 atom is too small:%uL",
  1011.                               mp4->file.name.data, atom_size);
  1012.                 return NGX_ERROR;
  1013.             }
  1014.         }

  1016.         if (ngx_http_mp4_read(mp4, sizeof(ngx_mp4_atom_header_t)) != NGX_OK) {
  1017.             return NGX_ERROR;
  1018.         }

  1020.         atom_header = mp4->buffer_pos;
  1021.         atom_name = atom_header + sizeof(uint32_t);

  1023.         ngx_log_debug4(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1024.                        "mp4 atom: %*s @%O:%uL",
  1025.                        (size_t) 4, atom_name, mp4->offset, atom_size);

  1027.         if (atom_size > (uint64_t) (NGX_MAX_OFF_T_VALUE - mp4->offset)
  1028.             || mp4->offset + (off_t) atom_size > end)
  1029.         {
  1030.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1031.                           "\"%s\" mp4 atom too large:%uL",
  1032.                           mp4->file.name.data, atom_size);
  1033.             return NGX_ERROR;
  1034.         }

  1036.         for (n = 0; atom[n].name; n++) {

  1038.             if (ngx_strncmp(atom_name, atom[n].name, 4) == 0) {

  1040.                 ngx_mp4_atom_next(mp4, atom_header_size);

  1042.                 rc = atom[n].handler(mp4, atom_size - atom_header_size);
  1043.                 if (rc != NGX_OK) {
  1044.                     return rc;
  1045.                 }

  1047.                 goto next;
  1048.             }
  1049.         }

  1051.         ngx_mp4_atom_next(mp4, atom_size);

  1053.     next:
  1054.         continue;
  1055.     }

  1057.     return NGX_OK;
  1058. }


  1061. static ngx_int_t
  1062. ‌ngx_http_mp4_read(ngx_http_mp4_file_t *mp4, size_t size)
  1063. {
  1064.     ssize_t  n;

  1066.     if (mp4->buffer_pos + size <= mp4->buffer_end) {
  1067.         return NGX_OK;
  1068.     }

  1070.     if (mp4->offset + (off_t) mp4->buffer_size > mp4->end) {
  1071.         mp4->buffer_size = (size_t) (mp4->end - mp4->offset);
  1072.     }

  1074.     if (mp4->buffer_size < size) {
  1075.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1076.                       "\"%s\" mp4 file truncated", mp4->file.name.data);
  1077.         return NGX_ERROR;
  1078.     }

  1080.     if (mp4->buffer == NULL) {
  1081.         mp4->buffer = ngx_palloc(mp4->request->pool, mp4->buffer_size);
  1082.         if (mp4->buffer == NULL) {
  1083.             return NGX_ERROR;
  1084.         }

  1086.         mp4->buffer_start = mp4->buffer;
  1087.     }

  1089.     n = ngx_read_file(&mp4->file, mp4->buffer_start, mp4->buffer_size,
  1090.                       mp4->offset);

  1092.     if (n == NGX_ERROR) {
  1093.         return NGX_ERROR;
  1094.     }

  1096.     if ((size_t) n != mp4->buffer_size) {
  1097.         ngx_log_error(NGX_LOG_CRIT, mp4->file.log, 0,
  1098.                       ngx_read_file_n " read only %z of %z from \"%s\"",
  1099.                       n, mp4->buffer_size, mp4->file.name.data);
  1100.         return NGX_ERROR;
  1101.     }

  1103.     mp4->buffer_pos = mp4->buffer_start;
  1104.     mp4->buffer_end = mp4->buffer_start + mp4->buffer_size;

  1106.     return NGX_OK;
  1107. }


  1110. static ngx_int_t
  1111. ‌ngx_http_mp4_read_ftyp_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1112. {
  1113.     u_char     *ftyp_atom;
  1114.     size_t      atom_size;
  1115.     ngx_buf_t  *atom;

  1117.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 ftyp atom");

  1119.     if (atom_data_size > 1024
  1120.         || ngx_mp4_atom_data(mp4) + (size_t) atom_data_size > mp4->buffer_end)
  1121.     {
  1122.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1123.                       "\"%s\" mp4 ftyp atom is too large:%uL",
  1124.                       mp4->file.name.data, atom_data_size);
  1125.         return NGX_ERROR;
  1126.     }

  1128.     if (mp4->ftyp_atom.buf) {
  1129.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1130.                       "duplicate mp4 ftyp atom in \"%s\"", mp4->file.name.data);
  1131.         return NGX_ERROR;
  1132.     }

  1134.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;

  1136.     ftyp_atom = ngx_palloc(mp4->request->pool, atom_size);
  1137.     if (ftyp_atom == NULL) {
  1138.         return NGX_ERROR;
  1139.     }

  1141.     ngx_mp4_set_32value(ftyp_atom, atom_size);
  1142.     ngx_mp4_set_atom_name(ftyp_atom, 'f', 't', 'y', 'p');

  1144.     /*
  1145.      * only moov atom content is guaranteed to be in mp4->buffer
  1146.      * during sending response, so ftyp atom content should be copied
  1147.      */
  1148.     ngx_memcpy(ftyp_atom + sizeof(ngx_mp4_atom_header_t),
  1149.                ngx_mp4_atom_data(mp4), (size_t) atom_data_size);

  1151.     atom = &mp4->ftyp_atom_buf;
  1152.     atom->temporary = 1;
  1153.     atom->pos = ftyp_atom;
  1154.     atom->last = ftyp_atom + atom_size;

  1156.     mp4->ftyp_atom.buf = atom;
  1157.     mp4->ftyp_size = atom_size;
  1158.     mp4->content_length = atom_size;

  1160.     ngx_mp4_atom_next(mp4, atom_data_size);

  1162.     return NGX_OK;
  1163. }


  1166. /*
  1167. * Small excess buffer to process atoms after moov atom, mp4->buffer_start
  1168. * will be set to this buffer part after moov atom processing.
  1169. */
  1170. ‌#define NGX_HTTP_MP4_MOOV_BUFFER_EXCESS  (4 * 1024)

  1172. static ngx_int_t
  1173. ‌ngx_http_mp4_read_moov_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1174. {
  1175.     ngx_int_t             rc;
  1176.     ngx_uint_t            no_mdat;
  1177.     ngx_buf_t            *atom;
  1178.     ngx_http_mp4_conf_t  *conf;

  1180.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 moov atom");

  1182.     no_mdat = (mp4->mdat_atom.buf == NULL);

  1184.     if (no_mdat && mp4->start == 0 && mp4->length == 0) {
  1185.         /*
  1186.          * send original file if moov atom resides before
  1187.          * mdat atom and client requests integral file
  1188.          */
  1189.         return NGX_DECLINED;
  1190.     }

  1192.     if (mp4->moov_atom.buf) {
  1193.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1194.                       "duplicate mp4 moov atom in \"%s\"", mp4->file.name.data);
  1195.         return NGX_ERROR;
  1196.     }

  1198.     conf = ngx_http_get_module_loc_conf(mp4->request, ngx_http_mp4_module);

  1200.     if (atom_data_size > mp4->buffer_size) {

  1202.         if (atom_data_size > conf->max_buffer_size) {
  1203.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1204.                           "\"%s\" mp4 moov atom is too large:%uL, "
  1205.                           "you may want to increase mp4_max_buffer_size",
  1206.                           mp4->file.name.data, atom_data_size);
  1207.             return NGX_ERROR;
  1208.         }

  1210.         ngx_pfree(mp4->request->pool, mp4->buffer);
  1211.         mp4->buffer = NULL;
  1212.         mp4->buffer_pos = NULL;
  1213.         mp4->buffer_end = NULL;

  1215.         mp4->buffer_size = (size_t) atom_data_size
  1216.                          + NGX_HTTP_MP4_MOOV_BUFFER_EXCESS * no_mdat;
  1217.     }

  1219.     if (ngx_http_mp4_read(mp4, (size_t) atom_data_size) != NGX_OK) {
  1220.         return NGX_ERROR;
  1221.     }

  1223.     mp4->trak.elts = &mp4->traks;
  1224.     mp4->trak.size = sizeof(ngx_http_mp4_trak_t);
  1225.     mp4->trak.nalloc = 2;
  1226.     mp4->trak.pool = mp4->request->pool;

  1228.     atom = &mp4->moov_atom_buf;
  1229.     atom->temporary = 1;
  1230.     atom->pos = mp4->moov_atom_header;
  1231.     atom->last = mp4->moov_atom_header + 8;

  1233.     mp4->moov_atom.buf = &mp4->moov_atom_buf;

  1235.     rc = ngx_http_mp4_read_atom(mp4, ngx_http_mp4_moov_atoms, atom_data_size);

  1237.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 moov atom done");

  1239.     if (no_mdat) {
  1240.         mp4->buffer_start = mp4->buffer_pos;
  1241.         mp4->buffer_size = NGX_HTTP_MP4_MOOV_BUFFER_EXCESS;

  1243.         if (mp4->buffer_start + mp4->buffer_size > mp4->buffer_end) {
  1244.             mp4->buffer = NULL;
  1245.             mp4->buffer_pos = NULL;
  1246.             mp4->buffer_end = NULL;
  1247.         }

  1249.     } else {
  1250.         /* skip atoms after moov atom */
  1251.         mp4->offset = mp4->end;
  1252.     }

  1254.     return rc;
  1255. }


  1258. static ngx_int_t
  1259. ‌ngx_http_mp4_read_mdat_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1260. {
  1261.     ngx_buf_t  *data;

  1263.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 mdat atom");

  1265.     if (mp4->mdat_atom.buf) {
  1266.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1267.                       "duplicate mp4 mdat atom in \"%s\"", mp4->file.name.data);
  1268.         return NGX_ERROR;
  1269.     }

  1271.     data = &mp4->mdat_data_buf;
  1272.     data->file = &mp4->file;
  1273.     data->in_file = 1;
  1274.     data->last_buf = (mp4->request == mp4->request->main) ? 1 : 0;
  1275.     data->last_in_chain = 1;
  1276.     data->file_last = mp4->offset + atom_data_size;

  1278.     mp4->mdat_atom.buf = &mp4->mdat_atom_buf;
  1279.     mp4->mdat_atom.next = &mp4->mdat_data;
  1280.     mp4->mdat_data.buf = data;

  1282.     if (mp4->trak.nelts) {
  1283.         /* skip atoms after mdat atom */
  1284.         mp4->offset = mp4->end;

  1286.     } else {
  1287.         ngx_mp4_atom_next(mp4, atom_data_size);
  1288.     }

  1290.     return NGX_OK;
  1291. }


  1294. static size_t
  1295. ‌ngx_http_mp4_update_mdat_atom(ngx_http_mp4_file_t *mp4, off_t start_offset,
  1296.     off_t end_offset)
  1297. {
  1298.     off_t       atom_data_size;
  1299.     u_char     *atom_header;
  1300.     uint32_t    atom_header_size;
  1301.     uint64_t    atom_size;
  1302.     ngx_buf_t  *atom;

  1304.     atom_data_size = end_offset - start_offset;
  1305.     mp4->mdat_data.buf->file_pos = start_offset;
  1306.     mp4->mdat_data.buf->file_last = end_offset;

  1308.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1309.                    "mdat new offset @%O:%O", start_offset, atom_data_size);

  1311.     atom_header = mp4->mdat_atom_header;

  1313.     if ((uint64_t) atom_data_size
  1314.         > (uint64_t) 0xffffffff - sizeof(ngx_mp4_atom_header_t))
  1315.     {
  1316.         atom_size = 1;
  1317.         atom_header_size = sizeof(ngx_mp4_atom_header64_t);
  1318.         ngx_mp4_set_64value(atom_header + sizeof(ngx_mp4_atom_header_t),
  1319.                             sizeof(ngx_mp4_atom_header64_t) + atom_data_size);
  1320.     } else {
  1321.         atom_size = sizeof(ngx_mp4_atom_header_t) + atom_data_size;
  1322.         atom_header_size = sizeof(ngx_mp4_atom_header_t);
  1323.     }

  1325.     mp4->content_length += atom_header_size + atom_data_size;

  1327.     ngx_mp4_set_32value(atom_header, atom_size);
  1328.     ngx_mp4_set_atom_name(atom_header, 'm', 'd', 'a', 't');

  1330.     atom = &mp4->mdat_atom_buf;
  1331.     atom->temporary = 1;
  1332.     atom->pos = atom_header;
  1333.     atom->last = atom_header + atom_header_size;

  1335.     return atom_header_size;
  1336. }


  1339. ‌typedef struct {
  1340.     u_char    size[4];
  1341.     u_char    name[4];
  1342.     u_char    version[1];
  1343.     u_char    flags[3];
  1344.     u_char    creation_time[4];
  1345.     u_char    modification_time[4];
  1346.     u_char    timescale[4];
  1347.     u_char    duration[4];
  1348.     u_char    rate[4];
  1349.     u_char    volume[2];
  1350.     u_char    reserved[10];
  1351.     u_char    matrix[36];
  1352.     u_char    preview_time[4];
  1353.     u_char    preview_duration[4];
  1354.     u_char    poster_time[4];
  1355.     u_char    selection_time[4];
  1356.     u_char    selection_duration[4];
  1357.     u_char    current_time[4];
  1358.     u_char    next_track_id[4];
  1359. ‌} ngx_mp4_mvhd_atom_t;

  1361. ‌typedef struct {
  1362.     u_char    size[4];
  1363.     u_char    name[4];
  1364.     u_char    version[1];
  1365.     u_char    flags[3];
  1366.     u_char    creation_time[8];
  1367.     u_char    modification_time[8];
  1368.     u_char    timescale[4];
  1369.     u_char    duration[8];
  1370.     u_char    rate[4];
  1371.     u_char    volume[2];
  1372.     u_char    reserved[10];
  1373.     u_char    matrix[36];
  1374.     u_char    preview_time[4];
  1375.     u_char    preview_duration[4];
  1376.     u_char    poster_time[4];
  1377.     u_char    selection_time[4];
  1378.     u_char    selection_duration[4];
  1379.     u_char    current_time[4];
  1380.     u_char    next_track_id[4];
  1381. ‌} ngx_mp4_mvhd64_atom_t;


  1384. static ngx_int_t
  1385. ‌ngx_http_mp4_read_mvhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1386. {
  1387.     u_char                 *atom_header;
  1388.     size_t                  atom_size;
  1389.     uint32_t                timescale;
  1390.     uint64_t                duration, start_time, length_time;
  1391.     ngx_buf_t              *atom;
  1392.     ngx_mp4_mvhd_atom_t    *mvhd_atom;
  1393.     ngx_mp4_mvhd64_atom_t  *mvhd64_atom;

  1395.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 mvhd atom");

  1397.     if (mp4->mvhd_atom.buf) {
  1398.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1399.                       "duplicate mp4 mvhd atom in \"%s\"", mp4->file.name.data);
  1400.         return NGX_ERROR;
  1401.     }

  1403.     atom_header = ngx_mp4_atom_header(mp4);
  1404.     mvhd_atom = (ngx_mp4_mvhd_atom_t *) atom_header;
  1405.     mvhd64_atom = (ngx_mp4_mvhd64_atom_t *) atom_header;
  1406.     ngx_mp4_set_atom_name(atom_header, 'm', 'v', 'h', 'd');

  1408.     if (ngx_mp4_atom_data_size(ngx_mp4_mvhd_atom_t) > atom_data_size) {
  1409.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1410.                       "\"%s\" mp4 mvhd atom too small", mp4->file.name.data);
  1411.         return NGX_ERROR;
  1412.     }

  1414.     if (mvhd_atom->version[0] == 0) {
  1415.         /* version 0: 32-bit duration */
  1416.         timescale = ngx_mp4_get_32value(mvhd_atom->timescale);
  1417.         duration = ngx_mp4_get_32value(mvhd_atom->duration);

  1419.     } else {
  1420.         /* version 1: 64-bit duration */

  1422.         if (ngx_mp4_atom_data_size(ngx_mp4_mvhd64_atom_t) > atom_data_size) {
  1423.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1424.                           "\"%s\" mp4 mvhd atom too small",
  1425.                           mp4->file.name.data);
  1426.             return NGX_ERROR;
  1427.         }

  1429.         timescale = ngx_mp4_get_32value(mvhd64_atom->timescale);
  1430.         duration = ngx_mp4_get_64value(mvhd64_atom->duration);
  1431.     }

  1433.     mp4->timescale = timescale;

  1435.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1436.                    "mvhd timescale:%uD, duration:%uL, time:%.3fs",
  1437.                    timescale, duration, (double) duration / timescale);

  1439.     start_time = (uint64_t) mp4->start * timescale / 1000;

  1441.     if (duration < start_time) {
  1442.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1443.                       "\"%s\" mp4 start time exceeds file duration",
  1444.                       mp4->file.name.data);
  1445.         return NGX_ERROR;
  1446.     }

  1448.     duration -= start_time;

  1450.     if (mp4->length) {
  1451.         length_time = (uint64_t) mp4->length * timescale / 1000;

  1453.         if (duration > length_time) {
  1454.             duration = length_time;
  1455.         }
  1456.     }

  1458.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1459.                    "mvhd new duration:%uL, time:%.3fs",
  1460.                    duration, (double) duration / timescale);

  1462.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  1463.     ngx_mp4_set_32value(mvhd_atom->size, atom_size);

  1465.     if (mvhd_atom->version[0] == 0) {
  1466.         ngx_mp4_set_32value(mvhd_atom->duration, duration);

  1468.     } else {
  1469.         ngx_mp4_set_64value(mvhd64_atom->duration, duration);
  1470.     }

  1472.     atom = &mp4->mvhd_atom_buf;
  1473.     atom->temporary = 1;
  1474.     atom->pos = atom_header;
  1475.     atom->last = atom_header + atom_size;

  1477.     mp4->mvhd_atom.buf = atom;

  1479.     ngx_mp4_atom_next(mp4, atom_data_size);

  1481.     return NGX_OK;
  1482. }


  1485. static ngx_int_t
  1486. ‌ngx_http_mp4_read_trak_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1487. {
  1488.     u_char               *atom_header, *atom_end;
  1489.     off_t                 atom_file_end;
  1490.     ngx_int_t             rc;
  1491.     ngx_buf_t            *atom;
  1492.     ngx_http_mp4_trak_t  *trak;

  1494.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 trak atom");

  1496.     trak = ngx_array_push(&mp4->trak);
  1497.     if (trak == NULL) {
  1498.         return NGX_ERROR;
  1499.     }

  1501.     ngx_memzero(trak, sizeof(ngx_http_mp4_trak_t));

  1503.     atom_header = ngx_mp4_atom_header(mp4);
  1504.     ngx_mp4_set_atom_name(atom_header, 't', 'r', 'a', 'k');

  1506.     atom = &trak->trak_atom_buf;
  1507.     atom->temporary = 1;
  1508.     atom->pos = atom_header;
  1509.     atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);

  1511.     trak->out[NGX_HTTP_MP4_TRAK_ATOM].buf = atom;

  1513.     atom_end = mp4->buffer_pos + (size_t) atom_data_size;
  1514.     atom_file_end = mp4->offset + atom_data_size;

  1516.     rc = ngx_http_mp4_read_atom(mp4, ngx_http_mp4_trak_atoms, atom_data_size);

  1518.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1519.                    "mp4 trak atom: %i", rc);

  1521.     if (rc == NGX_DECLINED) {
  1522.         /* skip this trak */
  1523.         ngx_memzero(trak, sizeof(ngx_http_mp4_trak_t));
  1524.         mp4->trak.nelts--;
  1525.         mp4->buffer_pos = atom_end;
  1526.         mp4->offset = atom_file_end;
  1527.         return NGX_OK;
  1528.     }

  1530.     return rc;
  1531. }


  1534. static void
  1535. ‌ngx_http_mp4_update_trak_atom(ngx_http_mp4_file_t *mp4,
  1536.     ngx_http_mp4_trak_t *trak)
  1537. {
  1538.     ngx_buf_t  *atom;

  1540.     trak->size += sizeof(ngx_mp4_atom_header_t);
  1541.     atom = &trak->trak_atom_buf;
  1542.     ngx_mp4_set_32value(atom->pos, trak->size);
  1543. }


  1546. static ngx_int_t
  1547. ‌ngx_http_mp4_read_cmov_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1548. {
  1549.     ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1550.                   "\"%s\" mp4 compressed moov atom (cmov) is not supported",
  1551.                   mp4->file.name.data);

  1553.     return NGX_ERROR;
  1554. }


  1557. ‌typedef struct {
  1558.     u_char    size[4];
  1559.     u_char    name[4];
  1560.     u_char    version[1];
  1561.     u_char    flags[3];
  1562.     u_char    creation_time[4];
  1563.     u_char    modification_time[4];
  1564.     u_char    track_id[4];
  1565.     u_char    reserved1[4];
  1566.     u_char    duration[4];
  1567.     u_char    reserved2[8];
  1568.     u_char    layer[2];
  1569.     u_char    group[2];
  1570.     u_char    volume[2];
  1571.     u_char    reserved3[2];
  1572.     u_char    matrix[36];
  1573.     u_char    width[4];
  1574.     u_char    height[4];
  1575. ‌} ngx_mp4_tkhd_atom_t;

  1577. ‌typedef struct {
  1578.     u_char    size[4];
  1579.     u_char    name[4];
  1580.     u_char    version[1];
  1581.     u_char    flags[3];
  1582.     u_char    creation_time[8];
  1583.     u_char    modification_time[8];
  1584.     u_char    track_id[4];
  1585.     u_char    reserved1[4];
  1586.     u_char    duration[8];
  1587.     u_char    reserved2[8];
  1588.     u_char    layer[2];
  1589.     u_char    group[2];
  1590.     u_char    volume[2];
  1591.     u_char    reserved3[2];
  1592.     u_char    matrix[36];
  1593.     u_char    width[4];
  1594.     u_char    height[4];
  1595. ‌} ngx_mp4_tkhd64_atom_t;


  1598. static ngx_int_t
  1599. ‌ngx_http_mp4_read_tkhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1600. {
  1601.     u_char                 *atom_header;
  1602.     size_t                  atom_size;
  1603.     uint64_t                duration, start_time, length_time;
  1604.     ngx_buf_t              *atom;
  1605.     ngx_http_mp4_trak_t    *trak;
  1606.     ngx_mp4_tkhd_atom_t    *tkhd_atom;
  1607.     ngx_mp4_tkhd64_atom_t  *tkhd64_atom;

  1609.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 tkhd atom");

  1611.     atom_header = ngx_mp4_atom_header(mp4);
  1612.     tkhd_atom = (ngx_mp4_tkhd_atom_t *) atom_header;
  1613.     tkhd64_atom = (ngx_mp4_tkhd64_atom_t *) atom_header;
  1614.     ngx_mp4_set_atom_name(tkhd_atom, 't', 'k', 'h', 'd');

  1616.     if (ngx_mp4_atom_data_size(ngx_mp4_tkhd_atom_t) > atom_data_size) {
  1617.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1618.                       "\"%s\" mp4 tkhd atom too small", mp4->file.name.data);
  1619.         return NGX_ERROR;
  1620.     }

  1622.     if (tkhd_atom->version[0] == 0) {
  1623.         /* version 0: 32-bit duration */
  1624.         duration = ngx_mp4_get_32value(tkhd_atom->duration);

  1626.     } else {
  1627.         /* version 1: 64-bit duration */

  1629.         if (ngx_mp4_atom_data_size(ngx_mp4_tkhd64_atom_t) > atom_data_size) {
  1630.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1631.                           "\"%s\" mp4 tkhd atom too small",
  1632.                           mp4->file.name.data);
  1633.             return NGX_ERROR;
  1634.         }

  1636.         duration = ngx_mp4_get_64value(tkhd64_atom->duration);
  1637.     }

  1639.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1640.                    "tkhd duration:%uL, time:%.3fs",
  1641.                    duration, (double) duration / mp4->timescale);

  1643.     start_time = (uint64_t) mp4->start * mp4->timescale / 1000;

  1645.     if (duration <= start_time) {
  1646.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1647.                        "tkhd duration is less than start time");
  1648.         return NGX_DECLINED;
  1649.     }

  1651.     duration -= start_time;

  1653.     if (mp4->length) {
  1654.         length_time = (uint64_t) mp4->length * mp4->timescale / 1000;

  1656.         if (duration > length_time) {
  1657.             duration = length_time;
  1658.         }
  1659.     }

  1661.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1662.                    "tkhd new duration:%uL, time:%.3fs",
  1663.                    duration, (double) duration / mp4->timescale);

  1665.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;

  1667.     trak = ngx_mp4_last_trak(mp4);

  1669.     if (trak->out[NGX_HTTP_MP4_TKHD_ATOM].buf) {
  1670.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1671.                       "duplicate mp4 tkhd atom in \"%s\"", mp4->file.name.data);
  1672.         return NGX_ERROR;
  1673.     }

  1675.     trak->tkhd_size = atom_size;
  1676.     trak->movie_duration = duration;

  1678.     ngx_mp4_set_32value(tkhd_atom->size, atom_size);

  1680.     if (tkhd_atom->version[0] == 0) {
  1681.         ngx_mp4_set_32value(tkhd_atom->duration, duration);

  1683.     } else {
  1684.         ngx_mp4_set_64value(tkhd64_atom->duration, duration);
  1685.     }

  1687.     atom = &trak->tkhd_atom_buf;
  1688.     atom->temporary = 1;
  1689.     atom->pos = atom_header;
  1690.     atom->last = atom_header + atom_size;

  1692.     trak->out[NGX_HTTP_MP4_TKHD_ATOM].buf = atom;

  1694.     ngx_mp4_atom_next(mp4, atom_data_size);

  1696.     return NGX_OK;
  1697. }


  1700. static ngx_int_t
  1701. ‌ngx_http_mp4_read_mdia_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1702. {
  1703.     u_char               *atom_header;
  1704.     ngx_buf_t            *atom;
  1705.     ngx_http_mp4_trak_t  *trak;

  1707.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "process mdia atom");

  1709.     atom_header = ngx_mp4_atom_header(mp4);
  1710.     ngx_mp4_set_atom_name(atom_header, 'm', 'd', 'i', 'a');

  1712.     trak = ngx_mp4_last_trak(mp4);

  1714.     if (trak->out[NGX_HTTP_MP4_MDIA_ATOM].buf) {
  1715.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1716.                       "duplicate mp4 mdia atom in \"%s\"", mp4->file.name.data);
  1717.         return NGX_ERROR;
  1718.     }

  1720.     atom = &trak->mdia_atom_buf;
  1721.     atom->temporary = 1;
  1722.     atom->pos = atom_header;
  1723.     atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);

  1725.     trak->out[NGX_HTTP_MP4_MDIA_ATOM].buf = atom;

  1727.     return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_mdia_atoms, atom_data_size);
  1728. }


  1731. static void
  1732. ‌ngx_http_mp4_update_mdia_atom(ngx_http_mp4_file_t *mp4,
  1733.     ngx_http_mp4_trak_t *trak)
  1734. {
  1735.     ngx_buf_t  *atom;

  1737.     trak->size += sizeof(ngx_mp4_atom_header_t);
  1738.     atom = &trak->mdia_atom_buf;
  1739.     ngx_mp4_set_32value(atom->pos, trak->size);
  1740. }


  1743. ‌typedef struct {
  1744.     u_char    size[4];
  1745.     u_char    name[4];
  1746.     u_char    version[1];
  1747.     u_char    flags[3];
  1748.     u_char    creation_time[4];
  1749.     u_char    modification_time[4];
  1750.     u_char    timescale[4];
  1751.     u_char    duration[4];
  1752.     u_char    language[2];
  1753.     u_char    quality[2];
  1754. ‌} ngx_mp4_mdhd_atom_t;

  1756. ‌typedef struct {
  1757.     u_char    size[4];
  1758.     u_char    name[4];
  1759.     u_char    version[1];
  1760.     u_char    flags[3];
  1761.     u_char    creation_time[8];
  1762.     u_char    modification_time[8];
  1763.     u_char    timescale[4];
  1764.     u_char    duration[8];
  1765.     u_char    language[2];
  1766.     u_char    quality[2];
  1767. ‌} ngx_mp4_mdhd64_atom_t;


  1770. static ngx_int_t
  1771. ‌ngx_http_mp4_read_mdhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1772. {
  1773.     u_char                 *atom_header;
  1774.     size_t                  atom_size;
  1775.     uint32_t                timescale;
  1776.     uint64_t                duration, start_time, length_time;
  1777.     ngx_buf_t              *atom;
  1778.     ngx_http_mp4_trak_t    *trak;
  1779.     ngx_mp4_mdhd_atom_t    *mdhd_atom;
  1780.     ngx_mp4_mdhd64_atom_t  *mdhd64_atom;

  1782.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 mdhd atom");

  1784.     atom_header = ngx_mp4_atom_header(mp4);
  1785.     mdhd_atom = (ngx_mp4_mdhd_atom_t *) atom_header;
  1786.     mdhd64_atom = (ngx_mp4_mdhd64_atom_t *) atom_header;
  1787.     ngx_mp4_set_atom_name(mdhd_atom, 'm', 'd', 'h', 'd');

  1789.     if (ngx_mp4_atom_data_size(ngx_mp4_mdhd_atom_t) > atom_data_size) {
  1790.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1791.                       "\"%s\" mp4 mdhd atom too small", mp4->file.name.data);
  1792.         return NGX_ERROR;
  1793.     }

  1795.     if (mdhd_atom->version[0] == 0) {
  1796.         /* version 0: everything is 32-bit */
  1797.         timescale = ngx_mp4_get_32value(mdhd_atom->timescale);
  1798.         duration = ngx_mp4_get_32value(mdhd_atom->duration);

  1800.     } else {
  1801.         /* version 1: 64-bit duration and 32-bit timescale */

  1803.         if (ngx_mp4_atom_data_size(ngx_mp4_mdhd64_atom_t) > atom_data_size) {
  1804.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1805.                           "\"%s\" mp4 mdhd atom too small",
  1806.                           mp4->file.name.data);
  1807.             return NGX_ERROR;
  1808.         }

  1810.         timescale = ngx_mp4_get_32value(mdhd64_atom->timescale);
  1811.         duration = ngx_mp4_get_64value(mdhd64_atom->duration);
  1812.     }

  1814.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1815.                    "mdhd timescale:%uD, duration:%uL, time:%.3fs",
  1816.                    timescale, duration, (double) duration / timescale);

  1818.     start_time = (uint64_t) mp4->start * timescale / 1000;

  1820.     if (duration <= start_time) {
  1821.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1822.                        "mdhd duration is less than start time");
  1823.         return NGX_DECLINED;
  1824.     }

  1826.     duration -= start_time;

  1828.     if (mp4->length) {
  1829.         length_time = (uint64_t) mp4->length * timescale / 1000;

  1831.         if (duration > length_time) {
  1832.             duration = length_time;
  1833.         }
  1834.     }

  1836.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1837.                    "mdhd new duration:%uL, time:%.3fs",
  1838.                    duration, (double) duration / timescale);

  1840.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;

  1842.     trak = ngx_mp4_last_trak(mp4);

  1844.     if (trak->out[NGX_HTTP_MP4_MDHD_ATOM].buf) {
  1845.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1846.                       "duplicate mp4 mdhd atom in \"%s\"", mp4->file.name.data);
  1847.         return NGX_ERROR;
  1848.     }

  1850.     trak->mdhd_size = atom_size;
  1851.     trak->timescale = timescale;
  1852.     trak->duration = duration;

  1854.     ngx_mp4_set_32value(mdhd_atom->size, atom_size);

  1856.     atom = &trak->mdhd_atom_buf;
  1857.     atom->temporary = 1;
  1858.     atom->pos = atom_header;
  1859.     atom->last = atom_header + atom_size;

  1861.     trak->out[NGX_HTTP_MP4_MDHD_ATOM].buf = atom;

  1863.     ngx_mp4_atom_next(mp4, atom_data_size);

  1865.     return NGX_OK;
  1866. }


  1869. static void
  1870. ‌ngx_http_mp4_update_mdhd_atom(ngx_http_mp4_file_t *mp4,
  1871.             ngx_http_mp4_trak_t *trak)
  1872. {
  1873.     ngx_buf_t              *atom;
  1874.     ngx_mp4_mdhd_atom_t    *mdhd_atom;
  1875.     ngx_mp4_mdhd64_atom_t  *mdhd64_atom;

  1877.     atom = trak->out[NGX_HTTP_MP4_MDHD_ATOM].buf;
  1878.     if (atom == NULL) {
  1879.         return;
  1880.     }

  1882.     mdhd_atom = (ngx_mp4_mdhd_atom_t *) atom->pos;
  1883.     mdhd64_atom = (ngx_mp4_mdhd64_atom_t *) atom->pos;

  1885.     if (mdhd_atom->version[0] == 0) {
  1886.         ngx_mp4_set_32value(mdhd_atom->duration, trak->duration);

  1888.     } else {
  1889.         ngx_mp4_set_64value(mdhd64_atom->duration, trak->duration);
  1890.     }

  1892.     trak->size += trak->mdhd_size;
  1893. }


  1896. static ngx_int_t
  1897. ‌ngx_http_mp4_read_hdlr_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1898. {
  1899.     u_char              *atom_header;
  1900.     size_t               atom_size;
  1901.     ngx_buf_t            *atom;
  1902.     ngx_http_mp4_trak_t  *trak;

  1904.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 hdlr atom");

  1906.     atom_header = ngx_mp4_atom_header(mp4);
  1907.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  1908.     ngx_mp4_set_32value(atom_header, atom_size);
  1909.     ngx_mp4_set_atom_name(atom_header, 'h', 'd', 'l', 'r');

  1911.     trak = ngx_mp4_last_trak(mp4);

  1913.     if (trak->out[NGX_HTTP_MP4_HDLR_ATOM].buf) {
  1914.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1915.                       "duplicate mp4 hdlr atom in \"%s\"", mp4->file.name.data);
  1916.         return NGX_ERROR;
  1917.     }

  1919.     atom = &trak->hdlr_atom_buf;
  1920.     atom->temporary = 1;
  1921.     atom->pos = atom_header;
  1922.     atom->last = atom_header + atom_size;

  1924.     trak->hdlr_size = atom_size;
  1925.     trak->out[NGX_HTTP_MP4_HDLR_ATOM].buf = atom;

  1927.     ngx_mp4_atom_next(mp4, atom_data_size);

  1929.     return NGX_OK;
  1930. }


  1933. static ngx_int_t
  1934. ‌ngx_http_mp4_read_minf_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1935. {
  1936.     u_char               *atom_header;
  1937.     ngx_buf_t            *atom;
  1938.     ngx_http_mp4_trak_t  *trak;

  1940.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "process minf atom");

  1942.     atom_header = ngx_mp4_atom_header(mp4);
  1943.     ngx_mp4_set_atom_name(atom_header, 'm', 'i', 'n', 'f');

  1945.     trak = ngx_mp4_last_trak(mp4);

  1947.     if (trak->out[NGX_HTTP_MP4_MINF_ATOM].buf) {
  1948.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1949.                       "duplicate mp4 minf atom in \"%s\"", mp4->file.name.data);
  1950.         return NGX_ERROR;
  1951.     }

  1953.     atom = &trak->minf_atom_buf;
  1954.     atom->temporary = 1;
  1955.     atom->pos = atom_header;
  1956.     atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);

  1958.     trak->out[NGX_HTTP_MP4_MINF_ATOM].buf = atom;

  1960.     return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_minf_atoms, atom_data_size);
  1961. }


  1964. static void
  1965. ‌ngx_http_mp4_update_minf_atom(ngx_http_mp4_file_t *mp4,
  1966.     ngx_http_mp4_trak_t *trak)
  1967. {
  1968.     ngx_buf_t  *atom;

  1970.     trak->size += sizeof(ngx_mp4_atom_header_t)
  1971.                + trak->vmhd_size
  1972.                + trak->smhd_size
  1973.                + trak->dinf_size;
  1974.     atom = &trak->minf_atom_buf;
  1975.     ngx_mp4_set_32value(atom->pos, trak->size);
  1976. }


  1979. static ngx_int_t
  1980. ‌ngx_http_mp4_read_vmhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1981. {
  1982.     u_char              *atom_header;
  1983.     size_t               atom_size;
  1984.     ngx_buf_t            *atom;
  1985.     ngx_http_mp4_trak_t  *trak;

  1987.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 vmhd atom");

  1989.     atom_header = ngx_mp4_atom_header(mp4);
  1990.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  1991.     ngx_mp4_set_32value(atom_header, atom_size);
  1992.     ngx_mp4_set_atom_name(atom_header, 'v', 'm', 'h', 'd');

  1994.     trak = ngx_mp4_last_trak(mp4);

  1996.     if (trak->out[NGX_HTTP_MP4_VMHD_ATOM].buf
  1997.         || trak->out[NGX_HTTP_MP4_SMHD_ATOM].buf)
  1998.     {
  1999.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2000.                       "duplicate mp4 vmhd/smhd atom in \"%s\"",
  2001.                       mp4->file.name.data);
  2002.         return NGX_ERROR;
  2003.     }

  2005.     atom = &trak->vmhd_atom_buf;
  2006.     atom->temporary = 1;
  2007.     atom->pos = atom_header;
  2008.     atom->last = atom_header + atom_size;

  2010.     trak->vmhd_size += atom_size;
  2011.     trak->out[NGX_HTTP_MP4_VMHD_ATOM].buf = atom;

  2013.     ngx_mp4_atom_next(mp4, atom_data_size);

  2015.     return NGX_OK;
  2016. }


  2019. static ngx_int_t
  2020. ‌ngx_http_mp4_read_smhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2021. {
  2022.     u_char              *atom_header;
  2023.     size_t               atom_size;
  2024.     ngx_buf_t            *atom;
  2025.     ngx_http_mp4_trak_t  *trak;

  2027.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 smhd atom");

  2029.     atom_header = ngx_mp4_atom_header(mp4);
  2030.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  2031.     ngx_mp4_set_32value(atom_header, atom_size);
  2032.     ngx_mp4_set_atom_name(atom_header, 's', 'm', 'h', 'd');

  2034.     trak = ngx_mp4_last_trak(mp4);

  2036.     if (trak->out[NGX_HTTP_MP4_VMHD_ATOM].buf
  2037.         || trak->out[NGX_HTTP_MP4_SMHD_ATOM].buf)
  2038.     {
  2039.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2040.                       "duplicate mp4 vmhd/smhd atom in \"%s\"",
  2041.                       mp4->file.name.data);
  2042.         return NGX_ERROR;
  2043.     }

  2045.     atom = &trak->smhd_atom_buf;
  2046.     atom->temporary = 1;
  2047.     atom->pos = atom_header;
  2048.     atom->last = atom_header + atom_size;

  2050.     trak->smhd_size += atom_size;
  2051.     trak->out[NGX_HTTP_MP4_SMHD_ATOM].buf = atom;

  2053.     ngx_mp4_atom_next(mp4, atom_data_size);

  2055.     return NGX_OK;
  2056. }


  2059. static ngx_int_t
  2060. ‌ngx_http_mp4_read_dinf_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2061. {
  2062.     u_char              *atom_header;
  2063.     size_t               atom_size;
  2064.     ngx_buf_t            *atom;
  2065.     ngx_http_mp4_trak_t  *trak;

  2067.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 dinf atom");

  2069.     atom_header = ngx_mp4_atom_header(mp4);
  2070.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  2071.     ngx_mp4_set_32value(atom_header, atom_size);
  2072.     ngx_mp4_set_atom_name(atom_header, 'd', 'i', 'n', 'f');

  2074.     trak = ngx_mp4_last_trak(mp4);

  2076.     if (trak->out[NGX_HTTP_MP4_DINF_ATOM].buf) {
  2077.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2078.                       "duplicate mp4 dinf atom in \"%s\"", mp4->file.name.data);
  2079.         return NGX_ERROR;
  2080.     }

  2082.     atom = &trak->dinf_atom_buf;
  2083.     atom->temporary = 1;
  2084.     atom->pos = atom_header;
  2085.     atom->last = atom_header + atom_size;

  2087.     trak->dinf_size += atom_size;
  2088.     trak->out[NGX_HTTP_MP4_DINF_ATOM].buf = atom;

  2090.     ngx_mp4_atom_next(mp4, atom_data_size);

  2092.     return NGX_OK;
  2093. }


  2096. static ngx_int_t
  2097. ‌ngx_http_mp4_read_stbl_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2098. {
  2099.     u_char               *atom_header;
  2100.     ngx_buf_t            *atom;
  2101.     ngx_http_mp4_trak_t  *trak;

  2103.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "process stbl atom");

  2105.     atom_header = ngx_mp4_atom_header(mp4);
  2106.     ngx_mp4_set_atom_name(atom_header, 's', 't', 'b', 'l');

  2108.     trak = ngx_mp4_last_trak(mp4);

  2110.     if (trak->out[NGX_HTTP_MP4_STBL_ATOM].buf) {
  2111.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2112.                       "duplicate mp4 stbl atom in \"%s\"", mp4->file.name.data);
  2113.         return NGX_ERROR;
  2114.     }

  2116.     atom = &trak->stbl_atom_buf;
  2117.     atom->temporary = 1;
  2118.     atom->pos = atom_header;
  2119.     atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);

  2121.     trak->out[NGX_HTTP_MP4_STBL_ATOM].buf = atom;

  2123.     return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_stbl_atoms, atom_data_size);
  2124. }


  2127. static void
  2128. ‌ngx_http_mp4_update_edts_atom(ngx_http_mp4_file_t *mp4,
  2129.     ngx_http_mp4_trak_t *trak)
  2130. {
  2131.     ngx_buf_t            *atom;
  2132.     ngx_mp4_elst_atom_t  *elst_atom;
  2133.     ngx_mp4_edts_atom_t  *edts_atom;

  2135.     if (trak->prefix == 0) {
  2136.         return;
  2137.     }

  2139.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2140.                    "mp4 edts atom update prefix:%uL", trak->prefix);

  2142.     edts_atom = &trak->edts_atom;
  2143.     ngx_mp4_set_32value(edts_atom->size, sizeof(ngx_mp4_edts_atom_t)
  2144.                                          + sizeof(ngx_mp4_elst_atom_t));
  2145.     ngx_mp4_set_atom_name(edts_atom, 'e', 'd', 't', 's');

  2147.     atom = &trak->edts_atom_buf;
  2148.     atom->temporary = 1;
  2149.     atom->pos = (u_char *) edts_atom;
  2150.     atom->last = (u_char *) edts_atom + sizeof(ngx_mp4_edts_atom_t);

  2152.     trak->out[NGX_HTTP_MP4_EDTS_ATOM].buf = atom;

  2154.     elst_atom = &trak->elst_atom;
  2155.     ngx_mp4_set_32value(elst_atom->size, sizeof(ngx_mp4_elst_atom_t));
  2156.     ngx_mp4_set_atom_name(elst_atom, 'e', 'l', 's', 't');

  2158.     elst_atom->version[0] = 1;
  2159.     elst_atom->flags[0] = 0;
  2160.     elst_atom->flags[1] = 0;
  2161.     elst_atom->flags[2] = 0;

  2163.     ngx_mp4_set_32value(elst_atom->entries, 1);
  2164.     ngx_mp4_set_64value(elst_atom->duration, trak->movie_duration);
  2165.     ngx_mp4_set_64value(elst_atom->media_time, trak->prefix);
  2166.     ngx_mp4_set_16value(elst_atom->media_rate, 1);
  2167.     ngx_mp4_set_16value(elst_atom->reserved, 0);

  2169.     atom = &trak->elst_atom_buf;
  2170.     atom->temporary = 1;
  2171.     atom->pos = (u_char *) elst_atom;
  2172.     atom->last = (u_char *) elst_atom + sizeof(ngx_mp4_elst_atom_t);

  2174.     trak->out[NGX_HTTP_MP4_ELST_ATOM].buf = atom;

  2176.     trak->size += sizeof(ngx_mp4_edts_atom_t) + sizeof(ngx_mp4_elst_atom_t);
  2177. }


  2180. static void
  2181. ‌ngx_http_mp4_update_stbl_atom(ngx_http_mp4_file_t *mp4,
  2182.     ngx_http_mp4_trak_t *trak)
  2183. {
  2184.     ngx_buf_t  *atom;

  2186.     trak->size += sizeof(ngx_mp4_atom_header_t);
  2187.     atom = &trak->stbl_atom_buf;
  2188.     ngx_mp4_set_32value(atom->pos, trak->size);
  2189. }


  2192. ‌typedef struct {
  2193.     u_char    size[4];
  2194.     u_char    name[4];
  2195.     u_char    version[1];
  2196.     u_char    flags[3];
  2197.     u_char    entries[4];

  2199.     u_char    media_size[4];
  2200.     u_char    media_name[4];
  2201. ‌} ngx_mp4_stsd_atom_t;


  2204. static ngx_int_t
  2205. ‌ngx_http_mp4_read_stsd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2206. {
  2207.     u_char               *atom_header, *atom_table;
  2208.     size_t                atom_size;
  2209.     ngx_buf_t            *atom;
  2210.     ngx_mp4_stsd_atom_t  *stsd_atom;
  2211.     ngx_http_mp4_trak_t  *trak;

  2213.     /* sample description atom */

  2215.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stsd atom");

  2217.     atom_header = ngx_mp4_atom_header(mp4);
  2218.     stsd_atom = (ngx_mp4_stsd_atom_t *) atom_header;
  2219.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  2220.     atom_table = atom_header + atom_size;
  2221.     ngx_mp4_set_32value(stsd_atom->size, atom_size);
  2222.     ngx_mp4_set_atom_name(stsd_atom, 's', 't', 's', 'd');

  2224.     if (ngx_mp4_atom_data_size(ngx_mp4_stsd_atom_t) > atom_data_size) {
  2225.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2226.                       "\"%s\" mp4 stsd atom too small", mp4->file.name.data);
  2227.         return NGX_ERROR;
  2228.     }

  2230.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2231.                    "stsd entries:%uD, media:%*s",
  2232.                    ngx_mp4_get_32value(stsd_atom->entries),
  2233.                    (size_t) 4, stsd_atom->media_name);

  2235.     trak = ngx_mp4_last_trak(mp4);

  2237.     if (trak->out[NGX_HTTP_MP4_STSD_ATOM].buf) {
  2238.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2239.                       "duplicate mp4 stsd atom in \"%s\"", mp4->file.name.data);
  2240.         return NGX_ERROR;
  2241.     }

  2243.     atom = &trak->stsd_atom_buf;
  2244.     atom->temporary = 1;
  2245.     atom->pos = atom_header;
  2246.     atom->last = atom_table;

  2248.     trak->out[NGX_HTTP_MP4_STSD_ATOM].buf = atom;
  2249.     trak->size += atom_size;

  2251.     ngx_mp4_atom_next(mp4, atom_data_size);

  2253.     return NGX_OK;
  2254. }


  2257. ‌typedef struct {
  2258.     u_char    size[4];
  2259.     u_char    name[4];
  2260.     u_char    version[1];
  2261.     u_char    flags[3];
  2262.     u_char    entries[4];
  2263. ‌} ngx_mp4_stts_atom_t;

  2265. ‌typedef struct {
  2266.     u_char    count[4];
  2267.     u_char    duration[4];
  2268. ‌} ngx_mp4_stts_entry_t;


  2271. static ngx_int_t
  2272. ‌ngx_http_mp4_read_stts_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2273. {
  2274.     u_char               *atom_header, *atom_table, *atom_end;
  2275.     uint32_t              entries;
  2276.     ngx_buf_t            *atom, *data;
  2277.     ngx_mp4_stts_atom_t  *stts_atom;
  2278.     ngx_http_mp4_trak_t  *trak;

  2280.     /* time-to-sample atom */

  2282.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stts atom");

  2284.     atom_header = ngx_mp4_atom_header(mp4);
  2285.     stts_atom = (ngx_mp4_stts_atom_t *) atom_header;
  2286.     ngx_mp4_set_atom_name(stts_atom, 's', 't', 't', 's');

  2288.     if (ngx_mp4_atom_data_size(ngx_mp4_stts_atom_t) > atom_data_size) {
  2289.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2290.                       "\"%s\" mp4 stts atom too small", mp4->file.name.data);
  2291.         return NGX_ERROR;
  2292.     }

  2294.     entries = ngx_mp4_get_32value(stts_atom->entries);

  2296.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2297.                    "mp4 time-to-sample entries:%uD", entries);

  2299.     if (ngx_mp4_atom_data_size(ngx_mp4_stts_atom_t)
  2300.         + (uint64_t) entries * sizeof(ngx_mp4_stts_entry_t) > atom_data_size)
  2301.     {
  2302.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2303.                       "\"%s\" mp4 stts atom too small", mp4->file.name.data);
  2304.         return NGX_ERROR;
  2305.     }

  2307.     atom_table = atom_header + sizeof(ngx_mp4_stts_atom_t);
  2308.     atom_end = atom_table + entries * sizeof(ngx_mp4_stts_entry_t);

  2310.     trak = ngx_mp4_last_trak(mp4);

  2312.     if (trak->out[NGX_HTTP_MP4_STTS_ATOM].buf) {
  2313.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2314.                       "duplicate mp4 stts atom in \"%s\"", mp4->file.name.data);
  2315.         return NGX_ERROR;
  2316.     }

  2318.     trak->time_to_sample_entries = entries;

  2320.     atom = &trak->stts_atom_buf;
  2321.     atom->temporary = 1;
  2322.     atom->pos = atom_header;
  2323.     atom->last = atom_table;

  2325.     data = &trak->stts_data_buf;
  2326.     data->temporary = 1;
  2327.     data->pos = atom_table;
  2328.     data->last = atom_end;

  2330.     trak->out[NGX_HTTP_MP4_STTS_ATOM].buf = atom;
  2331.     trak->out[NGX_HTTP_MP4_STTS_DATA].buf = data;

  2333.     ngx_mp4_atom_next(mp4, atom_data_size);

  2335.     return NGX_OK;
  2336. }


  2339. static ngx_int_t
  2340. ‌ngx_http_mp4_update_stts_atom(ngx_http_mp4_file_t *mp4,
  2341.     ngx_http_mp4_trak_t *trak)
  2342. {
  2343.     size_t                atom_size;
  2344.     ngx_buf_t            *atom, *data;
  2345.     ngx_mp4_stts_atom_t  *stts_atom;

  2347.     /*
  2348.      * mdia.minf.stbl.stts updating requires trak->timescale
  2349.      * from mdia.mdhd atom which may reside after mdia.minf
  2350.      */

  2352.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2353.                    "mp4 stts atom update");

  2355.     data = trak->out[NGX_HTTP_MP4_STTS_DATA].buf;

  2357.     if (data == NULL) {
  2358.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2359.                       "no mp4 stts atoms were found in \"%s\"",
  2360.                       mp4->file.name.data);
  2361.         return NGX_ERROR;
  2362.     }

  2364.     if (ngx_http_mp4_crop_stts_data(mp4, trak, 1) != NGX_OK) {
  2365.         return NGX_ERROR;
  2366.     }

  2368.     if (ngx_http_mp4_crop_stts_data(mp4, trak, 0) != NGX_OK) {
  2369.         return NGX_ERROR;
  2370.     }

  2372.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2373.                    "time-to-sample entries:%uD", trak->time_to_sample_entries);

  2375.     atom_size = sizeof(ngx_mp4_stts_atom_t) + (data->last - data->pos);
  2376.     trak->size += atom_size;

  2378.     atom = trak->out[NGX_HTTP_MP4_STTS_ATOM].buf;
  2379.     stts_atom = (ngx_mp4_stts_atom_t *) atom->pos;
  2380.     ngx_mp4_set_32value(stts_atom->size, atom_size);
  2381.     ngx_mp4_set_32value(stts_atom->entries, trak->time_to_sample_entries);

  2383.     return NGX_OK;
  2384. }


  2387. static ngx_int_t
  2388. ‌ngx_http_mp4_crop_stts_data(ngx_http_mp4_file_t *mp4,
  2389.     ngx_http_mp4_trak_t *trak, ngx_uint_t start)
  2390. {
  2391.     uint32_t               count, duration, rest, key_prefix;
  2392.     uint64_t               start_time;
  2393.     ngx_buf_t             *data;
  2394.     ngx_uint_t             start_sample, entries, start_sec;
  2395.     ngx_mp4_stts_entry_t  *entry, *end;

  2397.     if (start) {
  2398.         start_sec = mp4->start;

  2400.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2401.                        "mp4 stts crop start_time:%ui", start_sec);

  2403.     } else if (mp4->length) {
  2404.         start_sec = mp4->length;

  2406.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2407.                        "mp4 stts crop end_time:%ui", start_sec);

  2409.     } else {
  2410.         return NGX_OK;
  2411.     }

  2413.     data = trak->out[NGX_HTTP_MP4_STTS_DATA].buf;

  2415.     start_time = (uint64_t) start_sec * trak->timescale / 1000 + trak->prefix;

  2417.     entries = trak->time_to_sample_entries;
  2418.     start_sample = 0;
  2419.     entry = (ngx_mp4_stts_entry_t *) data->pos;
  2420.     end = (ngx_mp4_stts_entry_t *) data->last;

  2422.     while (entry < end) {
  2423.         count = ngx_mp4_get_32value(entry->count);
  2424.         duration = ngx_mp4_get_32value(entry->duration);

  2426.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2427.                        "time:%uL, count:%uD, duration:%uD",
  2428.                        start_time, count, duration);

  2430.         if (start_time < (uint64_t) count * duration) {
  2431.             start_sample += (ngx_uint_t) (start_time / duration);
  2432.             rest = (uint32_t) (start_time / duration);
  2433.             goto found;
  2434.         }

  2436.         start_sample += count;
  2437.         start_time -= (uint64_t) count * duration;
  2438.         entries--;
  2439.         entry++;
  2440.     }

  2442.     if (start) {
  2443.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2444.                       "start time is out mp4 stts samples in \"%s\"",
  2445.                       mp4->file.name.data);

  2447.         return NGX_ERROR;

  2449.     } else {
  2450.         trak->end_sample = trak->start_sample + start_sample;

  2452.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2453.                        "end_sample:%ui", trak->end_sample);

  2455.         return NGX_OK;
  2456.     }

  2458. found:

  2460.     if (start) {
  2461.         if (ngx_http_mp4_seek_key_frame(mp4, trak, start_sample, &key_prefix)
  2462.             != NGX_OK)
  2463.         {
  2464.             return NGX_ERROR;
  2465.         }

  2467.         start_sample -= key_prefix;

  2469.         while (rest < key_prefix) {
  2470.             trak->prefix += rest * duration;
  2471.             key_prefix -= rest;

  2473.             entry--;
  2474.             entries++;

  2476.             count = ngx_mp4_get_32value(entry->count);
  2477.             duration = ngx_mp4_get_32value(entry->duration);
  2478.             rest = count;
  2479.         }

  2481.         trak->prefix += key_prefix * duration;
  2482.         trak->duration += trak->prefix;
  2483.         rest -= key_prefix;

  2485.         ngx_mp4_set_32value(entry->count, count - rest);
  2486.         data->pos = (u_char *) entry;
  2487.         trak->time_to_sample_entries = entries;
  2488.         trak->start_sample = start_sample;

  2490.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2491.                        "start_sample:%ui, new count:%uD",
  2492.                        trak->start_sample, count - rest);

  2494.     } else {
  2495.         ngx_mp4_set_32value(entry->count, rest);
  2496.         data->last = (u_char *) (entry + 1);
  2497.         trak->time_to_sample_entries -= entries - 1;
  2498.         trak->end_sample = trak->start_sample + start_sample;

  2500.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2501.                        "end_sample:%ui, new count:%uD",
  2502.                        trak->end_sample, rest);
  2503.     }

  2505.     return NGX_OK;
  2506. }


  2509. static ngx_int_t
  2510. ‌ngx_http_mp4_seek_key_frame(ngx_http_mp4_file_t *mp4, ngx_http_mp4_trak_t *trak,
  2511.     uint32_t start_sample, uint32_t *key_prefix)
  2512. {
  2513.     uint32_t              sample, *entry, *end;
  2514.     ngx_buf_t            *data;
  2515.     ngx_http_mp4_conf_t  *conf;

  2517.     *key_prefix = 0;

  2519.     conf = ngx_http_get_module_loc_conf(mp4->request, ngx_http_mp4_module);
  2520.     if (!conf->start_key_frame) {
  2521.         return NGX_OK;
  2522.     }

  2524.     data = trak->out[NGX_HTTP_MP4_STSS_DATA].buf;
  2525.     if (data == NULL) {
  2526.         return NGX_OK;
  2527.     }

  2529.     entry = (uint32_t *) data->pos;
  2530.     end = (uint32_t *) data->last;

  2532.     /* sync samples starts from 1 */
  2533.     start_sample++;

  2535.     while (entry < end) {
  2536.         sample = ngx_mp4_get_32value(entry);

  2538.         if (sample == 0) {
  2539.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2540.                           "zero sync sample in \"%s\"",
  2541.                           mp4->file.name.data);
  2542.             return NGX_ERROR;
  2543.         }

  2545.         if (sample > start_sample) {
  2546.             break;
  2547.         }

  2549.         *key_prefix = start_sample - sample;
  2550.         entry++;
  2551.     }

  2553.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2554.                    "mp4 key frame prefix:%uD", *key_prefix);

  2556.     return NGX_OK;
  2557. }


  2560. ‌typedef struct {
  2561.     u_char    size[4];
  2562.     u_char    name[4];
  2563.     u_char    version[1];
  2564.     u_char    flags[3];
  2565.     u_char    entries[4];
  2566. ‌} ngx_http_mp4_stss_atom_t;


  2569. static ngx_int_t
  2570. ‌ngx_http_mp4_read_stss_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2571. {
  2572.     u_char                    *atom_header, *atom_table, *atom_end;
  2573.     uint32_t                   entries;
  2574.     ngx_buf_t                 *atom, *data;
  2575.     ngx_http_mp4_trak_t       *trak;
  2576.     ngx_http_mp4_stss_atom_t  *stss_atom;

  2578.     /* sync samples atom */

  2580.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stss atom");

  2582.     atom_header = ngx_mp4_atom_header(mp4);
  2583.     stss_atom = (ngx_http_mp4_stss_atom_t *) atom_header;
  2584.     ngx_mp4_set_atom_name(stss_atom, 's', 't', 's', 's');

  2586.     if (ngx_mp4_atom_data_size(ngx_http_mp4_stss_atom_t) > atom_data_size) {
  2587.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2588.                       "\"%s\" mp4 stss atom too small", mp4->file.name.data);
  2589.         return NGX_ERROR;
  2590.     }

  2592.     entries = ngx_mp4_get_32value(stss_atom->entries);

  2594.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2595.                    "sync sample entries:%uD", entries);

  2597.     trak = ngx_mp4_last_trak(mp4);

  2599.     if (trak->out[NGX_HTTP_MP4_STSS_ATOM].buf) {
  2600.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2601.                       "duplicate mp4 stss atom in \"%s\"", mp4->file.name.data);
  2602.         return NGX_ERROR;
  2603.     }

  2605.     trak->sync_samples_entries = entries;

  2607.     atom_table = atom_header + sizeof(ngx_http_mp4_stss_atom_t);

  2609.     atom = &trak->stss_atom_buf;
  2610.     atom->temporary = 1;
  2611.     atom->pos = atom_header;
  2612.     atom->last = atom_table;

  2614.     if (ngx_mp4_atom_data_size(ngx_http_mp4_stss_atom_t)
  2615.         + (uint64_t) entries * sizeof(uint32_t) > atom_data_size)
  2616.     {
  2617.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2618.                       "\"%s\" mp4 stss atom too small", mp4->file.name.data);
  2619.         return NGX_ERROR;
  2620.     }

  2622.     atom_end = atom_table + entries * sizeof(uint32_t);

  2624.     data = &trak->stss_data_buf;
  2625.     data->temporary = 1;
  2626.     data->pos = atom_table;
  2627.     data->last = atom_end;

  2629.     trak->out[NGX_HTTP_MP4_STSS_ATOM].buf = atom;
  2630.     trak->out[NGX_HTTP_MP4_STSS_DATA].buf = data;

  2632.     ngx_mp4_atom_next(mp4, atom_data_size);

  2634.     return NGX_OK;
  2635. }


  2638. static ngx_int_t
  2639. ‌ngx_http_mp4_update_stss_atom(ngx_http_mp4_file_t *mp4,
  2640.     ngx_http_mp4_trak_t *trak)
  2641. {
  2642.     size_t                     atom_size;
  2643.     uint32_t                   sample, start_sample, *entry, *end;
  2644.     ngx_buf_t                 *atom, *data;
  2645.     ngx_http_mp4_stss_atom_t  *stss_atom;

  2647.     /*
  2648.      * mdia.minf.stbl.stss updating requires trak->start_sample
  2649.      * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
  2650.      * atom which may reside after mdia.minf
  2651.      */

  2653.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2654.                    "mp4 stss atom update");

  2656.     data = trak->out[NGX_HTTP_MP4_STSS_DATA].buf;

  2658.     if (data == NULL) {
  2659.         return NGX_OK;
  2660.     }

  2662.     ngx_http_mp4_crop_stss_data(mp4, trak, 1);
  2663.     ngx_http_mp4_crop_stss_data(mp4, trak, 0);

  2665.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2666.                    "sync sample entries:%uD", trak->sync_samples_entries);

  2668.     if (trak->sync_samples_entries) {
  2669.         entry = (uint32_t *) data->pos;
  2670.         end = (uint32_t *) data->last;

  2672.         start_sample = trak->start_sample;

  2674.         while (entry < end) {
  2675.             sample = ngx_mp4_get_32value(entry);
  2676.             sample -= start_sample;
  2677.             ngx_mp4_set_32value(entry, sample);
  2678.             entry++;
  2679.         }

  2681.     } else {
  2682.         trak->out[NGX_HTTP_MP4_STSS_DATA].buf = NULL;
  2683.     }

  2685.     atom_size = sizeof(ngx_http_mp4_stss_atom_t) + (data->last - data->pos);
  2686.     trak->size += atom_size;

  2688.     atom = trak->out[NGX_HTTP_MP4_STSS_ATOM].buf;
  2689.     stss_atom = (ngx_http_mp4_stss_atom_t *) atom->pos;

  2691.     ngx_mp4_set_32value(stss_atom->size, atom_size);
  2692.     ngx_mp4_set_32value(stss_atom->entries, trak->sync_samples_entries);

  2694.     return NGX_OK;
  2695. }


  2698. static void
  2699. ‌ngx_http_mp4_crop_stss_data(ngx_http_mp4_file_t *mp4,
  2700.     ngx_http_mp4_trak_t *trak, ngx_uint_t start)
  2701. {
  2702.     uint32_t     sample, start_sample, *entry, *end;
  2703.     ngx_buf_t   *data;
  2704.     ngx_uint_t   entries;

  2706.     /* sync samples starts from 1 */

  2708.     if (start) {
  2709.         start_sample = trak->start_sample + 1;

  2711.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2712.                        "mp4 stss crop start_sample:%uD", start_sample);

  2714.     } else if (mp4->length) {
  2715.         start_sample = trak->end_sample + 1;

  2717.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2718.                        "mp4 stss crop end_sample:%uD", start_sample);

  2720.     } else {
  2721.         return;
  2722.     }

  2724.     data = trak->out[NGX_HTTP_MP4_STSS_DATA].buf;

  2726.     entries = trak->sync_samples_entries;
  2727.     entry = (uint32_t *) data->pos;
  2728.     end = (uint32_t *) data->last;

  2730.     while (entry < end) {
  2731.         sample = ngx_mp4_get_32value(entry);

  2733.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2734.                        "sync:%uD", sample);

  2736.         if (sample >= start_sample) {
  2737.             goto found;
  2738.         }

  2740.         entries--;
  2741.         entry++;
  2742.     }

  2744.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2745.                    "sample is out of mp4 stss atom");

  2747. found:

  2749.     if (start) {
  2750.         data->pos = (u_char *) entry;
  2751.         trak->sync_samples_entries = entries;

  2753.     } else {
  2754.         data->last = (u_char *) entry;
  2755.         trak->sync_samples_entries -= entries;
  2756.     }
  2757. }


  2760. ‌typedef struct {
  2761.     u_char    size[4];
  2762.     u_char    name[4];
  2763.     u_char    version[1];
  2764.     u_char    flags[3];
  2765.     u_char    entries[4];
  2766. ‌} ngx_mp4_ctts_atom_t;

  2768. ‌typedef struct {
  2769.     u_char    count[4];
  2770.     u_char    offset[4];
  2771. ‌} ngx_mp4_ctts_entry_t;


  2774. static ngx_int_t
  2775. ‌ngx_http_mp4_read_ctts_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2776. {
  2777.     u_char               *atom_header, *atom_table, *atom_end;
  2778.     uint32_t              entries;
  2779.     ngx_buf_t            *atom, *data;
  2780.     ngx_mp4_ctts_atom_t  *ctts_atom;
  2781.     ngx_http_mp4_trak_t  *trak;

  2783.     /* composition offsets atom */

  2785.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 ctts atom");

  2787.     atom_header = ngx_mp4_atom_header(mp4);
  2788.     ctts_atom = (ngx_mp4_ctts_atom_t *) atom_header;
  2789.     ngx_mp4_set_atom_name(ctts_atom, 'c', 't', 't', 's');

  2791.     if (ngx_mp4_atom_data_size(ngx_mp4_ctts_atom_t) > atom_data_size) {
  2792.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2793.                       "\"%s\" mp4 ctts atom too small", mp4->file.name.data);
  2794.         return NGX_ERROR;
  2795.     }

  2797.     entries = ngx_mp4_get_32value(ctts_atom->entries);

  2799.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2800.                    "composition offset entries:%uD", entries);

  2802.     trak = ngx_mp4_last_trak(mp4);

  2804.     if (trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf) {
  2805.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2806.                       "duplicate mp4 ctts atom in \"%s\"", mp4->file.name.data);
  2807.         return NGX_ERROR;
  2808.     }

  2810.     trak->composition_offset_entries = entries;

  2812.     atom_table = atom_header + sizeof(ngx_mp4_ctts_atom_t);

  2814.     atom = &trak->ctts_atom_buf;
  2815.     atom->temporary = 1;
  2816.     atom->pos = atom_header;
  2817.     atom->last = atom_table;

  2819.     if (ngx_mp4_atom_data_size(ngx_mp4_ctts_atom_t)
  2820.         + (uint64_t) entries * sizeof(ngx_mp4_ctts_entry_t) > atom_data_size)
  2821.     {
  2822.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2823.                       "\"%s\" mp4 ctts atom too small", mp4->file.name.data);
  2824.         return NGX_ERROR;
  2825.     }

  2827.     atom_end = atom_table + entries * sizeof(ngx_mp4_ctts_entry_t);

  2829.     data = &trak->ctts_data_buf;
  2830.     data->temporary = 1;
  2831.     data->pos = atom_table;
  2832.     data->last = atom_end;

  2834.     trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf = atom;
  2835.     trak->out[NGX_HTTP_MP4_CTTS_DATA].buf = data;

  2837.     ngx_mp4_atom_next(mp4, atom_data_size);

  2839.     return NGX_OK;
  2840. }


  2843. static void
  2844. ‌ngx_http_mp4_update_ctts_atom(ngx_http_mp4_file_t *mp4,
  2845.     ngx_http_mp4_trak_t *trak)
  2846. {
  2847.     size_t                atom_size;
  2848.     ngx_buf_t            *atom, *data;
  2849.     ngx_mp4_ctts_atom_t  *ctts_atom;

  2851.     /*
  2852.      * mdia.minf.stbl.ctts updating requires trak->start_sample
  2853.      * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
  2854.      * atom which may reside after mdia.minf
  2855.      */

  2857.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2858.                    "mp4 ctts atom update");

  2860.     data = trak->out[NGX_HTTP_MP4_CTTS_DATA].buf;

  2862.     if (data == NULL) {
  2863.         return;
  2864.     }

  2866.     ngx_http_mp4_crop_ctts_data(mp4, trak, 1);
  2867.     ngx_http_mp4_crop_ctts_data(mp4, trak, 0);

  2869.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2870.                    "composition offset entries:%uD",
  2871.                    trak->composition_offset_entries);

  2873.     if (trak->composition_offset_entries == 0) {
  2874.         trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf = NULL;
  2875.         trak->out[NGX_HTTP_MP4_CTTS_DATA].buf = NULL;
  2876.         return;
  2877.     }

  2879.     atom_size = sizeof(ngx_mp4_ctts_atom_t) + (data->last - data->pos);
  2880.     trak->size += atom_size;

  2882.     atom = trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf;
  2883.     ctts_atom = (ngx_mp4_ctts_atom_t *) atom->pos;

  2885.     ngx_mp4_set_32value(ctts_atom->size, atom_size);
  2886.     ngx_mp4_set_32value(ctts_atom->entries, trak->composition_offset_entries);

  2888.     return;
  2889. }


  2892. static void
  2893. ‌ngx_http_mp4_crop_ctts_data(ngx_http_mp4_file_t *mp4,
  2894.     ngx_http_mp4_trak_t *trak, ngx_uint_t start)
  2895. {
  2896.     uint32_t               count, start_sample, rest;
  2897.     ngx_buf_t             *data;
  2898.     ngx_uint_t             entries;
  2899.     ngx_mp4_ctts_entry_t  *entry, *end;

  2901.     /* sync samples starts from 1 */

  2903.     if (start) {
  2904.         start_sample = trak->start_sample + 1;

  2906.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2907.                        "mp4 ctts crop start_sample:%uD", start_sample);

  2909.     } else if (mp4->length) {
  2910.         start_sample = trak->end_sample - trak->start_sample + 1;

  2912.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2913.                        "mp4 ctts crop end_sample:%uD", start_sample);

  2915.     } else {
  2916.         return;
  2917.     }

  2919.     data = trak->out[NGX_HTTP_MP4_CTTS_DATA].buf;

  2921.     entries = trak->composition_offset_entries;
  2922.     entry = (ngx_mp4_ctts_entry_t *) data->pos;
  2923.     end = (ngx_mp4_ctts_entry_t *) data->last;

  2925.     while (entry < end) {
  2926.         count = ngx_mp4_get_32value(entry->count);

  2928.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2929.                        "sample:%uD, count:%uD, offset:%uD",
  2930.                        start_sample, count, ngx_mp4_get_32value(entry->offset));

  2932.         if (start_sample <= count) {
  2933.             rest = start_sample - 1;
  2934.             goto found;
  2935.         }

  2937.         start_sample -= count;
  2938.         entries--;
  2939.         entry++;
  2940.     }

  2942.     if (start) {
  2943.         data->pos = (u_char *) end;
  2944.         trak->composition_offset_entries = 0;
  2945.     }

  2947.     return;

  2949. found:

  2951.     if (start) {
  2952.         ngx_mp4_set_32value(entry->count, count - rest);
  2953.         data->pos = (u_char *) entry;
  2954.         trak->composition_offset_entries = entries;

  2956.     } else {
  2957.         ngx_mp4_set_32value(entry->count, rest);
  2958.         data->last = (u_char *) (entry + 1);
  2959.         trak->composition_offset_entries -= entries - 1;
  2960.     }
  2961. }


  2964. ‌typedef struct {
  2965.     u_char    size[4];
  2966.     u_char    name[4];
  2967.     u_char    version[1];
  2968.     u_char    flags[3];
  2969.     u_char    entries[4];
  2970. ‌} ngx_mp4_stsc_atom_t;


  2973. static ngx_int_t
  2974. ‌ngx_http_mp4_read_stsc_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2975. {
  2976.     u_char               *atom_header, *atom_table, *atom_end;
  2977.     uint32_t              entries;
  2978.     ngx_buf_t            *atom, *data;
  2979.     ngx_mp4_stsc_atom_t  *stsc_atom;
  2980.     ngx_http_mp4_trak_t  *trak;

  2982.     /* sample-to-chunk atom */

  2984.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stsc atom");

  2986.     atom_header = ngx_mp4_atom_header(mp4);
  2987.     stsc_atom = (ngx_mp4_stsc_atom_t *) atom_header;
  2988.     ngx_mp4_set_atom_name(stsc_atom, 's', 't', 's', 'c');

  2990.     if (ngx_mp4_atom_data_size(ngx_mp4_stsc_atom_t) > atom_data_size) {
  2991.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2992.                       "\"%s\" mp4 stsc atom too small", mp4->file.name.data);
  2993.         return NGX_ERROR;
  2994.     }

  2996.     entries = ngx_mp4_get_32value(stsc_atom->entries);

  2998.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2999.                    "sample-to-chunk entries:%uD", entries);

  3001.     if (ngx_mp4_atom_data_size(ngx_mp4_stsc_atom_t)
  3002.         + (uint64_t) entries * sizeof(ngx_mp4_stsc_entry_t) > atom_data_size)
  3003.     {
  3004.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3005.                       "\"%s\" mp4 stsc atom too small", mp4->file.name.data);
  3006.         return NGX_ERROR;
  3007.     }

  3009.     atom_table = atom_header + sizeof(ngx_mp4_stsc_atom_t);
  3010.     atom_end = atom_table + entries * sizeof(ngx_mp4_stsc_entry_t);

  3012.     trak = ngx_mp4_last_trak(mp4);

  3014.     if (trak->out[NGX_HTTP_MP4_STSC_ATOM].buf) {
  3015.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3016.                       "duplicate mp4 stsc atom in \"%s\"", mp4->file.name.data);
  3017.         return NGX_ERROR;
  3018.     }

  3020.     trak->sample_to_chunk_entries = entries;

  3022.     atom = &trak->stsc_atom_buf;
  3023.     atom->temporary = 1;
  3024.     atom->pos = atom_header;
  3025.     atom->last = atom_table;

  3027.     data = &trak->stsc_data_buf;
  3028.     data->temporary = 1;
  3029.     data->pos = atom_table;
  3030.     data->last = atom_end;

  3032.     trak->out[NGX_HTTP_MP4_STSC_ATOM].buf = atom;
  3033.     trak->out[NGX_HTTP_MP4_STSC_DATA].buf = data;

  3035.     ngx_mp4_atom_next(mp4, atom_data_size);

  3037.     return NGX_OK;
  3038. }


  3041. static ngx_int_t
  3042. ‌ngx_http_mp4_update_stsc_atom(ngx_http_mp4_file_t *mp4,
  3043.     ngx_http_mp4_trak_t *trak)
  3044. {
  3045.     size_t                 atom_size;
  3046.     uint32_t               chunk;
  3047.     ngx_buf_t             *atom, *data;
  3048.     ngx_mp4_stsc_atom_t   *stsc_atom;
  3049.     ngx_mp4_stsc_entry_t  *entry, *end;

  3051.     /*
  3052.      * mdia.minf.stbl.stsc updating requires trak->start_sample
  3053.      * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
  3054.      * atom which may reside after mdia.minf
  3055.      */

  3057.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3058.                    "mp4 stsc atom update");

  3060.     data = trak->out[NGX_HTTP_MP4_STSC_DATA].buf;

  3062.     if (data == NULL) {
  3063.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3064.                       "no mp4 stsc atoms were found in \"%s\"",
  3065.                       mp4->file.name.data);
  3066.         return NGX_ERROR;
  3067.     }

  3069.     if (trak->sample_to_chunk_entries == 0) {
  3070.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3071.                       "zero number of entries in stsc atom in \"%s\"",
  3072.                       mp4->file.name.data);
  3073.         return NGX_ERROR;
  3074.     }

  3076.     if (ngx_http_mp4_crop_stsc_data(mp4, trak, 1) != NGX_OK) {
  3077.         return NGX_ERROR;
  3078.     }

  3080.     if (ngx_http_mp4_crop_stsc_data(mp4, trak, 0) != NGX_OK) {
  3081.         return NGX_ERROR;
  3082.     }

  3084.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3085.                    "sample-to-chunk entries:%uD",
  3086.                    trak->sample_to_chunk_entries);

  3088.     entry = (ngx_mp4_stsc_entry_t *) data->pos;
  3089.     end = (ngx_mp4_stsc_entry_t *) data->last;

  3091.     while (entry < end) {
  3092.         chunk = ngx_mp4_get_32value(entry->chunk);
  3093.         chunk -= trak->start_chunk;
  3094.         ngx_mp4_set_32value(entry->chunk, chunk);
  3095.         entry++;
  3096.     }

  3098.     atom_size = sizeof(ngx_mp4_stsc_atom_t)
  3099.                 + trak->sample_to_chunk_entries * sizeof(ngx_mp4_stsc_entry_t);

  3101.     trak->size += atom_size;

  3103.     atom = trak->out[NGX_HTTP_MP4_STSC_ATOM].buf;
  3104.     stsc_atom = (ngx_mp4_stsc_atom_t *) atom->pos;

  3106.     ngx_mp4_set_32value(stsc_atom->size, atom_size);
  3107.     ngx_mp4_set_32value(stsc_atom->entries, trak->sample_to_chunk_entries);

  3109.     return NGX_OK;
  3110. }


  3113. static ngx_int_t
  3114. ‌ngx_http_mp4_crop_stsc_data(ngx_http_mp4_file_t *mp4,
  3115.     ngx_http_mp4_trak_t *trak, ngx_uint_t start)
  3116. {
  3117.     uint64_t               n;
  3118.     uint32_t               start_sample, chunk, samples, id, next_chunk,
  3119.                            prev_samples;
  3120.     ngx_buf_t             *data, *buf;
  3121.     ngx_uint_t             entries, target_chunk, chunk_samples;
  3122.     ngx_mp4_stsc_entry_t  *entry, *end, *first;

  3124.     entries = trak->sample_to_chunk_entries - 1;

  3126.     if (start) {
  3127.         start_sample = (uint32_t) trak->start_sample;

  3129.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3130.                        "mp4 stsc crop start_sample:%uD", start_sample);

  3132.     } else if (mp4->length) {
  3133.         start_sample = (uint32_t) (trak->end_sample - trak->start_sample);
  3134.         samples = 0;

  3136.         data = trak->out[NGX_HTTP_MP4_STSC_START].buf;

  3138.         if (data) {
  3139.             entry = (ngx_mp4_stsc_entry_t *) data->pos;
  3140.             samples = ngx_mp4_get_32value(entry->samples);
  3141.             entries--;

  3143.             if (samples > start_sample) {
  3144.                 samples = start_sample;
  3145.                 ngx_mp4_set_32value(entry->samples, samples);
  3146.             }

  3148.             start_sample -= samples;
  3149.         }

  3151.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3152.                        "mp4 stsc crop end_sample:%uD, ext_samples:%uD",
  3153.                        start_sample, samples);

  3155.     } else {
  3156.         return NGX_OK;
  3157.     }

  3159.     data = trak->out[NGX_HTTP_MP4_STSC_DATA].buf;

  3161.     entry = (ngx_mp4_stsc_entry_t *) data->pos;
  3162.     end = (ngx_mp4_stsc_entry_t *) data->last;

  3164.     chunk = ngx_mp4_get_32value(entry->chunk);
  3165.     samples = ngx_mp4_get_32value(entry->samples);
  3166.     id = ngx_mp4_get_32value(entry->id);
  3167.     prev_samples = 0;
  3168.     entry++;

  3170.     while (entry < end) {

  3172.         next_chunk = ngx_mp4_get_32value(entry->chunk);

  3174.         if (next_chunk < chunk) {
  3175.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3176.                           "unordered mp4 stsc chunks in \"%s\"",
  3177.                           mp4->file.name.data);
  3178.             return NGX_ERROR;
  3179.         }

  3181.         ngx_log_debug5(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3182.                        "sample:%uD, chunk:%uD, chunks:%uD, "
  3183.                        "samples:%uD, id:%uD",
  3184.                        start_sample, chunk, next_chunk - chunk, samples, id);

  3186.         n = (uint64_t) (next_chunk - chunk) * samples;

  3188.         if (start_sample < n) {
  3189.             goto found;
  3190.         }

  3192.         start_sample -= n;

  3194.         if (next_chunk > chunk) {
  3195.             prev_samples = samples;
  3196.         }

  3198.         chunk = next_chunk;
  3199.         samples = ngx_mp4_get_32value(entry->samples);
  3200.         id = ngx_mp4_get_32value(entry->id);
  3201.         entries--;
  3202.         entry++;
  3203.     }

  3205.     next_chunk = trak->chunks + 1;

  3207.     if (next_chunk < chunk) {
  3208.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3209.                       "unordered mp4 stsc chunks in \"%s\"",
  3210.                       mp4->file.name.data);
  3211.         return NGX_ERROR;
  3212.     }

  3214.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3215.                    "sample:%uD, chunk:%uD, chunks:%uD, samples:%uD",
  3216.                    start_sample, chunk, next_chunk - chunk, samples);

  3218.     n = (uint64_t) (next_chunk - chunk) * samples;

  3220.     if (start_sample > n) {
  3221.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3222.                       "%s time is out mp4 stsc chunks in \"%s\"",
  3223.                       start ? "start" : "end", mp4->file.name.data);
  3224.         return NGX_ERROR;
  3225.     }

  3227. found:

  3229.     entries++;
  3230.     entry--;

  3232.     if (samples == 0) {
  3233.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3234.                       "zero number of samples in \"%s\"",
  3235.                       mp4->file.name.data);
  3236.         return NGX_ERROR;
  3237.     }

  3239.     if (chunk == 0) {
  3240.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3241.                       "zero chunk in \"%s\"", mp4->file.name.data);
  3242.         return NGX_ERROR;
  3243.     }

  3245.     target_chunk = chunk - 1;
  3246.     target_chunk += start_sample / samples;
  3247.     chunk_samples = start_sample % samples;

  3249.     if (start) {
  3250.         data->pos = (u_char *) entry;

  3252.         trak->sample_to_chunk_entries = entries;
  3253.         trak->start_chunk = target_chunk;
  3254.         trak->start_chunk_samples = chunk_samples;

  3256.         ngx_mp4_set_32value(entry->chunk, trak->start_chunk + 1);

  3258.         samples -= chunk_samples;

  3260.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3261.                        "start_chunk:%ui, start_chunk_samples:%ui",
  3262.                        trak->start_chunk, trak->start_chunk_samples);

  3264.     } else {
  3265.         if (start_sample) {
  3266.             data->last = (u_char *) (entry + 1);
  3267.             trak->sample_to_chunk_entries -= entries - 1;
  3268.             trak->end_chunk_samples = samples;

  3270.         } else {
  3271.             data->last = (u_char *) entry;
  3272.             trak->sample_to_chunk_entries -= entries;
  3273.             trak->end_chunk_samples = prev_samples;
  3274.         }

  3276.         if (chunk_samples) {
  3277.             trak->end_chunk = target_chunk + 1;
  3278.             trak->end_chunk_samples = chunk_samples;

  3280.         } else {
  3281.             trak->end_chunk = target_chunk;
  3282.         }

  3284.         samples = chunk_samples;
  3285.         next_chunk = chunk + 1;

  3287.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3288.                        "end_chunk:%ui, end_chunk_samples:%ui",
  3289.                        trak->end_chunk, trak->end_chunk_samples);
  3290.     }

  3292.     if (chunk_samples && next_chunk - target_chunk == 2) {

  3294.         ngx_mp4_set_32value(entry->samples, samples);

  3296.     } else if (chunk_samples && start) {

  3298.         first = &trak->stsc_start_chunk_entry;
  3299.         ngx_mp4_set_32value(first->chunk, 1);
  3300.         ngx_mp4_set_32value(first->samples, samples);
  3301.         ngx_mp4_set_32value(first->id, id);

  3303.         buf = &trak->stsc_start_chunk_buf;
  3304.         buf->temporary = 1;
  3305.         buf->pos = (u_char *) first;
  3306.         buf->last = (u_char *) first + sizeof(ngx_mp4_stsc_entry_t);

  3308.         trak->out[NGX_HTTP_MP4_STSC_START].buf = buf;

  3310.         ngx_mp4_set_32value(entry->chunk, trak->start_chunk + 2);

  3312.         trak->sample_to_chunk_entries++;

  3314.     } else if (chunk_samples) {

  3316.         first = &trak->stsc_end_chunk_entry;
  3317.         ngx_mp4_set_32value(first->chunk, trak->end_chunk - trak->start_chunk);
  3318.         ngx_mp4_set_32value(first->samples, samples);
  3319.         ngx_mp4_set_32value(first->id, id);

  3321.         buf = &trak->stsc_end_chunk_buf;
  3322.         buf->temporary = 1;
  3323.         buf->pos = (u_char *) first;
  3324.         buf->last = (u_char *) first + sizeof(ngx_mp4_stsc_entry_t);

  3326.         trak->out[NGX_HTTP_MP4_STSC_END].buf = buf;

  3328.         trak->sample_to_chunk_entries++;
  3329.     }

  3331.     return NGX_OK;
  3332. }


  3335. ‌typedef struct {
  3336.     u_char    size[4];
  3337.     u_char    name[4];
  3338.     u_char    version[1];
  3339.     u_char    flags[3];
  3340.     u_char    uniform_size[4];
  3341.     u_char    entries[4];
  3342. ‌} ngx_mp4_stsz_atom_t;


  3345. static ngx_int_t
  3346. ‌ngx_http_mp4_read_stsz_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  3347. {
  3348.     u_char               *atom_header, *atom_table, *atom_end;
  3349.     size_t                atom_size;
  3350.     uint32_t              entries, size;
  3351.     ngx_buf_t            *atom, *data;
  3352.     ngx_mp4_stsz_atom_t  *stsz_atom;
  3353.     ngx_http_mp4_trak_t  *trak;

  3355.     /* sample sizes atom */

  3357.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stsz atom");

  3359.     atom_header = ngx_mp4_atom_header(mp4);
  3360.     stsz_atom = (ngx_mp4_stsz_atom_t *) atom_header;
  3361.     ngx_mp4_set_atom_name(stsz_atom, 's', 't', 's', 'z');

  3363.     if (ngx_mp4_atom_data_size(ngx_mp4_stsz_atom_t) > atom_data_size) {
  3364.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3365.                       "\"%s\" mp4 stsz atom too small", mp4->file.name.data);
  3366.         return NGX_ERROR;
  3367.     }

  3369.     size = ngx_mp4_get_32value(stsz_atom->uniform_size);
  3370.     entries = ngx_mp4_get_32value(stsz_atom->entries);

  3372.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3373.                    "sample uniform size:%uD, entries:%uD", size, entries);

  3375.     trak = ngx_mp4_last_trak(mp4);

  3377.     if (trak->out[NGX_HTTP_MP4_STSZ_ATOM].buf) {
  3378.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3379.                       "duplicate mp4 stsz atom in \"%s\"", mp4->file.name.data);
  3380.         return NGX_ERROR;
  3381.     }

  3383.     trak->sample_sizes_entries = entries;

  3385.     atom_table = atom_header + sizeof(ngx_mp4_stsz_atom_t);

  3387.     atom = &trak->stsz_atom_buf;
  3388.     atom->temporary = 1;
  3389.     atom->pos = atom_header;
  3390.     atom->last = atom_table;

  3392.     trak->out[NGX_HTTP_MP4_STSZ_ATOM].buf = atom;

  3394.     if (size == 0) {
  3395.         if (ngx_mp4_atom_data_size(ngx_mp4_stsz_atom_t)
  3396.             + (uint64_t) entries * sizeof(uint32_t) > atom_data_size)
  3397.         {
  3398.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3399.                           "\"%s\" mp4 stsz atom too small",
  3400.                           mp4->file.name.data);
  3401.             return NGX_ERROR;
  3402.         }

  3404.         atom_end = atom_table + entries * sizeof(uint32_t);

  3406.         data = &trak->stsz_data_buf;
  3407.         data->temporary = 1;
  3408.         data->pos = atom_table;
  3409.         data->last = atom_end;

  3411.         trak->out[NGX_HTTP_MP4_STSZ_DATA].buf = data;

  3413.     } else {
  3414.         /* if size != 0 then all samples are the same size */
  3415.         /* TODO : chunk samples */
  3416.         atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  3417.         ngx_mp4_set_32value(atom_header, atom_size);
  3418.         trak->size += atom_size;
  3419.     }

  3421.     ngx_mp4_atom_next(mp4, atom_data_size);

  3423.     return NGX_OK;
  3424. }


  3427. static ngx_int_t
  3428. ‌ngx_http_mp4_update_stsz_atom(ngx_http_mp4_file_t *mp4,
  3429.     ngx_http_mp4_trak_t *trak)
  3430. {
  3431.     size_t                atom_size;
  3432.     uint32_t             *pos, *end, entries;
  3433.     ngx_buf_t            *atom, *data;
  3434.     ngx_mp4_stsz_atom_t  *stsz_atom;

  3436.     /*
  3437.      * mdia.minf.stbl.stsz updating requires trak->start_sample
  3438.      * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
  3439.      * atom which may reside after mdia.minf
  3440.      */

  3442.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3443.                    "mp4 stsz atom update");

  3445.     data = trak->out[NGX_HTTP_MP4_STSZ_DATA].buf;

  3447.     if (data) {
  3448.         entries = trak->sample_sizes_entries;

  3450.         if (trak->start_sample >= entries) {
  3451.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3452.                           "start time is out mp4 stsz samples in \"%s\"",
  3453.                           mp4->file.name.data);
  3454.             return NGX_ERROR;
  3455.         }

  3457.         entries -= trak->start_sample;
  3458.         data->pos += trak->start_sample * sizeof(uint32_t);
  3459.         end = (uint32_t *) data->pos;

  3461.         for (pos = end - trak->start_chunk_samples; pos < end; pos++) {
  3462.             trak->start_chunk_samples_size += ngx_mp4_get_32value(pos);
  3463.         }

  3465.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3466.                        "chunk samples sizes:%uL",
  3467.                        trak->start_chunk_samples_size);

  3469.         if (trak->start_chunk_samples_size > (uint64_t) mp4->end) {
  3470.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3471.                           "too large mp4 start samples size in \"%s\"",
  3472.                           mp4->file.name.data);
  3473.             return NGX_ERROR;
  3474.         }

  3476.         if (mp4->length) {
  3477.             if (trak->end_sample - trak->start_sample > entries) {
  3478.                 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3479.                               "end time is out mp4 stsz samples in \"%s\"",
  3480.                               mp4->file.name.data);
  3481.                 return NGX_ERROR;
  3482.             }

  3484.             entries = trak->end_sample - trak->start_sample;
  3485.             data->last = data->pos + entries * sizeof(uint32_t);
  3486.             end = (uint32_t *) data->last;

  3488.             for (pos = end - trak->end_chunk_samples; pos < end; pos++) {
  3489.                 trak->end_chunk_samples_size += ngx_mp4_get_32value(pos);
  3490.             }

  3492.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3493.                            "mp4 stsz end_chunk_samples_size:%uL",
  3494.                            trak->end_chunk_samples_size);

  3496.             if (trak->end_chunk_samples_size > (uint64_t) mp4->end) {
  3497.                 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3498.                               "too large mp4 end samples size in \"%s\"",
  3499.                               mp4->file.name.data);
  3500.                 return NGX_ERROR;
  3501.             }
  3502.         }

  3504.         atom_size = sizeof(ngx_mp4_stsz_atom_t) + (data->last - data->pos);
  3505.         trak->size += atom_size;

  3507.         atom = trak->out[NGX_HTTP_MP4_STSZ_ATOM].buf;
  3508.         stsz_atom = (ngx_mp4_stsz_atom_t *) atom->pos;

  3510.         ngx_mp4_set_32value(stsz_atom->size, atom_size);
  3511.         ngx_mp4_set_32value(stsz_atom->entries, entries);
  3512.     }

  3514.     return NGX_OK;
  3515. }


  3518. ‌typedef struct {
  3519.     u_char    size[4];
  3520.     u_char    name[4];
  3521.     u_char    version[1];
  3522.     u_char    flags[3];
  3523.     u_char    entries[4];
  3524. ‌} ngx_mp4_stco_atom_t;


  3527. static ngx_int_t
  3528. ‌ngx_http_mp4_read_stco_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  3529. {
  3530.     u_char               *atom_header, *atom_table, *atom_end;
  3531.     uint32_t              entries;
  3532.     ngx_buf_t            *atom, *data;
  3533.     ngx_mp4_stco_atom_t  *stco_atom;
  3534.     ngx_http_mp4_trak_t  *trak;

  3536.     /* chunk offsets atom */

  3538.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stco atom");

  3540.     atom_header = ngx_mp4_atom_header(mp4);
  3541.     stco_atom = (ngx_mp4_stco_atom_t *) atom_header;
  3542.     ngx_mp4_set_atom_name(stco_atom, 's', 't', 'c', 'o');

  3544.     if (ngx_mp4_atom_data_size(ngx_mp4_stco_atom_t) > atom_data_size) {
  3545.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3546.                       "\"%s\" mp4 stco atom too small", mp4->file.name.data);
  3547.         return NGX_ERROR;
  3548.     }

  3550.     entries = ngx_mp4_get_32value(stco_atom->entries);

  3552.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "chunks:%uD", entries);

  3554.     if (ngx_mp4_atom_data_size(ngx_mp4_stco_atom_t)
  3555.         + (uint64_t) entries * sizeof(uint32_t) > atom_data_size)
  3556.     {
  3557.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3558.                       "\"%s\" mp4 stco atom too small", mp4->file.name.data);
  3559.         return NGX_ERROR;
  3560.     }

  3562.     atom_table = atom_header + sizeof(ngx_mp4_stco_atom_t);
  3563.     atom_end = atom_table + entries * sizeof(uint32_t);

  3565.     trak = ngx_mp4_last_trak(mp4);

  3567.     if (trak->out[NGX_HTTP_MP4_STCO_ATOM].buf
  3568.         || trak->out[NGX_HTTP_MP4_CO64_ATOM].buf)
  3569.     {
  3570.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3571.                       "duplicate mp4 stco/co64 atom in \"%s\"",
  3572.                       mp4->file.name.data);
  3573.         return NGX_ERROR;
  3574.     }

  3576.     trak->chunks = entries;

  3578.     atom = &trak->stco_atom_buf;
  3579.     atom->temporary = 1;
  3580.     atom->pos = atom_header;
  3581.     atom->last = atom_table;

  3583.     data = &trak->stco_data_buf;
  3584.     data->temporary = 1;
  3585.     data->pos = atom_table;
  3586.     data->last = atom_end;

  3588.     trak->out[NGX_HTTP_MP4_STCO_ATOM].buf = atom;
  3589.     trak->out[NGX_HTTP_MP4_STCO_DATA].buf = data;

  3591.     ngx_mp4_atom_next(mp4, atom_data_size);

  3593.     return NGX_OK;
  3594. }


  3597. static ngx_int_t
  3598. ‌ngx_http_mp4_update_stco_atom(ngx_http_mp4_file_t *mp4,
  3599.     ngx_http_mp4_trak_t *trak)
  3600. {
  3601.     size_t                atom_size;
  3602.     uint32_t              entries;
  3603.     uint64_t              chunk_offset, samples_size;
  3604.     ngx_buf_t            *atom, *data;
  3605.     ngx_mp4_stco_atom_t  *stco_atom;

  3607.     /*
  3608.      * mdia.minf.stbl.stco updating requires trak->start_chunk
  3609.      * from mdia.minf.stbl.stsc which depends on value from mdia.mdhd
  3610.      * atom which may reside after mdia.minf
  3611.      */

  3613.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3614.                    "mp4 stco atom update");

  3616.     data = trak->out[NGX_HTTP_MP4_STCO_DATA].buf;

  3618.     if (data == NULL) {
  3619.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3620.                       "no mp4 stco atoms were found in \"%s\"",
  3621.                       mp4->file.name.data);
  3622.         return NGX_ERROR;
  3623.     }

  3625.     if (trak->start_chunk >= trak->chunks) {
  3626.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3627.                       "start time is out mp4 stco chunks in \"%s\"",
  3628.                       mp4->file.name.data);
  3629.         return NGX_ERROR;
  3630.     }

  3632.     data->pos += trak->start_chunk * sizeof(uint32_t);

  3634.     chunk_offset = ngx_mp4_get_32value(data->pos);
  3635.     samples_size = trak->start_chunk_samples_size;

  3637.     if (chunk_offset > (uint64_t) mp4->end - samples_size
  3638.         || chunk_offset + samples_size > NGX_MAX_UINT32_VALUE)
  3639.     {
  3640.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3641.                       "too large chunk offset in \"%s\"",
  3642.                       mp4->file.name.data);
  3643.         return NGX_ERROR;
  3644.     }

  3646.     trak->start_offset = chunk_offset + samples_size;
  3647.     ngx_mp4_set_32value(data->pos, trak->start_offset);

  3649.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3650.                    "start chunk offset:%O", trak->start_offset);

  3652.     if (mp4->length) {

  3654.         if (trak->end_chunk > trak->chunks) {
  3655.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3656.                           "end time is out mp4 stco chunks in \"%s\"",
  3657.                           mp4->file.name.data);
  3658.             return NGX_ERROR;
  3659.         }

  3661.         entries = trak->end_chunk - trak->start_chunk;
  3662.         data->last = data->pos + entries * sizeof(uint32_t);

  3664.         if (entries) {
  3665.             chunk_offset = ngx_mp4_get_32value(data->last - sizeof(uint32_t));
  3666.             samples_size = trak->end_chunk_samples_size;

  3668.             if (chunk_offset > (uint64_t) mp4->end - samples_size
  3669.                 || chunk_offset + samples_size > NGX_MAX_UINT32_VALUE)
  3670.             {
  3671.                 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3672.                               "too large chunk offset in \"%s\"",
  3673.                               mp4->file.name.data);
  3674.                 return NGX_ERROR;
  3675.             }

  3677.             trak->end_offset = chunk_offset + samples_size;

  3679.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3680.                            "end chunk offset:%O", trak->end_offset);
  3681.         }

  3683.     } else {
  3684.         entries = trak->chunks - trak->start_chunk;
  3685.         trak->end_offset = mp4->mdat_data.buf->file_last;
  3686.     }

  3688.     if (entries == 0) {
  3689.         trak->start_offset = mp4->end;
  3690.         trak->end_offset = 0;
  3691.     }

  3693.     atom_size = sizeof(ngx_mp4_stco_atom_t) + (data->last - data->pos);
  3694.     trak->size += atom_size;

  3696.     atom = trak->out[NGX_HTTP_MP4_STCO_ATOM].buf;
  3697.     stco_atom = (ngx_mp4_stco_atom_t *) atom->pos;

  3699.     ngx_mp4_set_32value(stco_atom->size, atom_size);
  3700.     ngx_mp4_set_32value(stco_atom->entries, entries);

  3702.     return NGX_OK;
  3703. }


  3706. static void
  3707. ‌ngx_http_mp4_adjust_stco_atom(ngx_http_mp4_file_t *mp4,
  3708.     ngx_http_mp4_trak_t *trak, int32_t adjustment)
  3709. {
  3710.     uint32_t    offset, *entry, *end;
  3711.     ngx_buf_t  *data;

  3713.     /*
  3714.      * moov.trak.mdia.minf.stbl.stco adjustment requires
  3715.      * minimal start offset of all traks and new moov atom size
  3716.      */

  3718.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3719.                    "mp4 stco atom adjustment");

  3721.     data = trak->out[NGX_HTTP_MP4_STCO_DATA].buf;
  3722.     entry = (uint32_t *) data->pos;
  3723.     end = (uint32_t *) data->last;

  3725.     while (entry < end) {
  3726.         offset = ngx_mp4_get_32value(entry);
  3727.         offset += adjustment;
  3728.         ngx_mp4_set_32value(entry, offset);
  3729.         entry++;
  3730.     }
  3731. }


  3734. ‌typedef struct {
  3735.     u_char    size[4];
  3736.     u_char    name[4];
  3737.     u_char    version[1];
  3738.     u_char    flags[3];
  3739.     u_char    entries[4];
  3740. ‌} ngx_mp4_co64_atom_t;


  3743. static ngx_int_t
  3744. ‌ngx_http_mp4_read_co64_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  3745. {
  3746.     u_char               *atom_header, *atom_table, *atom_end;
  3747.     uint32_t              entries;
  3748.     ngx_buf_t            *atom, *data;
  3749.     ngx_mp4_co64_atom_t  *co64_atom;
  3750.     ngx_http_mp4_trak_t  *trak;

  3752.     /* chunk offsets atom */

  3754.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 co64 atom");

  3756.     atom_header = ngx_mp4_atom_header(mp4);
  3757.     co64_atom = (ngx_mp4_co64_atom_t *) atom_header;
  3758.     ngx_mp4_set_atom_name(co64_atom, 'c', 'o', '6', '4');

  3760.     if (ngx_mp4_atom_data_size(ngx_mp4_co64_atom_t) > atom_data_size) {
  3761.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3762.                       "\"%s\" mp4 co64 atom too small", mp4->file.name.data);
  3763.         return NGX_ERROR;
  3764.     }

  3766.     entries = ngx_mp4_get_32value(co64_atom->entries);

  3768.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "chunks:%uD", entries);

  3770.     if (ngx_mp4_atom_data_size(ngx_mp4_co64_atom_t)
  3771.         + (uint64_t) entries * sizeof(uint64_t) > atom_data_size)
  3772.     {
  3773.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3774.                       "\"%s\" mp4 co64 atom too small", mp4->file.name.data);
  3775.         return NGX_ERROR;
  3776.     }

  3778.     atom_table = atom_header + sizeof(ngx_mp4_co64_atom_t);
  3779.     atom_end = atom_table + entries * sizeof(uint64_t);

  3781.     trak = ngx_mp4_last_trak(mp4);

  3783.     if (trak->out[NGX_HTTP_MP4_STCO_ATOM].buf
  3784.         || trak->out[NGX_HTTP_MP4_CO64_ATOM].buf)
  3785.     {
  3786.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3787.                       "duplicate mp4 stco/co64 atom in \"%s\"",
  3788.                       mp4->file.name.data);
  3789.         return NGX_ERROR;
  3790.     }

  3792.     trak->chunks = entries;

  3794.     atom = &trak->co64_atom_buf;
  3795.     atom->temporary = 1;
  3796.     atom->pos = atom_header;
  3797.     atom->last = atom_table;

  3799.     data = &trak->co64_data_buf;
  3800.     data->temporary = 1;
  3801.     data->pos = atom_table;
  3802.     data->last = atom_end;

  3804.     trak->out[NGX_HTTP_MP4_CO64_ATOM].buf = atom;
  3805.     trak->out[NGX_HTTP_MP4_CO64_DATA].buf = data;

  3807.     ngx_mp4_atom_next(mp4, atom_data_size);

  3809.     return NGX_OK;
  3810. }


  3813. static ngx_int_t
  3814. ‌ngx_http_mp4_update_co64_atom(ngx_http_mp4_file_t *mp4,
  3815.     ngx_http_mp4_trak_t *trak)
  3816. {
  3817.     size_t                atom_size;
  3818.     uint64_t              entries, chunk_offset, samples_size;
  3819.     ngx_buf_t            *atom, *data;
  3820.     ngx_mp4_co64_atom_t  *co64_atom;

  3822.     /*
  3823.      * mdia.minf.stbl.co64 updating requires trak->start_chunk
  3824.      * from mdia.minf.stbl.stsc which depends on value from mdia.mdhd
  3825.      * atom which may reside after mdia.minf
  3826.      */

  3828.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3829.                    "mp4 co64 atom update");

  3831.     data = trak->out[NGX_HTTP_MP4_CO64_DATA].buf;

  3833.     if (data == NULL) {
  3834.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3835.                       "no mp4 co64 atoms were found in \"%s\"",
  3836.                       mp4->file.name.data);
  3837.         return NGX_ERROR;
  3838.     }

  3840.     if (trak->start_chunk >= trak->chunks) {
  3841.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3842.                       "start time is out mp4 co64 chunks in \"%s\"",
  3843.                       mp4->file.name.data);
  3844.         return NGX_ERROR;
  3845.     }

  3847.     data->pos += trak->start_chunk * sizeof(uint64_t);

  3849.     chunk_offset = ngx_mp4_get_64value(data->pos);
  3850.     samples_size = trak->start_chunk_samples_size;

  3852.     if (chunk_offset > (uint64_t) mp4->end - samples_size) {
  3853.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3854.                       "too large chunk offset in \"%s\"",
  3855.                       mp4->file.name.data);
  3856.         return NGX_ERROR;
  3857.     }

  3859.     trak->start_offset = chunk_offset + samples_size;
  3860.     ngx_mp4_set_64value(data->pos, trak->start_offset);

  3862.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3863.                    "start chunk offset:%O", trak->start_offset);

  3865.     if (mp4->length) {

  3867.         if (trak->end_chunk > trak->chunks) {
  3868.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3869.                           "end time is out mp4 co64 chunks in \"%s\"",
  3870.                           mp4->file.name.data);
  3871.             return NGX_ERROR;
  3872.         }

  3874.         entries = trak->end_chunk - trak->start_chunk;
  3875.         data->last = data->pos + entries * sizeof(uint64_t);

  3877.         if (entries) {
  3878.             chunk_offset = ngx_mp4_get_64value(data->last - sizeof(uint64_t));
  3879.             samples_size = trak->end_chunk_samples_size;

  3881.             if (chunk_offset > (uint64_t) mp4->end - samples_size) {
  3882.                 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3883.                               "too large chunk offset in \"%s\"",
  3884.                               mp4->file.name.data);
  3885.                 return NGX_ERROR;
  3886.             }

  3888.             trak->end_offset = chunk_offset + samples_size;

  3890.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3891.                            "end chunk offset:%O", trak->end_offset);
  3892.         }

  3894.     } else {
  3895.         entries = trak->chunks - trak->start_chunk;
  3896.         trak->end_offset = mp4->mdat_data.buf->file_last;
  3897.     }

  3899.     if (entries == 0) {
  3900.         trak->start_offset = mp4->end;
  3901.         trak->end_offset = 0;
  3902.     }

  3904.     atom_size = sizeof(ngx_mp4_co64_atom_t) + (data->last - data->pos);
  3905.     trak->size += atom_size;

  3907.     atom = trak->out[NGX_HTTP_MP4_CO64_ATOM].buf;
  3908.     co64_atom = (ngx_mp4_co64_atom_t *) atom->pos;

  3910.     ngx_mp4_set_32value(co64_atom->size, atom_size);
  3911.     ngx_mp4_set_32value(co64_atom->entries, entries);

  3913.     return NGX_OK;
  3914. }


  3917. static void
  3918. ‌ngx_http_mp4_adjust_co64_atom(ngx_http_mp4_file_t *mp4,
  3919.     ngx_http_mp4_trak_t *trak, off_t adjustment)
  3920. {
  3921.     uint64_t    offset, *entry, *end;
  3922.     ngx_buf_t  *data;

  3924.     /*
  3925.      * moov.trak.mdia.minf.stbl.co64 adjustment requires
  3926.      * minimal start offset of all traks and new moov atom size
  3927.      */

  3929.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3930.                    "mp4 co64 atom adjustment");

  3932.     data = trak->out[NGX_HTTP_MP4_CO64_DATA].buf;
  3933.     entry = (uint64_t *) data->pos;
  3934.     end = (uint64_t *) data->last;

  3936.     while (entry < end) {
  3937.         offset = ngx_mp4_get_64value(entry);
  3938.         offset += adjustment;
  3939.         ngx_mp4_set_64value(entry, offset);
  3940.         entry++;
  3941.     }
  3942. }


  3945. static char *
  3946. ‌ngx_http_mp4(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3947. {
  3948.     ngx_http_core_loc_conf_t  *clcf;

  3950.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  3951.     clcf->handler = ngx_http_mp4_handler;

  3953.     return NGX_CONF_OK;
  3954. }


  3957. static void *
  3958. ‌ngx_http_mp4_create_conf(ngx_conf_t *cf)
  3959. {
  3960.     ngx_http_mp4_conf_t  *conf;

  3962.     conf = ngx_palloc(cf->pool, sizeof(ngx_http_mp4_conf_t));
  3963.     if (conf == NULL) {
  3964.         return NULL;
  3965.     }

  3967.     conf->buffer_size = NGX_CONF_UNSET_SIZE;
  3968.     conf->max_buffer_size = NGX_CONF_UNSET_SIZE;
  3969.     conf->start_key_frame = NGX_CONF_UNSET;

  3971.     return conf;
  3972. }


  3975. static char *
  3976. ‌ngx_http_mp4_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  3977. {
  3978.     ngx_http_mp4_conf_t *prev = parent;
  3979.     ngx_http_mp4_conf_t *conf = child;

  3981.     ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size, 512 * 1024);
  3982.     ngx_conf_merge_size_value(conf->max_buffer_size, prev->max_buffer_size,
  3983.                               10 * 1024 * 1024);
  3984.     ngx_conf_merge_value(conf->start_key_frame, prev->start_key_frame, 0);

  3986.     return NGX_CONF_OK;
  3987. }

One Level Up Top Level