One Level Up Top Level

src/http/modules/ngx_http_mp4_module.c - nginx-1.31.3 nginx/ @ 42f8df65b

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 && mp4->buffer_end
  1067.         && mp4->buffer_pos + size <= mp4->buffer_end)
  1068.     {
  1069.         return NGX_OK;
  1070.     }

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

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

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

  1088.         mp4->buffer_start = mp4->buffer;
  1089.     }

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

  1094.     if (n == NGX_ERROR) {
  1095.         return NGX_ERROR;
  1096.     }

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

  1105.     mp4->buffer_pos = mp4->buffer_start;
  1106.     mp4->buffer_end = mp4->buffer_start + mp4->buffer_size;

  1108.     return NGX_OK;
  1109. }


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

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

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

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

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

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

  1143.     ngx_mp4_set_32value(ftyp_atom, atom_size);
  1144.     ngx_mp4_set_atom_name(ftyp_atom, 'f', 't', 'y', 'p');

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

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

  1158.     mp4->ftyp_atom.buf = atom;
  1159.     mp4->ftyp_size = atom_size;
  1160.     mp4->content_length = atom_size;

  1162.     ngx_mp4_atom_next(mp4, atom_data_size);

  1164.     return NGX_OK;
  1165. }


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1256.     return rc;
  1257. }


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

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

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

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

  1280.     mp4->mdat_atom.buf = &mp4->mdat_atom_buf;
  1281.     mp4->mdat_atom.next = &mp4->mdat_data;
  1282.     mp4->mdat_data.buf = data;

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

  1288.     } else {
  1289.         ngx_mp4_atom_next(mp4, atom_data_size);
  1290.     }

  1292.     return NGX_OK;
  1293. }


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

  1306.     atom_data_size = end_offset - start_offset;
  1307.     mp4->mdat_data.buf->file_pos = start_offset;
  1308.     mp4->mdat_data.buf->file_last = end_offset;

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

  1313.     atom_header = mp4->mdat_atom_header;

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

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

  1329.     ngx_mp4_set_32value(atom_header, atom_size);
  1330.     ngx_mp4_set_atom_name(atom_header, 'm', 'd', 'a', 't');

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

  1337.     return atom_header_size;
  1338. }


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

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


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

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

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

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

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

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

  1421.     } else {
  1422.         /* version 1: 64-bit duration */

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

  1431.         timescale = ngx_mp4_get_32value(mvhd64_atom->timescale);
  1432.         duration = ngx_mp4_get_64value(mvhd64_atom->duration);
  1433.     }

  1435.     mp4->timescale = timescale;

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

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

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

  1450.     duration -= start_time;

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

  1455.         if (duration > length_time) {
  1456.             duration = length_time;
  1457.         }
  1458.     }

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

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

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

  1470.     } else {
  1471.         ngx_mp4_set_64value(mvhd64_atom->duration, duration);
  1472.     }

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

  1479.     mp4->mvhd_atom.buf = atom;

  1481.     ngx_mp4_atom_next(mp4, atom_data_size);

  1483.     return NGX_OK;
  1484. }


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

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

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

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

  1505.     atom_header = ngx_mp4_atom_header(mp4);
  1506.     ngx_mp4_set_atom_name(atom_header, 't', 'r', 'a', 'k');

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

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

  1515.     atom_end = mp4->buffer_pos + (size_t) atom_data_size;
  1516.     atom_file_end = mp4->offset + atom_data_size;

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

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

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

  1532.     return rc;
  1533. }


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

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


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

  1555.     return NGX_ERROR;
  1556. }


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

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


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

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

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

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

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

  1628.     } else {
  1629.         /* version 1: 64-bit duration */

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

  1638.         duration = ngx_mp4_get_64value(tkhd64_atom->duration);
  1639.     }

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

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

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

  1653.     duration -= start_time;

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

  1658.         if (duration > length_time) {
  1659.             duration = length_time;
  1660.         }
  1661.     }

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

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

  1669.     trak = ngx_mp4_last_trak(mp4);

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

  1677.     trak->tkhd_size = atom_size;
  1678.     trak->movie_duration = duration;

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

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

  1685.     } else {
  1686.         ngx_mp4_set_64value(tkhd64_atom->duration, duration);
  1687.     }

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

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

  1696.     ngx_mp4_atom_next(mp4, atom_data_size);

  1698.     return NGX_OK;
  1699. }


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

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

  1711.     atom_header = ngx_mp4_atom_header(mp4);
  1712.     ngx_mp4_set_atom_name(atom_header, 'm', 'd', 'i', 'a');

  1714.     trak = ngx_mp4_last_trak(mp4);

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

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

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

  1729.     return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_mdia_atoms, atom_data_size);
  1730. }


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

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


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

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


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

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

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

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

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

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

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

  1812.         timescale = ngx_mp4_get_32value(mdhd64_atom->timescale);
  1813.         duration = ngx_mp4_get_64value(mdhd64_atom->duration);
  1814.     }

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

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

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

  1828.     duration -= start_time;

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

  1833.         if (duration > length_time) {
  1834.             duration = length_time;
  1835.         }
  1836.     }

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

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

  1844.     trak = ngx_mp4_last_trak(mp4);

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

  1852.     trak->mdhd_size = atom_size;
  1853.     trak->timescale = timescale;
  1854.     trak->duration = duration;

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

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

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

  1865.     ngx_mp4_atom_next(mp4, atom_data_size);

  1867.     return NGX_OK;
  1868. }


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

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

  1884.     mdhd_atom = (ngx_mp4_mdhd_atom_t *) atom->pos;
  1885.     mdhd64_atom = (ngx_mp4_mdhd64_atom_t *) atom->pos;

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

  1890.     } else {
  1891.         ngx_mp4_set_64value(mdhd64_atom->duration, trak->duration);
  1892.     }

  1894.     trak->size += trak->mdhd_size;
  1895. }


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

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

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

  1913.     trak = ngx_mp4_last_trak(mp4);

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

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

  1926.     trak->hdlr_size = atom_size;
  1927.     trak->out[NGX_HTTP_MP4_HDLR_ATOM].buf = atom;

  1929.     ngx_mp4_atom_next(mp4, atom_data_size);

  1931.     return NGX_OK;
  1932. }


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

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

  1944.     atom_header = ngx_mp4_atom_header(mp4);
  1945.     ngx_mp4_set_atom_name(atom_header, 'm', 'i', 'n', 'f');

  1947.     trak = ngx_mp4_last_trak(mp4);

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

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

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

  1962.     return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_minf_atoms, atom_data_size);
  1963. }


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

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


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

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

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

  1996.     trak = ngx_mp4_last_trak(mp4);

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

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

  2012.     trak->vmhd_size += atom_size;
  2013.     trak->out[NGX_HTTP_MP4_VMHD_ATOM].buf = atom;

  2015.     ngx_mp4_atom_next(mp4, atom_data_size);

  2017.     return NGX_OK;
  2018. }


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

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

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

  2036.     trak = ngx_mp4_last_trak(mp4);

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

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

  2052.     trak->smhd_size += atom_size;
  2053.     trak->out[NGX_HTTP_MP4_SMHD_ATOM].buf = atom;

  2055.     ngx_mp4_atom_next(mp4, atom_data_size);

  2057.     return NGX_OK;
  2058. }


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

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

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

  2076.     trak = ngx_mp4_last_trak(mp4);

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

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

  2089.     trak->dinf_size += atom_size;
  2090.     trak->out[NGX_HTTP_MP4_DINF_ATOM].buf = atom;

  2092.     ngx_mp4_atom_next(mp4, atom_data_size);

  2094.     return NGX_OK;
  2095. }


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

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

  2107.     atom_header = ngx_mp4_atom_header(mp4);
  2108.     ngx_mp4_set_atom_name(atom_header, 's', 't', 'b', 'l');

  2110.     trak = ngx_mp4_last_trak(mp4);

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

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

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

  2125.     return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_stbl_atoms, atom_data_size);
  2126. }


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

  2137.     if (trak->prefix == 0) {
  2138.         return;
  2139.     }

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

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

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

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

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

  2160.     elst_atom->version[0] = 1;
  2161.     elst_atom->flags[0] = 0;
  2162.     elst_atom->flags[1] = 0;
  2163.     elst_atom->flags[2] = 0;

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

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

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

  2178.     trak->size += sizeof(ngx_mp4_edts_atom_t) + sizeof(ngx_mp4_elst_atom_t);
  2179. }


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

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


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

  2201.     u_char    media_size[4];
  2202.     u_char    media_name[4];
  2203. ‌} ngx_mp4_stsd_atom_t;


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

  2215.     /* sample description atom */

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

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

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

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

  2237.     trak = ngx_mp4_last_trak(mp4);

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

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

  2250.     trak->out[NGX_HTTP_MP4_STSD_ATOM].buf = atom;
  2251.     trak->size += atom_size;

  2253.     ngx_mp4_atom_next(mp4, atom_data_size);

  2255.     return NGX_OK;
  2256. }


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

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


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

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

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

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

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

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

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

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

  2309.     atom_table = atom_header + sizeof(ngx_mp4_stts_atom_t);
  2310.     atom_end = atom_table + entries * sizeof(ngx_mp4_stts_entry_t);

  2312.     trak = ngx_mp4_last_trak(mp4);

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

  2320.     trak->time_to_sample_entries = entries;

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

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

  2332.     trak->out[NGX_HTTP_MP4_STTS_ATOM].buf = atom;
  2333.     trak->out[NGX_HTTP_MP4_STTS_DATA].buf = data;

  2335.     ngx_mp4_atom_next(mp4, atom_data_size);

  2337.     return NGX_OK;
  2338. }


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

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

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

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

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

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

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

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

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

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

  2385.     return NGX_OK;
  2386. }


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

  2399.     if (start) {
  2400.         start_sec = mp4->start;

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

  2405.     } else if (mp4->length) {
  2406.         start_sec = mp4->length;

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

  2411.     } else {
  2412.         return NGX_OK;
  2413.     }

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

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

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

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

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

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

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

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

  2449.         return NGX_ERROR;

  2451.     } else {
  2452.         trak->end_sample = trak->start_sample + start_sample;

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

  2457.         return NGX_OK;
  2458.     }

  2460. found:

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

  2469.         start_sample -= key_prefix;

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

  2475.             entry--;
  2476.             entries++;

  2478.             count = ngx_mp4_get_32value(entry->count);
  2479.             duration = ngx_mp4_get_32value(entry->duration);
  2480.             rest = count;
  2481.         }

  2483.         trak->prefix += key_prefix * duration;
  2484.         trak->duration += trak->prefix;
  2485.         rest -= key_prefix;

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

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

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

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

  2507.     return NGX_OK;
  2508. }


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

  2519.     *key_prefix = 0;

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

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

  2531.     entry = (uint32_t *) data->pos;
  2532.     end = (uint32_t *) data->last;

  2534.     /* sync samples starts from 1 */
  2535.     start_sample++;

  2537.     while (entry < end) {
  2538.         sample = ngx_mp4_get_32value(entry);

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

  2547.         if (sample > start_sample) {
  2548.             break;
  2549.         }

  2551.         *key_prefix = start_sample - sample;
  2552.         entry++;
  2553.     }

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

  2558.     return NGX_OK;
  2559. }


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


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

  2580.     /* sync samples atom */

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

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

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

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

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

  2599.     trak = ngx_mp4_last_trak(mp4);

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

  2607.     trak->sync_samples_entries = entries;

  2609.     atom_table = atom_header + sizeof(ngx_http_mp4_stss_atom_t);

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

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

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

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

  2631.     trak->out[NGX_HTTP_MP4_STSS_ATOM].buf = atom;
  2632.     trak->out[NGX_HTTP_MP4_STSS_DATA].buf = data;

  2634.     ngx_mp4_atom_next(mp4, atom_data_size);

  2636.     return NGX_OK;
  2637. }


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

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

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

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

  2660.     if (data == NULL) {
  2661.         return NGX_OK;
  2662.     }

  2664.     ngx_http_mp4_crop_stss_data(mp4, trak, 1);
  2665.     ngx_http_mp4_crop_stss_data(mp4, trak, 0);

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

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

  2674.         start_sample = trak->start_sample;

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

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

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

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

  2693.     ngx_mp4_set_32value(stss_atom->size, atom_size);
  2694.     ngx_mp4_set_32value(stss_atom->entries, trak->sync_samples_entries);

  2696.     return NGX_OK;
  2697. }


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

  2708.     /* sync samples starts from 1 */

  2710.     if (start) {
  2711.         start_sample = trak->start_sample + 1;

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

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

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

  2722.     } else {
  2723.         return;
  2724.     }

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

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

  2732.     while (entry < end) {
  2733.         sample = ngx_mp4_get_32value(entry);

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

  2738.         if (sample >= start_sample) {
  2739.             goto found;
  2740.         }

  2742.         entries--;
  2743.         entry++;
  2744.     }

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

  2749. found:

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

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


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

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


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

  2785.     /* composition offsets atom */

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

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

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

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

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

  2804.     trak = ngx_mp4_last_trak(mp4);

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

  2812.     trak->composition_offset_entries = entries;

  2814.     atom_table = atom_header + sizeof(ngx_mp4_ctts_atom_t);

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

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

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

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

  2836.     trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf = atom;
  2837.     trak->out[NGX_HTTP_MP4_CTTS_DATA].buf = data;

  2839.     ngx_mp4_atom_next(mp4, atom_data_size);

  2841.     return NGX_OK;
  2842. }


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

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

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

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

  2864.     if (data == NULL) {
  2865.         return;
  2866.     }

  2868.     ngx_http_mp4_crop_ctts_data(mp4, trak, 1);
  2869.     ngx_http_mp4_crop_ctts_data(mp4, trak, 0);

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

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

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

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

  2887.     ngx_mp4_set_32value(ctts_atom->size, atom_size);
  2888.     ngx_mp4_set_32value(ctts_atom->entries, trak->composition_offset_entries);

  2890.     return;
  2891. }


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

  2903.     /* sync samples starts from 1 */

  2905.     if (start) {
  2906.         start_sample = trak->start_sample + 1;

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

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

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

  2917.     } else {
  2918.         return;
  2919.     }

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

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

  2927.     while (entry < end) {
  2928.         count = ngx_mp4_get_32value(entry->count);

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

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

  2939.         start_sample -= count;
  2940.         entries--;
  2941.         entry++;
  2942.     }

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

  2949.     return;

  2951. found:

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

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


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


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

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

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

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

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

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

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

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

  3011.     atom_table = atom_header + sizeof(ngx_mp4_stsc_atom_t);
  3012.     atom_end = atom_table + entries * sizeof(ngx_mp4_stsc_entry_t);

  3014.     trak = ngx_mp4_last_trak(mp4);

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

  3022.     trak->sample_to_chunk_entries = entries;

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

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

  3034.     trak->out[NGX_HTTP_MP4_STSC_ATOM].buf = atom;
  3035.     trak->out[NGX_HTTP_MP4_STSC_DATA].buf = data;

  3037.     ngx_mp4_atom_next(mp4, atom_data_size);

  3039.     return NGX_OK;
  3040. }


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

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

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

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

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

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

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

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

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

  3090.     entry = (ngx_mp4_stsc_entry_t *) data->pos;
  3091.     end = (ngx_mp4_stsc_entry_t *) data->last;

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

  3100.     atom_size = sizeof(ngx_mp4_stsc_atom_t)
  3101.                 + trak->sample_to_chunk_entries * sizeof(ngx_mp4_stsc_entry_t);

  3103.     trak->size += atom_size;

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

  3108.     ngx_mp4_set_32value(stsc_atom->size, atom_size);
  3109.     ngx_mp4_set_32value(stsc_atom->entries, trak->sample_to_chunk_entries);

  3111.     return NGX_OK;
  3112. }


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

  3126.     entries = trak->sample_to_chunk_entries - 1;

  3128.     if (start) {
  3129.         start_sample = (uint32_t) trak->start_sample;

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

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

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

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

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

  3150.             start_sample -= samples;
  3151.         }

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

  3157.     } else {
  3158.         return NGX_OK;
  3159.     }

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

  3163.     entry = (ngx_mp4_stsc_entry_t *) data->pos;
  3164.     end = (ngx_mp4_stsc_entry_t *) data->last;

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

  3172.     while (entry < end) {

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

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

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

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

  3190.         if (start_sample < n) {
  3191.             goto found;
  3192.         }

  3194.         start_sample -= n;

  3196.         if (next_chunk > chunk) {
  3197.             prev_samples = samples;
  3198.         }

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

  3207.     next_chunk = trak->chunks + 1;

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

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

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

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

  3229. found:

  3231.     entries++;
  3232.     entry--;

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

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

  3247.     target_chunk = chunk - 1;
  3248.     target_chunk += start_sample / samples;
  3249.     chunk_samples = start_sample % samples;

  3251.     if (start) {
  3252.         data->pos = (u_char *) entry;

  3254.         trak->sample_to_chunk_entries = entries;
  3255.         trak->start_chunk = target_chunk;
  3256.         trak->start_chunk_samples = chunk_samples;

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

  3260.         samples -= chunk_samples;

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

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

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

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

  3282.         } else {
  3283.             trak->end_chunk = target_chunk;
  3284.         }

  3286.         samples = chunk_samples;
  3287.         next_chunk = chunk + 1;

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

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

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

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

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

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

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

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

  3314.         trak->sample_to_chunk_entries++;

  3316.     } else if (chunk_samples) {

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

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

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

  3330.         trak->sample_to_chunk_entries++;
  3331.     }

  3333.     return NGX_OK;
  3334. }


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


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

  3357.     /* sample sizes atom */

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

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

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

  3371.     size = ngx_mp4_get_32value(stsz_atom->uniform_size);
  3372.     entries = ngx_mp4_get_32value(stsz_atom->entries);

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

  3377.     trak = ngx_mp4_last_trak(mp4);

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

  3385.     trak->sample_sizes_entries = entries;

  3387.     atom_table = atom_header + sizeof(ngx_mp4_stsz_atom_t);

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

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

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

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

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

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

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

  3423.     ngx_mp4_atom_next(mp4, atom_data_size);

  3425.     return NGX_OK;
  3426. }


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

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

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

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

  3449.     if (data) {
  3450.         entries = trak->sample_sizes_entries;

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

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

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

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

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

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

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

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

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

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

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

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

  3512.         ngx_mp4_set_32value(stsz_atom->size, atom_size);
  3513.         ngx_mp4_set_32value(stsz_atom->entries, entries);
  3514.     }

  3516.     return NGX_OK;
  3517. }


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


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

  3538.     /* chunk offsets atom */

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

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

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

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

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

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

  3564.     atom_table = atom_header + sizeof(ngx_mp4_stco_atom_t);
  3565.     atom_end = atom_table + entries * sizeof(uint32_t);

  3567.     trak = ngx_mp4_last_trak(mp4);

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

  3578.     trak->chunks = entries;

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

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

  3590.     trak->out[NGX_HTTP_MP4_STCO_ATOM].buf = atom;
  3591.     trak->out[NGX_HTTP_MP4_STCO_DATA].buf = data;

  3593.     ngx_mp4_atom_next(mp4, atom_data_size);

  3595.     return NGX_OK;
  3596. }


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

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

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

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

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

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

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

  3636.     chunk_offset = ngx_mp4_get_32value(data->pos);
  3637.     samples_size = trak->start_chunk_samples_size;

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

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

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

  3654.     if (mp4->length) {

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

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

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

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

  3679.             trak->end_offset = chunk_offset + samples_size;

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

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

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

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

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

  3701.     ngx_mp4_set_32value(stco_atom->size, atom_size);
  3702.     ngx_mp4_set_32value(stco_atom->entries, entries);

  3704.     return NGX_OK;
  3705. }


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

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

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

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

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


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


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

  3754.     /* chunk offsets atom */

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

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

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

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

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

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

  3780.     atom_table = atom_header + sizeof(ngx_mp4_co64_atom_t);
  3781.     atom_end = atom_table + entries * sizeof(uint64_t);

  3783.     trak = ngx_mp4_last_trak(mp4);

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

  3794.     trak->chunks = entries;

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

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

  3806.     trak->out[NGX_HTTP_MP4_CO64_ATOM].buf = atom;
  3807.     trak->out[NGX_HTTP_MP4_CO64_DATA].buf = data;

  3809.     ngx_mp4_atom_next(mp4, atom_data_size);

  3811.     return NGX_OK;
  3812. }


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

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

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

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

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

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

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

  3851.     chunk_offset = ngx_mp4_get_64value(data->pos);
  3852.     samples_size = trak->start_chunk_samples_size;

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

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

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

  3867.     if (mp4->length) {

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

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

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

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

  3890.             trak->end_offset = chunk_offset + samples_size;

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

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

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

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

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

  3912.     ngx_mp4_set_32value(co64_atom->size, atom_size);
  3913.     ngx_mp4_set_32value(co64_atom->entries, entries);

  3915.     return NGX_OK;
  3916. }


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

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

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

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

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


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

  3952.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  3953.     clcf->handler = ngx_http_mp4_handler;

  3955.     return NGX_CONF_OK;
  3956. }


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

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

  3969.     conf->buffer_size = NGX_CONF_UNSET_SIZE;
  3970.     conf->max_buffer_size = NGX_CONF_UNSET_SIZE;
  3971.     conf->start_key_frame = NGX_CONF_UNSET;

  3973.     return conf;
  3974. }


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

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

  3988.     return NGX_CONF_OK;
  3989. }

One Level Up Top Level