One Level Up Top Level

src/http/modules/ngx_http_mp4_module.c - nginx-1.7.10

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_MDIA_ATOM     2
  15. ‌#define NGX_HTTP_MP4_MDHD_ATOM     3
  16. ‌#define NGX_HTTP_MP4_HDLR_ATOM     4
  17. ‌#define NGX_HTTP_MP4_MINF_ATOM     5
  18. ‌#define NGX_HTTP_MP4_VMHD_ATOM     6
  19. ‌#define NGX_HTTP_MP4_SMHD_ATOM     7
  20. ‌#define NGX_HTTP_MP4_DINF_ATOM     8
  21. ‌#define NGX_HTTP_MP4_STBL_ATOM     9
  22. ‌#define NGX_HTTP_MP4_STSD_ATOM    10
  23. ‌#define NGX_HTTP_MP4_STTS_ATOM    11
  24. ‌#define NGX_HTTP_MP4_STTS_DATA    12
  25. ‌#define NGX_HTTP_MP4_STSS_ATOM    13
  26. ‌#define NGX_HTTP_MP4_STSS_DATA    14
  27. ‌#define NGX_HTTP_MP4_CTTS_ATOM    15
  28. ‌#define NGX_HTTP_MP4_CTTS_DATA    16
  29. ‌#define NGX_HTTP_MP4_STSC_ATOM    17
  30. ‌#define NGX_HTTP_MP4_STSC_START   18
  31. ‌#define NGX_HTTP_MP4_STSC_DATA    19
  32. ‌#define NGX_HTTP_MP4_STSC_END     20
  33. ‌#define NGX_HTTP_MP4_STSZ_ATOM    21
  34. ‌#define NGX_HTTP_MP4_STSZ_DATA    22
  35. ‌#define NGX_HTTP_MP4_STCO_ATOM    23
  36. ‌#define NGX_HTTP_MP4_STCO_DATA    24
  37. ‌#define NGX_HTTP_MP4_CO64_ATOM    25
  38. ‌#define NGX_HTTP_MP4_CO64_DATA    26

  40. ‌#define NGX_HTTP_MP4_LAST_ATOM    NGX_HTTP_MP4_CO64_DATA


  43. typedef struct {
  44.     size_t                buffer_size;
  45.     size_t                max_buffer_size;
  46. ‌} ngx_http_mp4_conf_t;


  49. typedef struct {
  50.     u_char                chunk[4];
  51.     u_char                samples[4];
  52.     u_char                id[4];
  53. ‌} ngx_mp4_stsc_entry_t;


  56. typedef struct {
  57.     uint32_t              timescale;
  58.     uint32_t              time_to_sample_entries;
  59.     uint32_t              sample_to_chunk_entries;
  60.     uint32_t              sync_samples_entries;
  61.     uint32_t              composition_offset_entries;
  62.     uint32_t              sample_sizes_entries;
  63.     uint32_t              chunks;

  65.     ngx_uint_t            start_sample;
  66.     ngx_uint_t            end_sample;
  67.     ngx_uint_t            start_chunk;
  68.     ngx_uint_t            end_chunk;
  69.     ngx_uint_t            start_chunk_samples;
  70.     ngx_uint_t            end_chunk_samples;
  71.     uint64_t              start_chunk_samples_size;
  72.     uint64_t              end_chunk_samples_size;
  73.     off_t                 start_offset;
  74.     off_t                 end_offset;

  76.     size_t                tkhd_size;
  77.     size_t                mdhd_size;
  78.     size_t                hdlr_size;
  79.     size_t                vmhd_size;
  80.     size_t                smhd_size;
  81.     size_t                dinf_size;
  82.     size_t                size;

  84.     ngx_chain_t           out[NGX_HTTP_MP4_LAST_ATOM + 1];

  86.     ngx_buf_t             trak_atom_buf;
  87.     ngx_buf_t             tkhd_atom_buf;
  88.     ngx_buf_t             mdia_atom_buf;
  89.     ngx_buf_t             mdhd_atom_buf;
  90.     ngx_buf_t             hdlr_atom_buf;
  91.     ngx_buf_t             minf_atom_buf;
  92.     ngx_buf_t             vmhd_atom_buf;
  93.     ngx_buf_t             smhd_atom_buf;
  94.     ngx_buf_t             dinf_atom_buf;
  95.     ngx_buf_t             stbl_atom_buf;
  96.     ngx_buf_t             stsd_atom_buf;
  97.     ngx_buf_t             stts_atom_buf;
  98.     ngx_buf_t             stts_data_buf;
  99.     ngx_buf_t             stss_atom_buf;
  100.     ngx_buf_t             stss_data_buf;
  101.     ngx_buf_t             ctts_atom_buf;
  102.     ngx_buf_t             ctts_data_buf;
  103.     ngx_buf_t             stsc_atom_buf;
  104.     ngx_buf_t             stsc_start_chunk_buf;
  105.     ngx_buf_t             stsc_end_chunk_buf;
  106.     ngx_buf_t             stsc_data_buf;
  107.     ngx_buf_t             stsz_atom_buf;
  108.     ngx_buf_t             stsz_data_buf;
  109.     ngx_buf_t             stco_atom_buf;
  110.     ngx_buf_t             stco_data_buf;
  111.     ngx_buf_t             co64_atom_buf;
  112.     ngx_buf_t             co64_data_buf;

  114.     ngx_mp4_stsc_entry_t  stsc_start_chunk_entry;
  115.     ngx_mp4_stsc_entry_t  stsc_end_chunk_entry;
  116. ‌} ngx_http_mp4_trak_t;


  119. typedef struct {
  120.     ngx_file_t            file;

  122.     u_char               *buffer;
  123.     u_char               *buffer_start;
  124.     u_char               *buffer_pos;
  125.     u_char               *buffer_end;
  126.     size_t                buffer_size;

  128.     off_t                 offset;
  129.     off_t                 end;
  130.     off_t                 content_length;
  131.     ngx_uint_t            start;
  132.     ngx_uint_t            length;
  133.     uint32_t              timescale;
  134.     ngx_http_request_t   *request;
  135.     ngx_array_t           trak;
  136.     ngx_http_mp4_trak_t   traks[2];

  138.     size_t                ftyp_size;
  139.     size_t                moov_size;

  141.     ngx_chain_t          *out;
  142.     ngx_chain_t           ftyp_atom;
  143.     ngx_chain_t           moov_atom;
  144.     ngx_chain_t           mvhd_atom;
  145.     ngx_chain_t           mdat_atom;
  146.     ngx_chain_t           mdat_data;

  148.     ngx_buf_t             ftyp_atom_buf;
  149.     ngx_buf_t             moov_atom_buf;
  150.     ngx_buf_t             mvhd_atom_buf;
  151.     ngx_buf_t             mdat_atom_buf;
  152.     ngx_buf_t             mdat_data_buf;

  154.     u_char                moov_atom_header[8];
  155.     u_char                mdat_atom_header[16];
  156. ‌} ngx_http_mp4_file_t;


  159. typedef struct {
  160.     char                 *name;
  161.     ngx_int_t           (*handler)(ngx_http_mp4_file_t *mp4,
  162.                                    uint64_t atom_data_size);
  163. ‌} ngx_http_mp4_atom_handler_t;


  166. ‌#define ngx_mp4_atom_header(mp4)   (mp4->buffer_pos - 8)
  167. ‌#define ngx_mp4_atom_data(mp4)     mp4->buffer_pos
  168. ‌#define ngx_mp4_atom_data_size(t)  (uint64_t) (sizeof(t) - 8)


  171. ‌#define ngx_mp4_atom_next(mp4, n)                                             \
  172.     mp4->buffer_pos += (size_t) n;                                            \
  173.     mp4->offset += n


  176. ‌#define ngx_mp4_set_atom_name(p, n1, n2, n3, n4)                              \
  177.     ((u_char *) (p))[4] = n1;                                                 \
  178.     ((u_char *) (p))[5] = n2;                                                 \
  179.     ((u_char *) (p))[6] = n3;                                                 \
  180.     ((u_char *) (p))[7] = n4

  182. ‌#define ngx_mp4_get_32value(p)                                                \
  183.     ( ((uint32_t) ((u_char *) (p))[0] << 24)                                  \
  184.     + (           ((u_char *) (p))[1] << 16)                                  \
  185.     + (           ((u_char *) (p))[2] << 8)                                   \
  186.     + (           ((u_char *) (p))[3]) )

  188. ‌#define ngx_mp4_set_32value(p, n)                                             \
  189.     ((u_char *) (p))[0] = (u_char) ((n) >> 24);                               \
  190.     ((u_char *) (p))[1] = (u_char) ((n) >> 16);                               \
  191.     ((u_char *) (p))[2] = (u_char) ((n) >> 8);                                \
  192.     ((u_char *) (p))[3] = (u_char)  (n)

  194. ‌#define ngx_mp4_get_64value(p)                                                \
  195.     ( ((uint64_t) ((u_char *) (p))[0] << 56)                                  \
  196.     + ((uint64_t) ((u_char *) (p))[1] << 48)                                  \
  197.     + ((uint64_t) ((u_char *) (p))[2] << 40)                                  \
  198.     + ((uint64_t) ((u_char *) (p))[3] << 32)                                  \
  199.     + ((uint64_t) ((u_char *) (p))[4] << 24)                                  \
  200.     + (           ((u_char *) (p))[5] << 16)                                  \
  201.     + (           ((u_char *) (p))[6] << 8)                                   \
  202.     + (           ((u_char *) (p))[7]) )

  204. ‌#define ngx_mp4_set_64value(p, n)                                             \
  205.     ((u_char *) (p))[0] = (u_char) ((uint64_t) (n) >> 56);                    \
  206.     ((u_char *) (p))[1] = (u_char) ((uint64_t) (n) >> 48);                    \
  207.     ((u_char *) (p))[2] = (u_char) ((uint64_t) (n) >> 40);                    \
  208.     ((u_char *) (p))[3] = (u_char) ((uint64_t) (n) >> 32);                    \
  209.     ((u_char *) (p))[4] = (u_char) (           (n) >> 24);                    \
  210.     ((u_char *) (p))[5] = (u_char) (           (n) >> 16);                    \
  211.     ((u_char *) (p))[6] = (u_char) (           (n) >> 8);                     \
  212.     ((u_char *) (p))[7] = (u_char)             (n)

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


  218. static ngx_int_t ngx_http_mp4_handler(ngx_http_request_t *r);

  220. static ngx_int_t ngx_http_mp4_process(ngx_http_mp4_file_t *mp4);
  221. static ngx_int_t ngx_http_mp4_read_atom(ngx_http_mp4_file_t *mp4,
  222.     ngx_http_mp4_atom_handler_t *atom, uint64_t atom_data_size);
  223. static ngx_int_t ngx_http_mp4_read(ngx_http_mp4_file_t *mp4, size_t size);
  224. static ngx_int_t ngx_http_mp4_read_ftyp_atom(ngx_http_mp4_file_t *mp4,
  225.     uint64_t atom_data_size);
  226. static ngx_int_t ngx_http_mp4_read_moov_atom(ngx_http_mp4_file_t *mp4,
  227.     uint64_t atom_data_size);
  228. static ngx_int_t ngx_http_mp4_read_mdat_atom(ngx_http_mp4_file_t *mp4,
  229.     uint64_t atom_data_size);
  230. static size_t ngx_http_mp4_update_mdat_atom(ngx_http_mp4_file_t *mp4,
  231.     off_t start_offset, off_t end_offset);
  232. static ngx_int_t ngx_http_mp4_read_mvhd_atom(ngx_http_mp4_file_t *mp4,
  233.     uint64_t atom_data_size);
  234. static ngx_int_t ngx_http_mp4_read_trak_atom(ngx_http_mp4_file_t *mp4,
  235.     uint64_t atom_data_size);
  236. static void ngx_http_mp4_update_trak_atom(ngx_http_mp4_file_t *mp4,
  237.     ngx_http_mp4_trak_t *trak);
  238. static ngx_int_t ngx_http_mp4_read_cmov_atom(ngx_http_mp4_file_t *mp4,
  239.     uint64_t atom_data_size);
  240. static ngx_int_t ngx_http_mp4_read_tkhd_atom(ngx_http_mp4_file_t *mp4,
  241.     uint64_t atom_data_size);
  242. static ngx_int_t ngx_http_mp4_read_mdia_atom(ngx_http_mp4_file_t *mp4,
  243.     uint64_t atom_data_size);
  244. static void ngx_http_mp4_update_mdia_atom(ngx_http_mp4_file_t *mp4,
  245.     ngx_http_mp4_trak_t *trak);
  246. static ngx_int_t ngx_http_mp4_read_mdhd_atom(ngx_http_mp4_file_t *mp4,
  247.     uint64_t atom_data_size);
  248. static ngx_int_t ngx_http_mp4_read_hdlr_atom(ngx_http_mp4_file_t *mp4,
  249.     uint64_t atom_data_size);
  250. static ngx_int_t ngx_http_mp4_read_minf_atom(ngx_http_mp4_file_t *mp4,
  251.     uint64_t atom_data_size);
  252. static void ngx_http_mp4_update_minf_atom(ngx_http_mp4_file_t *mp4,
  253.     ngx_http_mp4_trak_t *trak);
  254. static ngx_int_t ngx_http_mp4_read_dinf_atom(ngx_http_mp4_file_t *mp4,
  255.     uint64_t atom_data_size);
  256. static ngx_int_t ngx_http_mp4_read_vmhd_atom(ngx_http_mp4_file_t *mp4,
  257.     uint64_t atom_data_size);
  258. static ngx_int_t ngx_http_mp4_read_smhd_atom(ngx_http_mp4_file_t *mp4,
  259.     uint64_t atom_data_size);
  260. static ngx_int_t ngx_http_mp4_read_stbl_atom(ngx_http_mp4_file_t *mp4,
  261.     uint64_t atom_data_size);
  262. static void ngx_http_mp4_update_stbl_atom(ngx_http_mp4_file_t *mp4,
  263.     ngx_http_mp4_trak_t *trak);
  264. static ngx_int_t ngx_http_mp4_read_stsd_atom(ngx_http_mp4_file_t *mp4,
  265.     uint64_t atom_data_size);
  266. static ngx_int_t ngx_http_mp4_read_stts_atom(ngx_http_mp4_file_t *mp4,
  267.     uint64_t atom_data_size);
  268. static ngx_int_t ngx_http_mp4_update_stts_atom(ngx_http_mp4_file_t *mp4,
  269.     ngx_http_mp4_trak_t *trak);
  270. static ngx_int_t ngx_http_mp4_crop_stts_data(ngx_http_mp4_file_t *mp4,
  271.     ngx_http_mp4_trak_t *trak, ngx_uint_t start);
  272. static ngx_int_t ngx_http_mp4_read_stss_atom(ngx_http_mp4_file_t *mp4,
  273.     uint64_t atom_data_size);
  274. static ngx_int_t ngx_http_mp4_update_stss_atom(ngx_http_mp4_file_t *mp4,
  275.     ngx_http_mp4_trak_t *trak);
  276. static void ngx_http_mp4_crop_stss_data(ngx_http_mp4_file_t *mp4,
  277.     ngx_http_mp4_trak_t *trak, ngx_uint_t start);
  278. static ngx_int_t ngx_http_mp4_read_ctts_atom(ngx_http_mp4_file_t *mp4,
  279.     uint64_t atom_data_size);
  280. static void ngx_http_mp4_update_ctts_atom(ngx_http_mp4_file_t *mp4,
  281.     ngx_http_mp4_trak_t *trak);
  282. static void ngx_http_mp4_crop_ctts_data(ngx_http_mp4_file_t *mp4,
  283.     ngx_http_mp4_trak_t *trak, ngx_uint_t start);
  284. static ngx_int_t ngx_http_mp4_read_stsc_atom(ngx_http_mp4_file_t *mp4,
  285.     uint64_t atom_data_size);
  286. static ngx_int_t ngx_http_mp4_update_stsc_atom(ngx_http_mp4_file_t *mp4,
  287.     ngx_http_mp4_trak_t *trak);
  288. static ngx_int_t ngx_http_mp4_crop_stsc_data(ngx_http_mp4_file_t *mp4,
  289.     ngx_http_mp4_trak_t *trak, ngx_uint_t start);
  290. static ngx_int_t ngx_http_mp4_read_stsz_atom(ngx_http_mp4_file_t *mp4,
  291.     uint64_t atom_data_size);
  292. static ngx_int_t ngx_http_mp4_update_stsz_atom(ngx_http_mp4_file_t *mp4,
  293.     ngx_http_mp4_trak_t *trak);
  294. static ngx_int_t ngx_http_mp4_read_stco_atom(ngx_http_mp4_file_t *mp4,
  295.     uint64_t atom_data_size);
  296. static ngx_int_t ngx_http_mp4_update_stco_atom(ngx_http_mp4_file_t *mp4,
  297.     ngx_http_mp4_trak_t *trak);
  298. static void ngx_http_mp4_adjust_stco_atom(ngx_http_mp4_file_t *mp4,
  299.     ngx_http_mp4_trak_t *trak, int32_t adjustment);
  300. static ngx_int_t ngx_http_mp4_read_co64_atom(ngx_http_mp4_file_t *mp4,
  301.     uint64_t atom_data_size);
  302. static ngx_int_t ngx_http_mp4_update_co64_atom(ngx_http_mp4_file_t *mp4,
  303.     ngx_http_mp4_trak_t *trak);
  304. static void ngx_http_mp4_adjust_co64_atom(ngx_http_mp4_file_t *mp4,
  305.     ngx_http_mp4_trak_t *trak, off_t adjustment);

  307. static char *ngx_http_mp4(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  308. static void *ngx_http_mp4_create_conf(ngx_conf_t *cf);
  309. static char *ngx_http_mp4_merge_conf(ngx_conf_t *cf, void *parent, void *child);


  312. ‌static ngx_command_t  ngx_http_mp4_commands[] = {

  314.     { ngx_string("mp4"),
  315.       NGX_HTTP_LOC_CONF|NGX_CONF_NOARGS,
  316.       ngx_http_mp4,
  317.       0,
  318.       0,
  319.       NULL },

  321.     { ngx_string("mp4_buffer_size"),
  322.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  323.       ngx_conf_set_size_slot,
  324.       NGX_HTTP_LOC_CONF_OFFSET,
  325.       offsetof(ngx_http_mp4_conf_t, buffer_size),
  326.       NULL },

  328.     { ngx_string("mp4_max_buffer_size"),
  329.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  330.       ngx_conf_set_size_slot,
  331.       NGX_HTTP_LOC_CONF_OFFSET,
  332.       offsetof(ngx_http_mp4_conf_t, max_buffer_size),
  333.       NULL },

  335.       ngx_null_command
  336. };


  339. ‌static ngx_http_module_t  ngx_http_mp4_module_ctx = {
  340.     NULL,                          /* preconfiguration */
  341.     NULL,                          /* postconfiguration */

  343.     NULL,                          /* create main configuration */
  344.     NULL,                          /* init main configuration */

  346.     NULL,                          /* create server configuration */
  347.     NULL,                          /* merge server configuration */

  349.     ngx_http_mp4_create_conf,      /* create location configuration */
  350.     ngx_http_mp4_merge_conf        /* merge location configuration */
  351. };


  354. ‌ngx_module_t  ngx_http_mp4_module = {
  355.     NGX_MODULE_V1,
  356.     &ngx_http_mp4_module_ctx,      /* module context */
  357.     ngx_http_mp4_commands,         /* module directives */
  358.     NGX_HTTP_MODULE,               /* module type */
  359.     NULL,                          /* init master */
  360.     NULL,                          /* init module */
  361.     NULL,                          /* init process */
  362.     NULL,                          /* init thread */
  363.     NULL,                          /* exit thread */
  364.     NULL,                          /* exit process */
  365.     NULL,                          /* exit master */
  366.     NGX_MODULE_V1_PADDING
  367. };


  370. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_atoms[] = {
  371.     { "ftyp", ngx_http_mp4_read_ftyp_atom },
  372.     { "moov", ngx_http_mp4_read_moov_atom },
  373.     { "mdat", ngx_http_mp4_read_mdat_atom },
  374.     { NULL, NULL }
  375. };

  377. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_moov_atoms[] = {
  378.     { "mvhd", ngx_http_mp4_read_mvhd_atom },
  379.     { "trak", ngx_http_mp4_read_trak_atom },
  380.     { "cmov", ngx_http_mp4_read_cmov_atom },
  381.     { NULL, NULL }
  382. };

  384. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_trak_atoms[] = {
  385.     { "tkhd", ngx_http_mp4_read_tkhd_atom },
  386.     { "mdia", ngx_http_mp4_read_mdia_atom },
  387.     { NULL, NULL }
  388. };

  390. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_mdia_atoms[] = {
  391.     { "mdhd", ngx_http_mp4_read_mdhd_atom },
  392.     { "hdlr", ngx_http_mp4_read_hdlr_atom },
  393.     { "minf", ngx_http_mp4_read_minf_atom },
  394.     { NULL, NULL }
  395. };

  397. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_minf_atoms[] = {
  398.     { "vmhd", ngx_http_mp4_read_vmhd_atom },
  399.     { "smhd", ngx_http_mp4_read_smhd_atom },
  400.     { "dinf", ngx_http_mp4_read_dinf_atom },
  401.     { "stbl", ngx_http_mp4_read_stbl_atom },
  402.     { NULL, NULL }
  403. };

  405. ‌static ngx_http_mp4_atom_handler_t  ngx_http_mp4_stbl_atoms[] = {
  406.     { "stsd", ngx_http_mp4_read_stsd_atom },
  407.     { "stts", ngx_http_mp4_read_stts_atom },
  408.     { "stss", ngx_http_mp4_read_stss_atom },
  409.     { "ctts", ngx_http_mp4_read_ctts_atom },
  410.     { "stsc", ngx_http_mp4_read_stsc_atom },
  411.     { "stsz", ngx_http_mp4_read_stsz_atom },
  412.     { "stco", ngx_http_mp4_read_stco_atom },
  413.     { "co64", ngx_http_mp4_read_co64_atom },
  414.     { NULL, NULL }
  415. };


  418. static ngx_int_t
  419. ‌ngx_http_mp4_handler(ngx_http_request_t *r)
  420. {
  421.     u_char                    *last;
  422.     size_t                     root;
  423.     ngx_int_t                  rc, start, end;
  424.     ngx_uint_t                 level, length;
  425.     ngx_str_t                  path, value;
  426.     ngx_log_t                 *log;
  427.     ngx_buf_t                 *b;
  428.     ngx_chain_t                out;
  429.     ngx_http_mp4_file_t       *mp4;
  430.     ngx_open_file_info_t       of;
  431.     ngx_http_core_loc_conf_t  *clcf;

  433.     if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD))) {
  434.         return NGX_HTTP_NOT_ALLOWED;
  435.     }

  437.     if (r->uri.data[r->uri.len - 1] == '/') {
  438.         return NGX_DECLINED;
  439.     }

  441.     rc = ngx_http_discard_request_body(r);

  443.     if (rc != NGX_OK) {
  444.         return rc;
  445.     }

  447.     last = ngx_http_map_uri_to_path(r, &path, &root, 0);
  448.     if (last == NULL) {
  449.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  450.     }

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

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

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

  459.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  463.     of.read_ahead = clcf->read_ahead;
  464.     of.directio = NGX_MAX_OFF_T_VALUE;
  465.     of.valid = clcf->open_file_cache_valid;
  466.     of.min_uses = clcf->open_file_cache_min_uses;
  467.     of.errors = clcf->open_file_cache_errors;
  468.     of.events = clcf->open_file_cache_events;

  470.     if (ngx_http_set_disable_symlinks(r, clcf, &path, &of) != NGX_OK) {
  471.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  472.     }

  474.     if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
  475.         != NGX_OK)
  476.     {
  477.         switch (of.err) {

  479.         case 0:
  480.             return NGX_HTTP_INTERNAL_SERVER_ERROR;

  482.         case NGX_ENOENT:
  483.         case NGX_ENOTDIR:
  484.         case NGX_ENAMETOOLONG:

  486.             level = NGX_LOG_ERR;
  487.             rc = NGX_HTTP_NOT_FOUND;
  488.             break;

  490.         case NGX_EACCES:
  491. #if (NGX_HAVE_OPENAT)
  492.         case NGX_EMLINK:
  493.         case NGX_ELOOP:
  494. #endif

  496.             level = NGX_LOG_ERR;
  497.             rc = NGX_HTTP_FORBIDDEN;
  498.             break;

  500.         default:

  502.             level = NGX_LOG_CRIT;
  503.             rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  504.             break;
  505.         }

  507.         if (rc != NGX_HTTP_NOT_FOUND || clcf->log_not_found) {
  508.             ngx_log_error(level, log, of.err,
  509.                           "%s \"%s\" failed", of.failed, path.data);
  510.         }

  512.         return rc;
  513.     }

  515.     if (!of.is_file) {

  517.         if (ngx_close_file(of.fd) == NGX_FILE_ERROR) {
  518.             ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
  519.                           ngx_close_file_n " \"%s\" failed", path.data);
  520.         }

  522.         return NGX_DECLINED;
  523.     }

  525.     r->root_tested = !r->error_page;
  526.     r->allow_ranges = 1;

  528.     start = -1;
  529.     length = 0;
  530.     r->headers_out.content_length_n = of.size;
  531.     mp4 = NULL;
  532.     b = NULL;

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

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

  538.             /*
  539.              * A Flash player may send start value with a lot of digits
  540.              * after dot so strtod() is used instead of atofp().  NaNs and
  541.              * infinities become negative numbers after (int) conversion.
  542.              */

  544.             ngx_set_errno(0);
  545.             start = (int) (strtod((char *) value.data, NULL) * 1000);

  547.             if (ngx_errno != 0) {
  548.                 start = -1;
  549.             }
  550.         }

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

  554.             ngx_set_errno(0);
  555.             end = (int) (strtod((char *) value.data, NULL) * 1000);

  557.             if (ngx_errno != 0) {
  558.                 end = -1;
  559.             }

  561.             if (end > 0) {
  562.                 if (start < 0) {
  563.                     start = 0;
  564.                 }

  566.                 if (end > start) {
  567.                     length = end - start;
  568.                 }
  569.             }
  570.         }
  571.     }

  573.     if (start >= 0) {
  574.         r->single_range = 1;

  576.         mp4 = ngx_pcalloc(r->pool, sizeof(ngx_http_mp4_file_t));
  577.         if (mp4 == NULL) {
  578.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  579.         }

  581.         mp4->file.fd = of.fd;
  582.         mp4->file.name = path;
  583.         mp4->file.log = r->connection->log;
  584.         mp4->end = of.size;
  585.         mp4->start = (ngx_uint_t) start;
  586.         mp4->length = length;
  587.         mp4->request = r;

  589.         switch (ngx_http_mp4_process(mp4)) {

  591.         case NGX_DECLINED:
  592.             if (mp4->buffer) {
  593.                 ngx_pfree(r->pool, mp4->buffer);
  594.             }

  596.             ngx_pfree(r->pool, mp4);
  597.             mp4 = NULL;

  599.             break;

  601.         case NGX_OK:
  602.             r->headers_out.content_length_n = mp4->content_length;
  603.             break;

  605.         default: /* NGX_ERROR */
  606.             if (mp4->buffer) {
  607.                 ngx_pfree(r->pool, mp4->buffer);
  608.             }

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

  612.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  613.         }
  614.     }

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

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

  620.         /*
  621.          * DIRECTIO is set on transfer only
  622.          * to allow kernel to cache "moov" atom
  623.          */

  625.         if (ngx_directio_on(of.fd) == NGX_FILE_ERROR) {
  626.             ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
  627.                           ngx_directio_on_n " \"%s\" failed", path.data);
  628.         }

  630.         of.is_directio = 1;

  632.         if (mp4) {
  633.             mp4->file.directio = 1;
  634.         }
  635.     }

  637.     r->headers_out.status = NGX_HTTP_OK;
  638.     r->headers_out.last_modified_time = of.mtime;

  640.     if (ngx_http_set_etag(r) != NGX_OK) {
  641.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  642.     }

  644.     if (ngx_http_set_content_type(r) != NGX_OK) {
  645.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  646.     }

  648.     if (mp4 == NULL) {
  649.         b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
  650.         if (b == NULL) {
  651.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  652.         }

  654.         b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
  655.         if (b->file == NULL) {
  656.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  657.         }
  658.     }

  660.     rc = ngx_http_send_header(r);

  662.     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  663.         return rc;
  664.     }

  666.     if (mp4) {
  667.         return ngx_http_output_filter(r, mp4->out);
  668.     }

  670.     b->file_pos = 0;
  671.     b->file_last = of.size;

  673.     b->in_file = b->file_last ? 1 : 0;
  674.     b->last_buf = (r == r->main) ? 1 : 0;
  675.     b->last_in_chain = 1;

  677.     b->file->fd = of.fd;
  678.     b->file->name = path;
  679.     b->file->log = log;
  680.     b->file->directio = of.is_directio;

  682.     out.buf = b;
  683.     out.next = NULL;

  685.     return ngx_http_output_filter(r, &out);
  686. }


  689. static ngx_int_t
  690. ‌ngx_http_mp4_process(ngx_http_mp4_file_t *mp4)
  691. {
  692.     off_t                  start_offset, end_offset, adjustment;
  693.     ngx_int_t              rc;
  694.     ngx_uint_t             i, j;
  695.     ngx_chain_t          **prev;
  696.     ngx_http_mp4_trak_t   *trak;
  697.     ngx_http_mp4_conf_t   *conf;

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

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

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

  706.     rc = ngx_http_mp4_read_atom(mp4, ngx_http_mp4_atoms, mp4->end);
  707.     if (rc != NGX_OK) {
  708.         return rc;
  709.     }

  711.     if (mp4->trak.nelts == 0) {
  712.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  713.                       "no mp4 trak atoms were found in \"%s\"",
  714.                       mp4->file.name.data);
  715.         return NGX_ERROR;
  716.     }

  718.     if (mp4->mdat_atom.buf == NULL) {
  719.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  720.                       "no mp4 mdat atom was found in \"%s\"",
  721.                       mp4->file.name.data);
  722.         return NGX_ERROR;
  723.     }

  725.     prev = &mp4->out;

  727.     if (mp4->ftyp_atom.buf) {
  728.         *prev = &mp4->ftyp_atom;
  729.         prev = &mp4->ftyp_atom.next;
  730.     }

  732.     *prev = &mp4->moov_atom;
  733.     prev = &mp4->moov_atom.next;

  735.     if (mp4->mvhd_atom.buf) {
  736.         mp4->moov_size += mp4->mvhd_atom_buf.last - mp4->mvhd_atom_buf.pos;
  737.         *prev = &mp4->mvhd_atom;
  738.         prev = &mp4->mvhd_atom.next;
  739.     }

  741.     start_offset = mp4->end;
  742.     end_offset = 0;
  743.     trak = mp4->trak.elts;

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

  747.         if (ngx_http_mp4_update_stts_atom(mp4, &trak[i]) != NGX_OK) {
  748.             return NGX_ERROR;
  749.         }

  751.         if (ngx_http_mp4_update_stss_atom(mp4, &trak[i]) != NGX_OK) {
  752.             return NGX_ERROR;
  753.         }

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

  757.         if (ngx_http_mp4_update_stsc_atom(mp4, &trak[i]) != NGX_OK) {
  758.             return NGX_ERROR;
  759.         }

  761.         if (ngx_http_mp4_update_stsz_atom(mp4, &trak[i]) != NGX_OK) {
  762.             return NGX_ERROR;
  763.         }

  765.         if (trak[i].out[NGX_HTTP_MP4_CO64_DATA].buf) {
  766.             if (ngx_http_mp4_update_co64_atom(mp4, &trak[i]) != NGX_OK) {
  767.                 return NGX_ERROR;
  768.             }

  770.         } else {
  771.             if (ngx_http_mp4_update_stco_atom(mp4, &trak[i]) != NGX_OK) {
  772.                 return NGX_ERROR;
  773.             }
  774.         }

  776.         ngx_http_mp4_update_stbl_atom(mp4, &trak[i]);
  777.         ngx_http_mp4_update_minf_atom(mp4, &trak[i]);
  778.         trak[i].size += trak[i].mdhd_size;
  779.         trak[i].size += trak[i].hdlr_size;
  780.         ngx_http_mp4_update_mdia_atom(mp4, &trak[i]);
  781.         trak[i].size += trak[i].tkhd_size;
  782.         ngx_http_mp4_update_trak_atom(mp4, &trak[i]);

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

  786.         if (start_offset > trak[i].start_offset) {
  787.             start_offset = trak[i].start_offset;
  788.         }

  790.         if (end_offset < trak[i].end_offset) {
  791.             end_offset = trak[i].end_offset;
  792.         }

  794.         *prev = &trak[i].out[NGX_HTTP_MP4_TRAK_ATOM];
  795.         prev = &trak[i].out[NGX_HTTP_MP4_TRAK_ATOM].next;

  797.         for (j = 0; j < NGX_HTTP_MP4_LAST_ATOM + 1; j++) {
  798.             if (trak[i].out[j].buf) {
  799.                 *prev = &trak[i].out[j];
  800.                 prev = &trak[i].out[j].next;
  801.             }
  802.         }
  803.     }

  805.     if (end_offset < start_offset) {
  806.         end_offset = start_offset;
  807.     }

  809.     mp4->moov_size += 8;

  811.     ngx_mp4_set_32value(mp4->moov_atom_header, mp4->moov_size);
  812.     ngx_mp4_set_atom_name(mp4->moov_atom_header, 'm', 'o', 'o', 'v');
  813.     mp4->content_length += mp4->moov_size;

  815.     *prev = &mp4->mdat_atom;

  817.     if (start_offset > mp4->mdat_data.buf->file_last) {
  818.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  819.                       "start time is out mp4 mdat atom in \"%s\"",
  820.                       mp4->file.name.data);
  821.         return NGX_ERROR;
  822.     }

  824.     adjustment = mp4->ftyp_size + mp4->moov_size
  825.                  + ngx_http_mp4_update_mdat_atom(mp4, start_offset, end_offset)
  826.                  - start_offset;

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

  831.     for (i = 0; i < mp4->trak.nelts; i++) {
  832.         if (trak[i].out[NGX_HTTP_MP4_CO64_DATA].buf) {
  833.             ngx_http_mp4_adjust_co64_atom(mp4, &trak[i], adjustment);
  834.         } else {
  835.             ngx_http_mp4_adjust_stco_atom(mp4, &trak[i], (int32_t) adjustment);
  836.         }
  837.     }

  839.     return NGX_OK;
  840. }


  843. typedef struct {
  844.     u_char    size[4];
  845.     u_char    name[4];
  846. ‌} ngx_mp4_atom_header_t;

  848. typedef struct {
  849.     u_char    size[4];
  850.     u_char    name[4];
  851.     u_char    size64[8];
  852. ‌} ngx_mp4_atom_header64_t;


  855. static ngx_int_t
  856. ‌ngx_http_mp4_read_atom(ngx_http_mp4_file_t *mp4,
  857.     ngx_http_mp4_atom_handler_t *atom, uint64_t atom_data_size)
  858. {
  859.     off_t        end;
  860.     size_t       atom_header_size;
  861.     u_char      *atom_header, *atom_name;
  862.     uint64_t     atom_size;
  863.     ngx_int_t    rc;
  864.     ngx_uint_t   n;

  866.     end = mp4->offset + atom_data_size;

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

  870.         if (ngx_http_mp4_read(mp4, sizeof(uint32_t)) != NGX_OK) {
  871.             return NGX_ERROR;
  872.         }

  874.         atom_header = mp4->buffer_pos;
  875.         atom_size = ngx_mp4_get_32value(atom_header);
  876.         atom_header_size = sizeof(ngx_mp4_atom_header_t);

  878.         if (atom_size == 0) {
  879.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  880.                            "mp4 atom end");
  881.             return NGX_OK;
  882.         }

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

  886.             if (atom_size == 1) {

  888.                 if (ngx_http_mp4_read(mp4, sizeof(ngx_mp4_atom_header64_t))
  889.                     != NGX_OK)
  890.                 {
  891.                     return NGX_ERROR;
  892.                 }

  894.                 /* 64-bit atom size */
  895.                 atom_header = mp4->buffer_pos;
  896.                 atom_size = ngx_mp4_get_64value(atom_header + 8);
  897.                 atom_header_size = sizeof(ngx_mp4_atom_header64_t);

  899.             } else {
  900.                 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  901.                               "\"%s\" mp4 atom is too small:%uL",
  902.                               mp4->file.name.data, atom_size);
  903.                 return NGX_ERROR;
  904.             }
  905.         }

  907.         if (ngx_http_mp4_read(mp4, sizeof(ngx_mp4_atom_header_t)) != NGX_OK) {
  908.             return NGX_ERROR;
  909.         }

  911.         atom_header = mp4->buffer_pos;
  912.         atom_name = atom_header + sizeof(uint32_t);

  914.         ngx_log_debug4(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  915.                        "mp4 atom: %*s @%O:%uL",
  916.                        4, atom_name, mp4->offset, atom_size);

  918.         if (atom_size > (uint64_t) (NGX_MAX_OFF_T_VALUE - mp4->offset)
  919.             || mp4->offset + (off_t) atom_size > end)
  920.         {
  921.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  922.                           "\"%s\" mp4 atom too large:%uL",
  923.                           mp4->file.name.data, atom_size);
  924.             return NGX_ERROR;
  925.         }

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

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

  931.                 ngx_mp4_atom_next(mp4, atom_header_size);

  933.                 rc = atom[n].handler(mp4, atom_size - atom_header_size);
  934.                 if (rc != NGX_OK) {
  935.                     return rc;
  936.                 }

  938.                 goto next;
  939.             }
  940.         }

  942.         ngx_mp4_atom_next(mp4, atom_size);

  944.     next:
  945.         continue;
  946.     }

  948.     return NGX_OK;
  949. }


  952. static ngx_int_t
  953. ‌ngx_http_mp4_read(ngx_http_mp4_file_t *mp4, size_t size)
  954. {
  955.     ssize_t  n;

  957.     if (mp4->buffer_pos + size <= mp4->buffer_end) {
  958.         return NGX_OK;
  959.     }

  961.     if (mp4->offset + (off_t) mp4->buffer_size > mp4->end) {
  962.         mp4->buffer_size = (size_t) (mp4->end - mp4->offset);
  963.     }

  965.     if (mp4->buffer_size < size) {
  966.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  967.                       "\"%s\" mp4 file truncated", mp4->file.name.data);
  968.         return NGX_ERROR;
  969.     }

  971.     if (mp4->buffer == NULL) {
  972.         mp4->buffer = ngx_palloc(mp4->request->pool, mp4->buffer_size);
  973.         if (mp4->buffer == NULL) {
  974.             return NGX_ERROR;
  975.         }

  977.         mp4->buffer_start = mp4->buffer;
  978.     }

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

  983.     if (n == NGX_ERROR) {
  984.         return NGX_ERROR;
  985.     }

  987.     if ((size_t) n != mp4->buffer_size) {
  988.         ngx_log_error(NGX_LOG_CRIT, mp4->file.log, 0,
  989.                       ngx_read_file_n " read only %z of %z from \"%s\"",
  990.                       n, mp4->buffer_size, mp4->file.name.data);
  991.         return NGX_ERROR;
  992.     }

  994.     mp4->buffer_pos = mp4->buffer_start;
  995.     mp4->buffer_end = mp4->buffer_start + mp4->buffer_size;

  997.     return NGX_OK;
  998. }


  1001. static ngx_int_t
  1002. ‌ngx_http_mp4_read_ftyp_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1003. {
  1004.     u_char     *ftyp_atom;
  1005.     size_t      atom_size;
  1006.     ngx_buf_t  *atom;

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

  1010.     if (atom_data_size > 1024
  1011.         || ngx_mp4_atom_data(mp4) + (size_t) atom_data_size > mp4->buffer_end)
  1012.     {
  1013.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1014.                       "\"%s\" mp4 ftyp atom is too large:%uL",
  1015.                       mp4->file.name.data, atom_data_size);
  1016.         return NGX_ERROR;
  1017.     }

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

  1021.     ftyp_atom = ngx_palloc(mp4->request->pool, atom_size);
  1022.     if (ftyp_atom == NULL) {
  1023.         return NGX_ERROR;
  1024.     }

  1026.     ngx_mp4_set_32value(ftyp_atom, atom_size);
  1027.     ngx_mp4_set_atom_name(ftyp_atom, 'f', 't', 'y', 'p');

  1029.     /*
  1030.      * only moov atom content is guaranteed to be in mp4->buffer
  1031.      * during sending response, so ftyp atom content should be copied
  1032.      */
  1033.     ngx_memcpy(ftyp_atom + sizeof(ngx_mp4_atom_header_t),
  1034.                ngx_mp4_atom_data(mp4), (size_t) atom_data_size);

  1036.     atom = &mp4->ftyp_atom_buf;
  1037.     atom->temporary = 1;
  1038.     atom->pos = ftyp_atom;
  1039.     atom->last = ftyp_atom + atom_size;

  1041.     mp4->ftyp_atom.buf = atom;
  1042.     mp4->ftyp_size = atom_size;
  1043.     mp4->content_length = atom_size;

  1045.     ngx_mp4_atom_next(mp4, atom_data_size);

  1047.     return NGX_OK;
  1048. }


  1051. /*
  1052. * Small excess buffer to process atoms after moov atom, mp4->buffer_start
  1053. * will be set to this buffer part after moov atom processing.
  1054. */
  1055. ‌#define NGX_HTTP_MP4_MOOV_BUFFER_EXCESS  (4 * 1024)

  1057. static ngx_int_t
  1058. ‌ngx_http_mp4_read_moov_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1059. {
  1060.     ngx_int_t             rc;
  1061.     ngx_uint_t            no_mdat;
  1062.     ngx_buf_t            *atom;
  1063.     ngx_http_mp4_conf_t  *conf;

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

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

  1069.     if (no_mdat && mp4->start == 0 && mp4->length == 0) {
  1070.         /*
  1071.          * send original file if moov atom resides before
  1072.          * mdat atom and client requests integral file
  1073.          */
  1074.         return NGX_DECLINED;
  1075.     }

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

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

  1081.         if (atom_data_size > conf->max_buffer_size) {
  1082.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1083.                           "\"%s\" mp4 moov atom is too large:%uL, "
  1084.                           "you may want to increase mp4_max_buffer_size",
  1085.                           mp4->file.name.data, atom_data_size);
  1086.             return NGX_ERROR;
  1087.         }

  1089.         ngx_pfree(mp4->request->pool, mp4->buffer);
  1090.         mp4->buffer = NULL;
  1091.         mp4->buffer_pos = NULL;
  1092.         mp4->buffer_end = NULL;

  1094.         mp4->buffer_size = (size_t) atom_data_size
  1095.                          + NGX_HTTP_MP4_MOOV_BUFFER_EXCESS * no_mdat;
  1096.     }

  1098.     if (ngx_http_mp4_read(mp4, (size_t) atom_data_size) != NGX_OK) {
  1099.         return NGX_ERROR;
  1100.     }

  1102.     mp4->trak.elts = &mp4->traks;
  1103.     mp4->trak.size = sizeof(ngx_http_mp4_trak_t);
  1104.     mp4->trak.nalloc = 2;
  1105.     mp4->trak.pool = mp4->request->pool;

  1107.     atom = &mp4->moov_atom_buf;
  1108.     atom->temporary = 1;
  1109.     atom->pos = mp4->moov_atom_header;
  1110.     atom->last = mp4->moov_atom_header + 8;

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

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

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

  1118.     if (no_mdat) {
  1119.         mp4->buffer_start = mp4->buffer_pos;
  1120.         mp4->buffer_size = NGX_HTTP_MP4_MOOV_BUFFER_EXCESS;

  1122.         if (mp4->buffer_start + mp4->buffer_size > mp4->buffer_end) {
  1123.             mp4->buffer = NULL;
  1124.             mp4->buffer_pos = NULL;
  1125.             mp4->buffer_end = NULL;
  1126.         }

  1128.     } else {
  1129.         /* skip atoms after moov atom */
  1130.         mp4->offset = mp4->end;
  1131.     }

  1133.     return rc;
  1134. }


  1137. static ngx_int_t
  1138. ‌ngx_http_mp4_read_mdat_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1139. {
  1140.     ngx_buf_t  *data;

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

  1144.     data = &mp4->mdat_data_buf;
  1145.     data->file = &mp4->file;
  1146.     data->in_file = 1;
  1147.     data->last_buf = 1;
  1148.     data->last_in_chain = 1;
  1149.     data->file_last = mp4->offset + atom_data_size;

  1151.     mp4->mdat_atom.buf = &mp4->mdat_atom_buf;
  1152.     mp4->mdat_atom.next = &mp4->mdat_data;
  1153.     mp4->mdat_data.buf = data;

  1155.     if (mp4->trak.nelts) {
  1156.         /* skip atoms after mdat atom */
  1157.         mp4->offset = mp4->end;

  1159.     } else {
  1160.         ngx_mp4_atom_next(mp4, atom_data_size);
  1161.     }

  1163.     return NGX_OK;
  1164. }


  1167. static size_t
  1168. ‌ngx_http_mp4_update_mdat_atom(ngx_http_mp4_file_t *mp4, off_t start_offset,
  1169.     off_t end_offset)
  1170. {
  1171.     off_t       atom_data_size;
  1172.     u_char     *atom_header;
  1173.     uint32_t    atom_header_size;
  1174.     uint64_t    atom_size;
  1175.     ngx_buf_t  *atom;

  1177.     atom_data_size = end_offset - start_offset;
  1178.     mp4->mdat_data.buf->file_pos = start_offset;
  1179.     mp4->mdat_data.buf->file_last = end_offset;

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

  1184.     atom_header = mp4->mdat_atom_header;

  1186.     if ((uint64_t) atom_data_size > (uint64_t) 0xffffffff) {
  1187.         atom_size = 1;
  1188.         atom_header_size = sizeof(ngx_mp4_atom_header64_t);
  1189.         ngx_mp4_set_64value(atom_header + sizeof(ngx_mp4_atom_header_t),
  1190.                             sizeof(ngx_mp4_atom_header64_t) + atom_data_size);
  1191.     } else {
  1192.         atom_size = sizeof(ngx_mp4_atom_header_t) + atom_data_size;
  1193.         atom_header_size = sizeof(ngx_mp4_atom_header_t);
  1194.     }

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

  1198.     ngx_mp4_set_32value(atom_header, atom_size);
  1199.     ngx_mp4_set_atom_name(atom_header, 'm', 'd', 'a', 't');

  1201.     atom = &mp4->mdat_atom_buf;
  1202.     atom->temporary = 1;
  1203.     atom->pos = atom_header;
  1204.     atom->last = atom_header + atom_header_size;

  1206.     return atom_header_size;
  1207. }


  1210. typedef struct {
  1211.     u_char    size[4];
  1212.     u_char    name[4];
  1213.     u_char    version[1];
  1214.     u_char    flags[3];
  1215.     u_char    creation_time[4];
  1216.     u_char    modification_time[4];
  1217.     u_char    timescale[4];
  1218.     u_char    duration[4];
  1219.     u_char    rate[4];
  1220.     u_char    volume[2];
  1221.     u_char    reserved[10];
  1222.     u_char    matrix[36];
  1223.     u_char    preview_time[4];
  1224.     u_char    preview_duration[4];
  1225.     u_char    poster_time[4];
  1226.     u_char    selection_time[4];
  1227.     u_char    selection_duration[4];
  1228.     u_char    current_time[4];
  1229.     u_char    next_track_id[4];
  1230. ‌} ngx_mp4_mvhd_atom_t;

  1232. typedef struct {
  1233.     u_char    size[4];
  1234.     u_char    name[4];
  1235.     u_char    version[1];
  1236.     u_char    flags[3];
  1237.     u_char    creation_time[8];
  1238.     u_char    modification_time[8];
  1239.     u_char    timescale[4];
  1240.     u_char    duration[8];
  1241.     u_char    rate[4];
  1242.     u_char    volume[2];
  1243.     u_char    reserved[10];
  1244.     u_char    matrix[36];
  1245.     u_char    preview_time[4];
  1246.     u_char    preview_duration[4];
  1247.     u_char    poster_time[4];
  1248.     u_char    selection_time[4];
  1249.     u_char    selection_duration[4];
  1250.     u_char    current_time[4];
  1251.     u_char    next_track_id[4];
  1252. ‌} ngx_mp4_mvhd64_atom_t;


  1255. static ngx_int_t
  1256. ‌ngx_http_mp4_read_mvhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1257. {
  1258.     u_char                 *atom_header;
  1259.     size_t                  atom_size;
  1260.     uint32_t                timescale;
  1261.     uint64_t                duration, start_time, length_time;
  1262.     ngx_buf_t              *atom;
  1263.     ngx_mp4_mvhd_atom_t    *mvhd_atom;
  1264.     ngx_mp4_mvhd64_atom_t  *mvhd64_atom;

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

  1268.     atom_header = ngx_mp4_atom_header(mp4);
  1269.     mvhd_atom = (ngx_mp4_mvhd_atom_t *) atom_header;
  1270.     mvhd64_atom = (ngx_mp4_mvhd64_atom_t *) atom_header;
  1271.     ngx_mp4_set_atom_name(atom_header, 'm', 'v', 'h', 'd');

  1273.     if (ngx_mp4_atom_data_size(ngx_mp4_mvhd_atom_t) > atom_data_size) {
  1274.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1275.                       "\"%s\" mp4 mvhd atom too small", mp4->file.name.data);
  1276.         return NGX_ERROR;
  1277.     }

  1279.     if (mvhd_atom->version[0] == 0) {
  1280.         /* version 0: 32-bit duration */
  1281.         timescale = ngx_mp4_get_32value(mvhd_atom->timescale);
  1282.         duration = ngx_mp4_get_32value(mvhd_atom->duration);

  1284.     } else {
  1285.         /* version 1: 64-bit duration */

  1287.         if (ngx_mp4_atom_data_size(ngx_mp4_mvhd64_atom_t) > atom_data_size) {
  1288.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1289.                           "\"%s\" mp4 mvhd atom too small",
  1290.                           mp4->file.name.data);
  1291.             return NGX_ERROR;
  1292.         }

  1294.         timescale = ngx_mp4_get_32value(mvhd64_atom->timescale);
  1295.         duration = ngx_mp4_get_64value(mvhd64_atom->duration);
  1296.     }

  1298.     mp4->timescale = timescale;

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

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

  1306.     if (duration < start_time) {
  1307.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1308.                       "\"%s\" mp4 start time exceeds file duration",
  1309.                       mp4->file.name.data);
  1310.         return NGX_ERROR;
  1311.     }

  1313.     duration -= start_time;

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

  1318.         if (duration > length_time) {
  1319.             duration = length_time;
  1320.         }
  1321.     }

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

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

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

  1333.     } else {
  1334.         ngx_mp4_set_64value(mvhd64_atom->duration, duration);
  1335.     }

  1337.     atom = &mp4->mvhd_atom_buf;
  1338.     atom->temporary = 1;
  1339.     atom->pos = atom_header;
  1340.     atom->last = atom_header + atom_size;

  1342.     mp4->mvhd_atom.buf = atom;

  1344.     ngx_mp4_atom_next(mp4, atom_data_size);

  1346.     return NGX_OK;
  1347. }


  1350. static ngx_int_t
  1351. ‌ngx_http_mp4_read_trak_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1352. {
  1353.     u_char               *atom_header, *atom_end;
  1354.     off_t                 atom_file_end;
  1355.     ngx_int_t             rc;
  1356.     ngx_buf_t            *atom;
  1357.     ngx_http_mp4_trak_t  *trak;

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

  1361.     trak = ngx_array_push(&mp4->trak);
  1362.     if (trak == NULL) {
  1363.         return NGX_ERROR;
  1364.     }

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

  1368.     atom_header = ngx_mp4_atom_header(mp4);
  1369.     ngx_mp4_set_atom_name(atom_header, 't', 'r', 'a', 'k');

  1371.     atom = &trak->trak_atom_buf;
  1372.     atom->temporary = 1;
  1373.     atom->pos = atom_header;
  1374.     atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);

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

  1378.     atom_end = mp4->buffer_pos + (size_t) atom_data_size;
  1379.     atom_file_end = mp4->offset + atom_data_size;

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

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

  1386.     if (rc == NGX_DECLINED) {
  1387.         /* skip this trak */
  1388.         ngx_memzero(trak, sizeof(ngx_http_mp4_trak_t));
  1389.         mp4->trak.nelts--;
  1390.         mp4->buffer_pos = atom_end;
  1391.         mp4->offset = atom_file_end;
  1392.         return NGX_OK;
  1393.     }

  1395.     return rc;
  1396. }


  1399. static void
  1400. ‌ngx_http_mp4_update_trak_atom(ngx_http_mp4_file_t *mp4,
  1401.     ngx_http_mp4_trak_t *trak)
  1402. {
  1403.     ngx_buf_t  *atom;

  1405.     trak->size += sizeof(ngx_mp4_atom_header_t);
  1406.     atom = &trak->trak_atom_buf;
  1407.     ngx_mp4_set_32value(atom->pos, trak->size);
  1408. }


  1411. static ngx_int_t
  1412. ‌ngx_http_mp4_read_cmov_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1413. {
  1414.     ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1415.                   "\"%s\" mp4 compressed moov atom (cmov) is not supported",
  1416.                   mp4->file.name.data);

  1418.     return NGX_ERROR;
  1419. }


  1422. typedef struct {
  1423.     u_char    size[4];
  1424.     u_char    name[4];
  1425.     u_char    version[1];
  1426.     u_char    flags[3];
  1427.     u_char    creation_time[4];
  1428.     u_char    modification_time[4];
  1429.     u_char    track_id[4];
  1430.     u_char    reserved1[4];
  1431.     u_char    duration[4];
  1432.     u_char    reserved2[8];
  1433.     u_char    layer[2];
  1434.     u_char    group[2];
  1435.     u_char    volume[2];
  1436.     u_char    reverved3[2];
  1437.     u_char    matrix[36];
  1438.     u_char    width[4];
  1439.     u_char    heigth[4];
  1440. ‌} ngx_mp4_tkhd_atom_t;

  1442. typedef struct {
  1443.     u_char    size[4];
  1444.     u_char    name[4];
  1445.     u_char    version[1];
  1446.     u_char    flags[3];
  1447.     u_char    creation_time[8];
  1448.     u_char    modification_time[8];
  1449.     u_char    track_id[4];
  1450.     u_char    reserved1[4];
  1451.     u_char    duration[8];
  1452.     u_char    reserved2[8];
  1453.     u_char    layer[2];
  1454.     u_char    group[2];
  1455.     u_char    volume[2];
  1456.     u_char    reverved3[2];
  1457.     u_char    matrix[36];
  1458.     u_char    width[4];
  1459.     u_char    heigth[4];
  1460. ‌} ngx_mp4_tkhd64_atom_t;


  1463. static ngx_int_t
  1464. ‌ngx_http_mp4_read_tkhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1465. {
  1466.     u_char                 *atom_header;
  1467.     size_t                  atom_size;
  1468.     uint64_t                duration, start_time, length_time;
  1469.     ngx_buf_t              *atom;
  1470.     ngx_http_mp4_trak_t    *trak;
  1471.     ngx_mp4_tkhd_atom_t    *tkhd_atom;
  1472.     ngx_mp4_tkhd64_atom_t  *tkhd64_atom;

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

  1476.     atom_header = ngx_mp4_atom_header(mp4);
  1477.     tkhd_atom = (ngx_mp4_tkhd_atom_t *) atom_header;
  1478.     tkhd64_atom = (ngx_mp4_tkhd64_atom_t *) atom_header;
  1479.     ngx_mp4_set_atom_name(tkhd_atom, 't', 'k', 'h', 'd');

  1481.     if (ngx_mp4_atom_data_size(ngx_mp4_tkhd_atom_t) > atom_data_size) {
  1482.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1483.                       "\"%s\" mp4 tkhd atom too small", mp4->file.name.data);
  1484.         return NGX_ERROR;
  1485.     }

  1487.     if (tkhd_atom->version[0] == 0) {
  1488.         /* version 0: 32-bit duration */
  1489.         duration = ngx_mp4_get_32value(tkhd_atom->duration);

  1491.     } else {
  1492.         /* version 1: 64-bit duration */

  1494.         if (ngx_mp4_atom_data_size(ngx_mp4_tkhd64_atom_t) > atom_data_size) {
  1495.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1496.                           "\"%s\" mp4 tkhd atom too small",
  1497.                           mp4->file.name.data);
  1498.             return NGX_ERROR;
  1499.         }

  1501.         duration = ngx_mp4_get_64value(tkhd64_atom->duration);
  1502.     }

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

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

  1510.     if (duration <= start_time) {
  1511.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1512.                        "tkhd duration is less than start time");
  1513.         return NGX_DECLINED;
  1514.     }

  1516.     duration -= start_time;

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

  1521.         if (duration > length_time) {
  1522.             duration = length_time;
  1523.         }
  1524.     }

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

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

  1532.     trak = ngx_mp4_last_trak(mp4);
  1533.     trak->tkhd_size = atom_size;

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

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

  1540.     } else {
  1541.         ngx_mp4_set_64value(tkhd64_atom->duration, duration);
  1542.     }

  1544.     atom = &trak->tkhd_atom_buf;
  1545.     atom->temporary = 1;
  1546.     atom->pos = atom_header;
  1547.     atom->last = atom_header + atom_size;

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

  1551.     ngx_mp4_atom_next(mp4, atom_data_size);

  1553.     return NGX_OK;
  1554. }


  1557. static ngx_int_t
  1558. ‌ngx_http_mp4_read_mdia_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1559. {
  1560.     u_char               *atom_header;
  1561.     ngx_buf_t            *atom;
  1562.     ngx_http_mp4_trak_t  *trak;

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

  1566.     atom_header = ngx_mp4_atom_header(mp4);
  1567.     ngx_mp4_set_atom_name(atom_header, 'm', 'd', 'i', 'a');

  1569.     trak = ngx_mp4_last_trak(mp4);

  1571.     atom = &trak->mdia_atom_buf;
  1572.     atom->temporary = 1;
  1573.     atom->pos = atom_header;
  1574.     atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);

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

  1578.     return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_mdia_atoms, atom_data_size);
  1579. }


  1582. static void
  1583. ‌ngx_http_mp4_update_mdia_atom(ngx_http_mp4_file_t *mp4,
  1584.     ngx_http_mp4_trak_t *trak)
  1585. {
  1586.     ngx_buf_t  *atom;

  1588.     trak->size += sizeof(ngx_mp4_atom_header_t);
  1589.     atom = &trak->mdia_atom_buf;
  1590.     ngx_mp4_set_32value(atom->pos, trak->size);
  1591. }


  1594. typedef struct {
  1595.     u_char    size[4];
  1596.     u_char    name[4];
  1597.     u_char    version[1];
  1598.     u_char    flags[3];
  1599.     u_char    creation_time[4];
  1600.     u_char    modification_time[4];
  1601.     u_char    timescale[4];
  1602.     u_char    duration[4];
  1603.     u_char    language[2];
  1604.     u_char    quality[2];
  1605. ‌} ngx_mp4_mdhd_atom_t;

  1607. typedef struct {
  1608.     u_char    size[4];
  1609.     u_char    name[4];
  1610.     u_char    version[1];
  1611.     u_char    flags[3];
  1612.     u_char    creation_time[8];
  1613.     u_char    modification_time[8];
  1614.     u_char    timescale[4];
  1615.     u_char    duration[8];
  1616.     u_char    language[2];
  1617.     u_char    quality[2];
  1618. ‌} ngx_mp4_mdhd64_atom_t;


  1621. static ngx_int_t
  1622. ‌ngx_http_mp4_read_mdhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1623. {
  1624.     u_char                 *atom_header;
  1625.     size_t                  atom_size;
  1626.     uint32_t                timescale;
  1627.     uint64_t                duration, start_time, length_time;
  1628.     ngx_buf_t              *atom;
  1629.     ngx_http_mp4_trak_t    *trak;
  1630.     ngx_mp4_mdhd_atom_t    *mdhd_atom;
  1631.     ngx_mp4_mdhd64_atom_t  *mdhd64_atom;

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

  1635.     atom_header = ngx_mp4_atom_header(mp4);
  1636.     mdhd_atom = (ngx_mp4_mdhd_atom_t *) atom_header;
  1637.     mdhd64_atom = (ngx_mp4_mdhd64_atom_t *) atom_header;
  1638.     ngx_mp4_set_atom_name(mdhd_atom, 'm', 'd', 'h', 'd');

  1640.     if (ngx_mp4_atom_data_size(ngx_mp4_mdhd_atom_t) > atom_data_size) {
  1641.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1642.                       "\"%s\" mp4 mdhd atom too small", mp4->file.name.data);
  1643.         return NGX_ERROR;
  1644.     }

  1646.     if (mdhd_atom->version[0] == 0) {
  1647.         /* version 0: everything is 32-bit */
  1648.         timescale = ngx_mp4_get_32value(mdhd_atom->timescale);
  1649.         duration = ngx_mp4_get_32value(mdhd_atom->duration);

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

  1654.         if (ngx_mp4_atom_data_size(ngx_mp4_mdhd64_atom_t) > atom_data_size) {
  1655.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1656.                           "\"%s\" mp4 mdhd atom too small",
  1657.                           mp4->file.name.data);
  1658.             return NGX_ERROR;
  1659.         }

  1661.         timescale = ngx_mp4_get_32value(mdhd64_atom->timescale);
  1662.         duration = ngx_mp4_get_64value(mdhd64_atom->duration);
  1663.     }

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

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

  1671.     if (duration <= start_time) {
  1672.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1673.                        "mdhd duration is less than start time");
  1674.         return NGX_DECLINED;
  1675.     }

  1677.     duration -= start_time;

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

  1682.         if (duration > length_time) {
  1683.             duration = length_time;
  1684.         }
  1685.     }

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

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

  1693.     trak = ngx_mp4_last_trak(mp4);
  1694.     trak->mdhd_size = atom_size;
  1695.     trak->timescale = timescale;

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

  1699.     if (mdhd_atom->version[0] == 0) {
  1700.         ngx_mp4_set_32value(mdhd_atom->duration, duration);

  1702.     } else {
  1703.         ngx_mp4_set_64value(mdhd64_atom->duration, duration);
  1704.     }

  1706.     atom = &trak->mdhd_atom_buf;
  1707.     atom->temporary = 1;
  1708.     atom->pos = atom_header;
  1709.     atom->last = atom_header + atom_size;

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

  1713.     ngx_mp4_atom_next(mp4, atom_data_size);

  1715.     return NGX_OK;
  1716. }


  1719. static ngx_int_t
  1720. ‌ngx_http_mp4_read_hdlr_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1721. {
  1722.     u_char              *atom_header;
  1723.     size_t               atom_size;
  1724.     ngx_buf_t            *atom;
  1725.     ngx_http_mp4_trak_t  *trak;

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

  1729.     atom_header = ngx_mp4_atom_header(mp4);
  1730.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  1731.     ngx_mp4_set_32value(atom_header, atom_size);
  1732.     ngx_mp4_set_atom_name(atom_header, 'h', 'd', 'l', 'r');

  1734.     trak = ngx_mp4_last_trak(mp4);

  1736.     atom = &trak->hdlr_atom_buf;
  1737.     atom->temporary = 1;
  1738.     atom->pos = atom_header;
  1739.     atom->last = atom_header + atom_size;

  1741.     trak->hdlr_size = atom_size;
  1742.     trak->out[NGX_HTTP_MP4_HDLR_ATOM].buf = atom;

  1744.     ngx_mp4_atom_next(mp4, atom_data_size);

  1746.     return NGX_OK;
  1747. }


  1750. static ngx_int_t
  1751. ‌ngx_http_mp4_read_minf_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1752. {
  1753.     u_char               *atom_header;
  1754.     ngx_buf_t            *atom;
  1755.     ngx_http_mp4_trak_t  *trak;

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

  1759.     atom_header = ngx_mp4_atom_header(mp4);
  1760.     ngx_mp4_set_atom_name(atom_header, 'm', 'i', 'n', 'f');

  1762.     trak = ngx_mp4_last_trak(mp4);

  1764.     atom = &trak->minf_atom_buf;
  1765.     atom->temporary = 1;
  1766.     atom->pos = atom_header;
  1767.     atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);

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

  1771.     return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_minf_atoms, atom_data_size);
  1772. }


  1775. static void
  1776. ‌ngx_http_mp4_update_minf_atom(ngx_http_mp4_file_t *mp4,
  1777.     ngx_http_mp4_trak_t *trak)
  1778. {
  1779.     ngx_buf_t  *atom;

  1781.     trak->size += sizeof(ngx_mp4_atom_header_t)
  1782.                + trak->vmhd_size
  1783.                + trak->smhd_size
  1784.                + trak->dinf_size;
  1785.     atom = &trak->minf_atom_buf;
  1786.     ngx_mp4_set_32value(atom->pos, trak->size);
  1787. }


  1790. static ngx_int_t
  1791. ‌ngx_http_mp4_read_vmhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1792. {
  1793.     u_char              *atom_header;
  1794.     size_t               atom_size;
  1795.     ngx_buf_t            *atom;
  1796.     ngx_http_mp4_trak_t  *trak;

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

  1800.     atom_header = ngx_mp4_atom_header(mp4);
  1801.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  1802.     ngx_mp4_set_32value(atom_header, atom_size);
  1803.     ngx_mp4_set_atom_name(atom_header, 'v', 'm', 'h', 'd');

  1805.     trak = ngx_mp4_last_trak(mp4);

  1807.     atom = &trak->vmhd_atom_buf;
  1808.     atom->temporary = 1;
  1809.     atom->pos = atom_header;
  1810.     atom->last = atom_header + atom_size;

  1812.     trak->vmhd_size += atom_size;
  1813.     trak->out[NGX_HTTP_MP4_VMHD_ATOM].buf = atom;

  1815.     ngx_mp4_atom_next(mp4, atom_data_size);

  1817.     return NGX_OK;
  1818. }


  1821. static ngx_int_t
  1822. ‌ngx_http_mp4_read_smhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1823. {
  1824.     u_char              *atom_header;
  1825.     size_t               atom_size;
  1826.     ngx_buf_t            *atom;
  1827.     ngx_http_mp4_trak_t  *trak;

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

  1831.     atom_header = ngx_mp4_atom_header(mp4);
  1832.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  1833.     ngx_mp4_set_32value(atom_header, atom_size);
  1834.     ngx_mp4_set_atom_name(atom_header, 's', 'm', 'h', 'd');

  1836.     trak = ngx_mp4_last_trak(mp4);

  1838.     atom = &trak->smhd_atom_buf;
  1839.     atom->temporary = 1;
  1840.     atom->pos = atom_header;
  1841.     atom->last = atom_header + atom_size;

  1843.     trak->smhd_size += atom_size;
  1844.     trak->out[NGX_HTTP_MP4_SMHD_ATOM].buf = atom;

  1846.     ngx_mp4_atom_next(mp4, atom_data_size);

  1848.     return NGX_OK;
  1849. }


  1852. static ngx_int_t
  1853. ‌ngx_http_mp4_read_dinf_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1854. {
  1855.     u_char              *atom_header;
  1856.     size_t               atom_size;
  1857.     ngx_buf_t            *atom;
  1858.     ngx_http_mp4_trak_t  *trak;

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

  1862.     atom_header = ngx_mp4_atom_header(mp4);
  1863.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  1864.     ngx_mp4_set_32value(atom_header, atom_size);
  1865.     ngx_mp4_set_atom_name(atom_header, 'd', 'i', 'n', 'f');

  1867.     trak = ngx_mp4_last_trak(mp4);

  1869.     atom = &trak->dinf_atom_buf;
  1870.     atom->temporary = 1;
  1871.     atom->pos = atom_header;
  1872.     atom->last = atom_header + atom_size;

  1874.     trak->dinf_size += atom_size;
  1875.     trak->out[NGX_HTTP_MP4_DINF_ATOM].buf = atom;

  1877.     ngx_mp4_atom_next(mp4, atom_data_size);

  1879.     return NGX_OK;
  1880. }


  1883. static ngx_int_t
  1884. ‌ngx_http_mp4_read_stbl_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1885. {
  1886.     u_char               *atom_header;
  1887.     ngx_buf_t            *atom;
  1888.     ngx_http_mp4_trak_t  *trak;

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

  1892.     atom_header = ngx_mp4_atom_header(mp4);
  1893.     ngx_mp4_set_atom_name(atom_header, 's', 't', 'b', 'l');

  1895.     trak = ngx_mp4_last_trak(mp4);

  1897.     atom = &trak->stbl_atom_buf;
  1898.     atom->temporary = 1;
  1899.     atom->pos = atom_header;
  1900.     atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);

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

  1904.     return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_stbl_atoms, atom_data_size);
  1905. }


  1908. static void
  1909. ‌ngx_http_mp4_update_stbl_atom(ngx_http_mp4_file_t *mp4,
  1910.     ngx_http_mp4_trak_t *trak)
  1911. {
  1912.     ngx_buf_t  *atom;

  1914.     trak->size += sizeof(ngx_mp4_atom_header_t);
  1915.     atom = &trak->stbl_atom_buf;
  1916.     ngx_mp4_set_32value(atom->pos, trak->size);
  1917. }


  1920. typedef struct {
  1921.     u_char    size[4];
  1922.     u_char    name[4];
  1923.     u_char    version[1];
  1924.     u_char    flags[3];
  1925.     u_char    entries[4];

  1927.     u_char    media_size[4];
  1928.     u_char    media_name[4];
  1929. ‌} ngx_mp4_stsd_atom_t;


  1932. static ngx_int_t
  1933. ‌ngx_http_mp4_read_stsd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1934. {
  1935.     u_char               *atom_header, *atom_table;
  1936.     size_t                atom_size;
  1937.     ngx_buf_t            *atom;
  1938.     ngx_mp4_stsd_atom_t  *stsd_atom;
  1939.     ngx_http_mp4_trak_t  *trak;

  1941.     /* sample description atom */

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

  1945.     atom_header = ngx_mp4_atom_header(mp4);
  1946.     stsd_atom = (ngx_mp4_stsd_atom_t *) atom_header;
  1947.     atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  1948.     atom_table = atom_header + atom_size;
  1949.     ngx_mp4_set_32value(stsd_atom->size, atom_size);
  1950.     ngx_mp4_set_atom_name(stsd_atom, 's', 't', 's', 'd');

  1952.     if (ngx_mp4_atom_data_size(ngx_mp4_stsd_atom_t) > atom_data_size) {
  1953.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  1954.                       "\"%s\" mp4 stsd atom too small", mp4->file.name.data);
  1955.         return NGX_ERROR;
  1956.     }

  1958.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  1959.                    "stsd entries:%uD, media:%*s",
  1960.                    ngx_mp4_get_32value(stsd_atom->entries),
  1961.                    4, stsd_atom->media_name);

  1963.     trak = ngx_mp4_last_trak(mp4);

  1965.     atom = &trak->stsd_atom_buf;
  1966.     atom->temporary = 1;
  1967.     atom->pos = atom_header;
  1968.     atom->last = atom_table;

  1970.     trak->out[NGX_HTTP_MP4_STSD_ATOM].buf = atom;
  1971.     trak->size += atom_size;

  1973.     ngx_mp4_atom_next(mp4, atom_data_size);

  1975.     return NGX_OK;
  1976. }


  1979. typedef struct {
  1980.     u_char    size[4];
  1981.     u_char    name[4];
  1982.     u_char    version[1];
  1983.     u_char    flags[3];
  1984.     u_char    entries[4];
  1985. ‌} ngx_mp4_stts_atom_t;

  1987. typedef struct {
  1988.     u_char    count[4];
  1989.     u_char    duration[4];
  1990. ‌} ngx_mp4_stts_entry_t;


  1993. static ngx_int_t
  1994. ‌ngx_http_mp4_read_stts_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  1995. {
  1996.     u_char               *atom_header, *atom_table, *atom_end;
  1997.     uint32_t              entries;
  1998.     ngx_buf_t            *atom, *data;
  1999.     ngx_mp4_stts_atom_t  *stts_atom;
  2000.     ngx_http_mp4_trak_t  *trak;

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

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

  2006.     atom_header = ngx_mp4_atom_header(mp4);
  2007.     stts_atom = (ngx_mp4_stts_atom_t *) atom_header;
  2008.     ngx_mp4_set_atom_name(stts_atom, 's', 't', 't', 's');

  2010.     if (ngx_mp4_atom_data_size(ngx_mp4_stts_atom_t) > atom_data_size) {
  2011.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2012.                       "\"%s\" mp4 stts atom too small", mp4->file.name.data);
  2013.         return NGX_ERROR;
  2014.     }

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

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

  2021.     if (ngx_mp4_atom_data_size(ngx_mp4_stts_atom_t)
  2022.         + entries * sizeof(ngx_mp4_stts_entry_t) > atom_data_size)
  2023.     {
  2024.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2025.                       "\"%s\" mp4 stts atom too small", mp4->file.name.data);
  2026.         return NGX_ERROR;
  2027.     }

  2029.     atom_table = atom_header + sizeof(ngx_mp4_stts_atom_t);
  2030.     atom_end = atom_table + entries * sizeof(ngx_mp4_stts_entry_t);

  2032.     trak = ngx_mp4_last_trak(mp4);
  2033.     trak->time_to_sample_entries = entries;

  2035.     atom = &trak->stts_atom_buf;
  2036.     atom->temporary = 1;
  2037.     atom->pos = atom_header;
  2038.     atom->last = atom_table;

  2040.     data = &trak->stts_data_buf;
  2041.     data->temporary = 1;
  2042.     data->pos = atom_table;
  2043.     data->last = atom_end;

  2045.     trak->out[NGX_HTTP_MP4_STTS_ATOM].buf = atom;
  2046.     trak->out[NGX_HTTP_MP4_STTS_DATA].buf = data;

  2048.     ngx_mp4_atom_next(mp4, atom_data_size);

  2050.     return NGX_OK;
  2051. }


  2054. static ngx_int_t
  2055. ‌ngx_http_mp4_update_stts_atom(ngx_http_mp4_file_t *mp4,
  2056.     ngx_http_mp4_trak_t *trak)
  2057. {
  2058.     size_t                atom_size;
  2059.     ngx_buf_t            *atom, *data;
  2060.     ngx_mp4_stts_atom_t  *stts_atom;

  2062.     /*
  2063.      * mdia.minf.stbl.stts updating requires trak->timescale
  2064.      * from mdia.mdhd atom which may reside after mdia.minf
  2065.      */

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

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

  2072.     if (data == NULL) {
  2073.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2074.                       "no mp4 stts atoms were found in \"%s\"",
  2075.                       mp4->file.name.data);
  2076.         return NGX_ERROR;
  2077.     }

  2079.     if (ngx_http_mp4_crop_stts_data(mp4, trak, 1) != NGX_OK) {
  2080.         return NGX_ERROR;
  2081.     }

  2083.     if (ngx_http_mp4_crop_stts_data(mp4, trak, 0) != NGX_OK) {
  2084.         return NGX_ERROR;
  2085.     }

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

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

  2093.     atom = trak->out[NGX_HTTP_MP4_STTS_ATOM].buf;
  2094.     stts_atom = (ngx_mp4_stts_atom_t *) atom->pos;
  2095.     ngx_mp4_set_32value(stts_atom->size, atom_size);
  2096.     ngx_mp4_set_32value(stts_atom->entries, trak->time_to_sample_entries);

  2098.     return NGX_OK;
  2099. }


  2102. static ngx_int_t
  2103. ‌ngx_http_mp4_crop_stts_data(ngx_http_mp4_file_t *mp4,
  2104.     ngx_http_mp4_trak_t *trak, ngx_uint_t start)
  2105. {
  2106.     uint32_t               count, duration, rest;
  2107.     uint64_t               start_time;
  2108.     ngx_buf_t             *data;
  2109.     ngx_uint_t             start_sample, entries, start_sec;
  2110.     ngx_mp4_stts_entry_t  *entry, *end;

  2112.     if (start) {
  2113.         start_sec = mp4->start;

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

  2118.     } else if (mp4->length) {
  2119.         start_sec = mp4->length;

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

  2124.     } else {
  2125.         return NGX_OK;
  2126.     }

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

  2130.     start_time = (uint64_t) start_sec * trak->timescale / 1000;

  2132.     entries = trak->time_to_sample_entries;
  2133.     start_sample = 0;
  2134.     entry = (ngx_mp4_stts_entry_t *) data->pos;
  2135.     end = (ngx_mp4_stts_entry_t *) data->last;

  2137.     while (entry < end) {
  2138.         count = ngx_mp4_get_32value(entry->count);
  2139.         duration = ngx_mp4_get_32value(entry->duration);

  2141.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2142.                        "time:%uL, count:%uD, duration:%uD",
  2143.                        start_time, count, duration);

  2145.         if (start_time < (uint64_t) count * duration) {
  2146.             start_sample += (ngx_uint_t) (start_time / duration);
  2147.             rest = (uint32_t) (start_time / duration);
  2148.             goto found;
  2149.         }

  2151.         start_sample += count;
  2152.         start_time -= count * duration;
  2153.         entries--;
  2154.         entry++;
  2155.     }

  2157.     if (start) {
  2158.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2159.                       "start time is out mp4 stts samples in \"%s\"",
  2160.                       mp4->file.name.data);

  2162.         return NGX_ERROR;

  2164.     } else {
  2165.         trak->end_sample = trak->start_sample + start_sample;

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

  2170.         return NGX_OK;
  2171.     }

  2173. found:

  2175.     if (start) {
  2176.         ngx_mp4_set_32value(entry->count, count - rest);
  2177.         data->pos = (u_char *) entry;
  2178.         trak->time_to_sample_entries = entries;
  2179.         trak->start_sample = start_sample;

  2181.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2182.                        "start_sample:%ui, new count:%uD",
  2183.                        trak->start_sample, count - rest);

  2185.     } else {
  2186.         ngx_mp4_set_32value(entry->count, rest);
  2187.         data->last = (u_char *) (entry + 1);
  2188.         trak->time_to_sample_entries -= entries - 1;
  2189.         trak->end_sample = trak->start_sample + start_sample;

  2191.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2192.                        "end_sample:%ui, new count:%uD",
  2193.                        trak->end_sample, rest);
  2194.     }

  2196.     return NGX_OK;
  2197. }


  2200. typedef struct {
  2201.     u_char    size[4];
  2202.     u_char    name[4];
  2203.     u_char    version[1];
  2204.     u_char    flags[3];
  2205.     u_char    entries[4];
  2206. ‌} ngx_http_mp4_stss_atom_t;


  2209. static ngx_int_t
  2210. ‌ngx_http_mp4_read_stss_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2211. {
  2212.     u_char                    *atom_header, *atom_table, *atom_end;
  2213.     uint32_t                   entries;
  2214.     ngx_buf_t                 *atom, *data;
  2215.     ngx_http_mp4_trak_t       *trak;
  2216.     ngx_http_mp4_stss_atom_t  *stss_atom;

  2218.     /* sync samples atom */

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

  2222.     atom_header = ngx_mp4_atom_header(mp4);
  2223.     stss_atom = (ngx_http_mp4_stss_atom_t *) atom_header;
  2224.     ngx_mp4_set_atom_name(stss_atom, 's', 't', 's', 's');

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

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

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

  2237.     trak = ngx_mp4_last_trak(mp4);
  2238.     trak->sync_samples_entries = entries;

  2240.     atom_table = atom_header + sizeof(ngx_http_mp4_stss_atom_t);

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

  2247.     if (ngx_mp4_atom_data_size(ngx_http_mp4_stss_atom_t)
  2248.         + entries * sizeof(uint32_t) > atom_data_size)
  2249.     {
  2250.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2251.                       "\"%s\" mp4 stss atom too small", mp4->file.name.data);
  2252.         return NGX_ERROR;
  2253.     }

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

  2257.     data = &trak->stss_data_buf;
  2258.     data->temporary = 1;
  2259.     data->pos = atom_table;
  2260.     data->last = atom_end;

  2262.     trak->out[NGX_HTTP_MP4_STSS_ATOM].buf = atom;
  2263.     trak->out[NGX_HTTP_MP4_STSS_DATA].buf = data;

  2265.     ngx_mp4_atom_next(mp4, atom_data_size);

  2267.     return NGX_OK;
  2268. }


  2271. static ngx_int_t
  2272. ‌ngx_http_mp4_update_stss_atom(ngx_http_mp4_file_t *mp4,
  2273.     ngx_http_mp4_trak_t *trak)
  2274. {
  2275.     size_t                     atom_size;
  2276.     uint32_t                   sample, start_sample, *entry, *end;
  2277.     ngx_buf_t                 *atom, *data;
  2278.     ngx_http_mp4_stss_atom_t  *stss_atom;

  2280.     /*
  2281.      * mdia.minf.stbl.stss updating requires trak->start_sample
  2282.      * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
  2283.      * atom which may reside after mdia.minf
  2284.      */

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

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

  2291.     if (data == NULL) {
  2292.         return NGX_OK;
  2293.     }

  2295.     ngx_http_mp4_crop_stss_data(mp4, trak, 1);
  2296.     ngx_http_mp4_crop_stss_data(mp4, trak, 0);

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

  2301.     if (trak->sync_samples_entries) {
  2302.         entry = (uint32_t *) data->pos;
  2303.         end = (uint32_t *) data->last;

  2305.         start_sample = trak->start_sample;

  2307.         while (entry < end) {
  2308.             sample = ngx_mp4_get_32value(entry);
  2309.             sample -= start_sample;
  2310.             ngx_mp4_set_32value(entry, sample);
  2311.             entry++;
  2312.         }

  2314.     } else {
  2315.         trak->out[NGX_HTTP_MP4_STSS_DATA].buf = NULL;
  2316.     }

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

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

  2324.     ngx_mp4_set_32value(stss_atom->size, atom_size);
  2325.     ngx_mp4_set_32value(stss_atom->entries, trak->sync_samples_entries);

  2327.     return NGX_OK;
  2328. }


  2331. static void
  2332. ‌ngx_http_mp4_crop_stss_data(ngx_http_mp4_file_t *mp4,
  2333.     ngx_http_mp4_trak_t *trak, ngx_uint_t start)
  2334. {
  2335.     uint32_t     sample, start_sample, *entry, *end;
  2336.     ngx_buf_t   *data;
  2337.     ngx_uint_t   entries;

  2339.     /* sync samples starts from 1 */

  2341.     if (start) {
  2342.         start_sample = trak->start_sample + 1;

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

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

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

  2353.     } else {
  2354.         return;
  2355.     }

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

  2359.     entries = trak->sync_samples_entries;
  2360.     entry = (uint32_t *) data->pos;
  2361.     end = (uint32_t *) data->last;

  2363.     while (entry < end) {
  2364.         sample = ngx_mp4_get_32value(entry);

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

  2369.         if (sample >= start_sample) {
  2370.             goto found;
  2371.         }

  2373.         entries--;
  2374.         entry++;
  2375.     }

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

  2380. found:

  2382.     if (start) {
  2383.         data->pos = (u_char *) entry;
  2384.         trak->sync_samples_entries = entries;

  2386.     } else {
  2387.         data->last = (u_char *) entry;
  2388.         trak->sync_samples_entries -= entries;
  2389.     }
  2390. }


  2393. typedef struct {
  2394.     u_char    size[4];
  2395.     u_char    name[4];
  2396.     u_char    version[1];
  2397.     u_char    flags[3];
  2398.     u_char    entries[4];
  2399. ‌} ngx_mp4_ctts_atom_t;

  2401. typedef struct {
  2402.     u_char    count[4];
  2403.     u_char    offset[4];
  2404. ‌} ngx_mp4_ctts_entry_t;


  2407. static ngx_int_t
  2408. ‌ngx_http_mp4_read_ctts_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2409. {
  2410.     u_char               *atom_header, *atom_table, *atom_end;
  2411.     uint32_t              entries;
  2412.     ngx_buf_t            *atom, *data;
  2413.     ngx_mp4_ctts_atom_t  *ctts_atom;
  2414.     ngx_http_mp4_trak_t  *trak;

  2416.     /* composition offsets atom */

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

  2420.     atom_header = ngx_mp4_atom_header(mp4);
  2421.     ctts_atom = (ngx_mp4_ctts_atom_t *) atom_header;
  2422.     ngx_mp4_set_atom_name(ctts_atom, 'c', 't', 't', 's');

  2424.     if (ngx_mp4_atom_data_size(ngx_mp4_ctts_atom_t) > atom_data_size) {
  2425.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2426.                       "\"%s\" mp4 ctts atom too small", mp4->file.name.data);
  2427.         return NGX_ERROR;
  2428.     }

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

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

  2435.     trak = ngx_mp4_last_trak(mp4);
  2436.     trak->composition_offset_entries = entries;

  2438.     atom_table = atom_header + sizeof(ngx_mp4_ctts_atom_t);

  2440.     atom = &trak->ctts_atom_buf;
  2441.     atom->temporary = 1;
  2442.     atom->pos = atom_header;
  2443.     atom->last = atom_table;

  2445.     if (ngx_mp4_atom_data_size(ngx_mp4_ctts_atom_t)
  2446.         + entries * sizeof(ngx_mp4_ctts_entry_t) > atom_data_size)
  2447.     {
  2448.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2449.                       "\"%s\" mp4 ctts atom too small", mp4->file.name.data);
  2450.         return NGX_ERROR;
  2451.     }

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

  2455.     data = &trak->ctts_data_buf;
  2456.     data->temporary = 1;
  2457.     data->pos = atom_table;
  2458.     data->last = atom_end;

  2460.     trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf = atom;
  2461.     trak->out[NGX_HTTP_MP4_CTTS_DATA].buf = data;

  2463.     ngx_mp4_atom_next(mp4, atom_data_size);

  2465.     return NGX_OK;
  2466. }


  2469. static void
  2470. ‌ngx_http_mp4_update_ctts_atom(ngx_http_mp4_file_t *mp4,
  2471.     ngx_http_mp4_trak_t *trak)
  2472. {
  2473.     size_t                atom_size;
  2474.     ngx_buf_t            *atom, *data;
  2475.     ngx_mp4_ctts_atom_t  *ctts_atom;

  2477.     /*
  2478.      * mdia.minf.stbl.ctts updating requires trak->start_sample
  2479.      * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
  2480.      * atom which may reside after mdia.minf
  2481.      */

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

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

  2488.     if (data == NULL) {
  2489.         return;
  2490.     }

  2492.     ngx_http_mp4_crop_ctts_data(mp4, trak, 1);
  2493.     ngx_http_mp4_crop_ctts_data(mp4, trak, 0);

  2495.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2496.                    "composition offset entries:%uD",
  2497.                    trak->composition_offset_entries);

  2499.     if (trak->composition_offset_entries == 0) {
  2500.         trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf = NULL;
  2501.         trak->out[NGX_HTTP_MP4_CTTS_DATA].buf = NULL;
  2502.         return;
  2503.     }

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

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

  2511.     ngx_mp4_set_32value(ctts_atom->size, atom_size);
  2512.     ngx_mp4_set_32value(ctts_atom->entries, trak->composition_offset_entries);

  2514.     return;
  2515. }


  2518. static void
  2519. ‌ngx_http_mp4_crop_ctts_data(ngx_http_mp4_file_t *mp4,
  2520.     ngx_http_mp4_trak_t *trak, ngx_uint_t start)
  2521. {
  2522.     uint32_t               count, start_sample, rest;
  2523.     ngx_buf_t             *data;
  2524.     ngx_uint_t             entries;
  2525.     ngx_mp4_ctts_entry_t  *entry, *end;

  2527.     /* sync samples starts from 1 */

  2529.     if (start) {
  2530.         start_sample = trak->start_sample + 1;

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

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

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

  2541.     } else {
  2542.         return;
  2543.     }

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

  2547.     entries = trak->composition_offset_entries;
  2548.     entry = (ngx_mp4_ctts_entry_t *) data->pos;
  2549.     end = (ngx_mp4_ctts_entry_t *) data->last;

  2551.     while (entry < end) {
  2552.         count = ngx_mp4_get_32value(entry->count);

  2554.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2555.                        "sample:%uD, count:%uD, offset:%uD",
  2556.                        start_sample, count, ngx_mp4_get_32value(entry->offset));

  2558.          if (start_sample <= count) {
  2559.              rest = start_sample - 1;
  2560.              goto found;
  2561.          }

  2563.          start_sample -= count;
  2564.          entries--;
  2565.          entry++;
  2566.     }

  2568.     if (start) {
  2569.         data->pos = (u_char *) end;
  2570.         trak->composition_offset_entries = 0;
  2571.     }

  2573.     return;

  2575. found:

  2577.     if (start) {
  2578.         ngx_mp4_set_32value(entry->count, count - rest);
  2579.         data->pos = (u_char *) entry;
  2580.         trak->composition_offset_entries = entries;

  2582.     } else {
  2583.         ngx_mp4_set_32value(entry->count, rest);
  2584.         data->last = (u_char *) (entry + 1);
  2585.         trak->composition_offset_entries -= entries - 1;
  2586.     }
  2587. }


  2590. typedef struct {
  2591.     u_char    size[4];
  2592.     u_char    name[4];
  2593.     u_char    version[1];
  2594.     u_char    flags[3];
  2595.     u_char    entries[4];
  2596. ‌} ngx_mp4_stsc_atom_t;


  2599. static ngx_int_t
  2600. ‌ngx_http_mp4_read_stsc_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2601. {
  2602.     u_char               *atom_header, *atom_table, *atom_end;
  2603.     uint32_t              entries;
  2604.     ngx_buf_t            *atom, *data;
  2605.     ngx_mp4_stsc_atom_t  *stsc_atom;
  2606.     ngx_http_mp4_trak_t  *trak;

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

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

  2612.     atom_header = ngx_mp4_atom_header(mp4);
  2613.     stsc_atom = (ngx_mp4_stsc_atom_t *) atom_header;
  2614.     ngx_mp4_set_atom_name(stsc_atom, 's', 't', 's', 'c');

  2616.     if (ngx_mp4_atom_data_size(ngx_mp4_stsc_atom_t) > atom_data_size) {
  2617.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2618.                       "\"%s\" mp4 stsc atom too small", mp4->file.name.data);
  2619.         return NGX_ERROR;
  2620.     }

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

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

  2627.     if (ngx_mp4_atom_data_size(ngx_mp4_stsc_atom_t)
  2628.         + entries * sizeof(ngx_mp4_stsc_entry_t) > atom_data_size)
  2629.     {
  2630.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2631.                       "\"%s\" mp4 stsc atom too small", mp4->file.name.data);
  2632.         return NGX_ERROR;
  2633.     }

  2635.     atom_table = atom_header + sizeof(ngx_mp4_stsc_atom_t);
  2636.     atom_end = atom_table + entries * sizeof(ngx_mp4_stsc_entry_t);

  2638.     trak = ngx_mp4_last_trak(mp4);
  2639.     trak->sample_to_chunk_entries = entries;

  2641.     atom = &trak->stsc_atom_buf;
  2642.     atom->temporary = 1;
  2643.     atom->pos = atom_header;
  2644.     atom->last = atom_table;

  2646.     data = &trak->stsc_data_buf;
  2647.     data->temporary = 1;
  2648.     data->pos = atom_table;
  2649.     data->last = atom_end;

  2651.     trak->out[NGX_HTTP_MP4_STSC_ATOM].buf = atom;
  2652.     trak->out[NGX_HTTP_MP4_STSC_DATA].buf = data;

  2654.     ngx_mp4_atom_next(mp4, atom_data_size);

  2656.     return NGX_OK;
  2657. }


  2660. static ngx_int_t
  2661. ‌ngx_http_mp4_update_stsc_atom(ngx_http_mp4_file_t *mp4,
  2662.     ngx_http_mp4_trak_t *trak)
  2663. {
  2664.     size_t                 atom_size;
  2665.     uint32_t               chunk;
  2666.     ngx_buf_t             *atom, *data;
  2667.     ngx_mp4_stsc_atom_t   *stsc_atom;
  2668.     ngx_mp4_stsc_entry_t  *entry, *end;

  2670.     /*
  2671.      * mdia.minf.stbl.stsc updating requires trak->start_sample
  2672.      * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
  2673.      * atom which may reside after mdia.minf
  2674.      */

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

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

  2681.     if (data == NULL) {
  2682.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2683.                       "no mp4 stsc atoms were found in \"%s\"",
  2684.                       mp4->file.name.data);
  2685.         return NGX_ERROR;
  2686.     }

  2688.     if (trak->sample_to_chunk_entries == 0) {
  2689.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2690.                       "zero number of entries in stsc atom in \"%s\"",
  2691.                       mp4->file.name.data);
  2692.         return NGX_ERROR;
  2693.     }

  2695.     if (ngx_http_mp4_crop_stsc_data(mp4, trak, 1) != NGX_OK) {
  2696.         return NGX_ERROR;
  2697.     }

  2699.     if (ngx_http_mp4_crop_stsc_data(mp4, trak, 0) != NGX_OK) {
  2700.         return NGX_ERROR;
  2701.     }

  2703.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2704.                    "sample-to-chunk entries:%uD",
  2705.                    trak->sample_to_chunk_entries);

  2707.     entry = (ngx_mp4_stsc_entry_t *) data->pos;
  2708.     end = (ngx_mp4_stsc_entry_t *) data->last;

  2710.     while (entry < end) {
  2711.         chunk = ngx_mp4_get_32value(entry->chunk);
  2712.         chunk -= trak->start_chunk;
  2713.         ngx_mp4_set_32value(entry->chunk, chunk);
  2714.         entry++;
  2715.     }

  2717.     atom_size = sizeof(ngx_mp4_stsc_atom_t)
  2718.                 + trak->sample_to_chunk_entries * sizeof(ngx_mp4_stsc_entry_t);

  2720.     trak->size += atom_size;

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

  2725.     ngx_mp4_set_32value(stsc_atom->size, atom_size);
  2726.     ngx_mp4_set_32value(stsc_atom->entries, trak->sample_to_chunk_entries);

  2728.     return NGX_OK;
  2729. }


  2732. static ngx_int_t
  2733. ‌ngx_http_mp4_crop_stsc_data(ngx_http_mp4_file_t *mp4,
  2734.     ngx_http_mp4_trak_t *trak, ngx_uint_t start)
  2735. {
  2736.     uint32_t               start_sample, chunk, samples, id, next_chunk, n,
  2737.                            prev_samples;
  2738.     ngx_buf_t             *data, *buf;
  2739.     ngx_uint_t             entries, target_chunk, chunk_samples;
  2740.     ngx_mp4_stsc_entry_t  *entry, *end, *first;

  2742.     entries = trak->sample_to_chunk_entries - 1;

  2744.     if (start) {
  2745.         start_sample = (uint32_t) trak->start_sample;

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

  2750.     } else if (mp4->length) {
  2751.         start_sample = (uint32_t) (trak->end_sample - trak->start_sample);
  2752.         samples = 0;

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

  2756.         if (data) {
  2757.             entry = (ngx_mp4_stsc_entry_t *) data->pos;
  2758.             samples = ngx_mp4_get_32value(entry->samples);
  2759.             entries--;

  2761.             if (samples > start_sample) {
  2762.                 samples = start_sample;
  2763.                 ngx_mp4_set_32value(entry->samples, samples);
  2764.             }

  2766.             start_sample -= samples;
  2767.         }

  2769.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2770.                        "mp4 stsc crop end_sample:%uD, ext_samples:%uD",
  2771.                        start_sample, samples);

  2773.     } else {
  2774.         return NGX_OK;
  2775.     }

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

  2779.     entry = (ngx_mp4_stsc_entry_t *) data->pos;
  2780.     end = (ngx_mp4_stsc_entry_t *) data->last;

  2782.     chunk = ngx_mp4_get_32value(entry->chunk);
  2783.     samples = ngx_mp4_get_32value(entry->samples);
  2784.     id = ngx_mp4_get_32value(entry->id);
  2785.     prev_samples = 0;
  2786.     entry++;

  2788.     while (entry < end) {

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

  2792.         ngx_log_debug5(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2793.                        "sample:%uD, chunk:%uD, chunks:%uD, "
  2794.                        "samples:%uD, id:%uD",
  2795.                        start_sample, chunk, next_chunk - chunk, samples, id);

  2797.         n = (next_chunk - chunk) * samples;

  2799.         if (start_sample < n) {
  2800.             goto found;
  2801.         }

  2803.         start_sample -= n;

  2805.         prev_samples = samples;
  2806.         chunk = next_chunk;
  2807.         samples = ngx_mp4_get_32value(entry->samples);
  2808.         id = ngx_mp4_get_32value(entry->id);
  2809.         entries--;
  2810.         entry++;
  2811.     }

  2813.     next_chunk = trak->chunks + 1;

  2815.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2816.                    "sample:%uD, chunk:%uD, chunks:%uD, samples:%uD",
  2817.                    start_sample, chunk, next_chunk - chunk, samples);

  2819.     n = (next_chunk - chunk) * samples;

  2821.     if (start_sample > n) {
  2822.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2823.                       "%s time is out mp4 stsc chunks in \"%s\"",
  2824.                       start ? "start" : "end", mp4->file.name.data);
  2825.         return NGX_ERROR;
  2826.     }

  2828. found:

  2830.     entries++;
  2831.     entry--;

  2833.     if (samples == 0) {
  2834.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2835.                       "zero number of samples in \"%s\"",
  2836.                       mp4->file.name.data);
  2837.         return NGX_ERROR;
  2838.     }

  2840.     target_chunk = chunk - 1;
  2841.     target_chunk += start_sample / samples;
  2842.     chunk_samples = start_sample % samples;

  2844.     if (start) {
  2845.         data->pos = (u_char *) entry;

  2847.         trak->sample_to_chunk_entries = entries;
  2848.         trak->start_chunk = target_chunk;
  2849.         trak->start_chunk_samples = chunk_samples;

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

  2853.         samples -= chunk_samples;

  2855.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2856.                        "start_chunk:%ui, start_chunk_samples:%ui",
  2857.                        trak->start_chunk, trak->start_chunk_samples);

  2859.     } else {
  2860.         if (start_sample) {
  2861.             data->last = (u_char *) (entry + 1);
  2862.             trak->sample_to_chunk_entries -= entries - 1;
  2863.             trak->end_chunk_samples = samples;

  2865.         } else {
  2866.             data->last = (u_char *) entry;
  2867.             trak->sample_to_chunk_entries -= entries;
  2868.             trak->end_chunk_samples = prev_samples;
  2869.         }

  2871.         if (chunk_samples) {
  2872.             trak->end_chunk = target_chunk + 1;
  2873.             trak->end_chunk_samples = chunk_samples;

  2875.         } else {
  2876.             trak->end_chunk = target_chunk;
  2877.         }

  2879.         samples = chunk_samples;
  2880.         next_chunk = chunk + 1;

  2882.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  2883.                        "end_chunk:%ui, end_chunk_samples:%ui",
  2884.                        trak->end_chunk, trak->end_chunk_samples);
  2885.     }

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

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

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

  2893.         first = &trak->stsc_start_chunk_entry;
  2894.         ngx_mp4_set_32value(first->chunk, 1);
  2895.         ngx_mp4_set_32value(first->samples, samples);
  2896.         ngx_mp4_set_32value(first->id, id);

  2898.         buf = &trak->stsc_start_chunk_buf;
  2899.         buf->temporary = 1;
  2900.         buf->pos = (u_char *) first;
  2901.         buf->last = (u_char *) first + sizeof(ngx_mp4_stsc_entry_t);

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

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

  2907.         trak->sample_to_chunk_entries++;

  2909.     } else if (chunk_samples) {

  2911.         first = &trak->stsc_end_chunk_entry;
  2912.         ngx_mp4_set_32value(first->chunk, trak->end_chunk - trak->start_chunk);
  2913.         ngx_mp4_set_32value(first->samples, samples);
  2914.         ngx_mp4_set_32value(first->id, id);

  2916.         buf = &trak->stsc_end_chunk_buf;
  2917.         buf->temporary = 1;
  2918.         buf->pos = (u_char *) first;
  2919.         buf->last = (u_char *) first + sizeof(ngx_mp4_stsc_entry_t);

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

  2923.         trak->sample_to_chunk_entries++;
  2924.     }

  2926.     return NGX_OK;
  2927. }


  2930. typedef struct {
  2931.     u_char    size[4];
  2932.     u_char    name[4];
  2933.     u_char    version[1];
  2934.     u_char    flags[3];
  2935.     u_char    uniform_size[4];
  2936.     u_char    entries[4];
  2937. ‌} ngx_mp4_stsz_atom_t;


  2940. static ngx_int_t
  2941. ‌ngx_http_mp4_read_stsz_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  2942. {
  2943.     u_char               *atom_header, *atom_table, *atom_end;
  2944.     size_t                atom_size;
  2945.     uint32_t              entries, size;
  2946.     ngx_buf_t            *atom, *data;
  2947.     ngx_mp4_stsz_atom_t  *stsz_atom;
  2948.     ngx_http_mp4_trak_t  *trak;

  2950.     /* sample sizes atom */

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

  2954.     atom_header = ngx_mp4_atom_header(mp4);
  2955.     stsz_atom = (ngx_mp4_stsz_atom_t *) atom_header;
  2956.     ngx_mp4_set_atom_name(stsz_atom, 's', 't', 's', 'z');

  2958.     if (ngx_mp4_atom_data_size(ngx_mp4_stsz_atom_t) > atom_data_size) {
  2959.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2960.                       "\"%s\" mp4 stsz atom too small", mp4->file.name.data);
  2961.         return NGX_ERROR;
  2962.     }

  2964.     size = ngx_mp4_get_32value(stsz_atom->uniform_size);
  2965.     entries = ngx_mp4_get_32value(stsz_atom->entries);

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

  2970.     trak = ngx_mp4_last_trak(mp4);
  2971.     trak->sample_sizes_entries = entries;

  2973.     atom_table = atom_header + sizeof(ngx_mp4_stsz_atom_t);

  2975.     atom = &trak->stsz_atom_buf;
  2976.     atom->temporary = 1;
  2977.     atom->pos = atom_header;
  2978.     atom->last = atom_table;

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

  2982.     if (size == 0) {
  2983.         if (ngx_mp4_atom_data_size(ngx_mp4_stsz_atom_t)
  2984.             + entries * sizeof(uint32_t) > atom_data_size)
  2985.         {
  2986.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  2987.                           "\"%s\" mp4 stsz atom too small",
  2988.                           mp4->file.name.data);
  2989.             return NGX_ERROR;
  2990.         }

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

  2994.         data = &trak->stsz_data_buf;
  2995.         data->temporary = 1;
  2996.         data->pos = atom_table;
  2997.         data->last = atom_end;

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

  3001.     } else {
  3002.         /* if size != 0 then all samples are the same size */
  3003.         /* TODO : chunk samples */
  3004.         atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
  3005.         ngx_mp4_set_32value(atom_header, atom_size);
  3006.         trak->size += atom_size;
  3007.     }

  3009.     ngx_mp4_atom_next(mp4, atom_data_size);

  3011.     return NGX_OK;
  3012. }


  3015. static ngx_int_t
  3016. ‌ngx_http_mp4_update_stsz_atom(ngx_http_mp4_file_t *mp4,
  3017.     ngx_http_mp4_trak_t *trak)
  3018. {
  3019.     size_t                atom_size;
  3020.     uint32_t             *pos, *end, entries;
  3021.     ngx_buf_t            *atom, *data;
  3022.     ngx_mp4_stsz_atom_t  *stsz_atom;

  3024.     /*
  3025.      * mdia.minf.stbl.stsz updating requires trak->start_sample
  3026.      * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
  3027.      * atom which may reside after mdia.minf
  3028.      */

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

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

  3035.     if (data) {
  3036.         entries = trak->sample_sizes_entries;

  3038.         if (trak->start_sample > entries) {
  3039.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3040.                           "start time is out mp4 stsz samples in \"%s\"",
  3041.                           mp4->file.name.data);
  3042.             return NGX_ERROR;
  3043.         }

  3045.         entries -= trak->start_sample;
  3046.         data->pos += trak->start_sample * sizeof(uint32_t);
  3047.         end = (uint32_t *) data->pos;

  3049.         for (pos = end - trak->start_chunk_samples; pos < end; pos++) {
  3050.             trak->start_chunk_samples_size += ngx_mp4_get_32value(pos);
  3051.         }

  3053.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3054.                        "chunk samples sizes:%uL",
  3055.                        trak->start_chunk_samples_size);

  3057.         if (mp4->length) {
  3058.             if (trak->end_sample - trak->start_sample > entries) {
  3059.                 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3060.                               "end time is out mp4 stsz samples in \"%s\"",
  3061.                               mp4->file.name.data);
  3062.                 return NGX_ERROR;
  3063.             }

  3065.             entries = trak->end_sample - trak->start_sample;
  3066.             data->last = data->pos + entries * sizeof(uint32_t);
  3067.             end = (uint32_t *) data->last;

  3069.             for (pos = end - trak->end_chunk_samples; pos < end; pos++) {
  3070.                 trak->end_chunk_samples_size += ngx_mp4_get_32value(pos);
  3071.             }

  3073.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3074.                            "mp4 stsz end_chunk_samples_size:%uL",
  3075.                            trak->end_chunk_samples_size);
  3076.         }

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

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

  3084.         ngx_mp4_set_32value(stsz_atom->size, atom_size);
  3085.         ngx_mp4_set_32value(stsz_atom->entries, entries);
  3086.     }

  3088.     return NGX_OK;
  3089. }


  3092. typedef struct {
  3093.     u_char    size[4];
  3094.     u_char    name[4];
  3095.     u_char    version[1];
  3096.     u_char    flags[3];
  3097.     u_char    entries[4];
  3098. ‌} ngx_mp4_stco_atom_t;


  3101. static ngx_int_t
  3102. ‌ngx_http_mp4_read_stco_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  3103. {
  3104.     u_char               *atom_header, *atom_table, *atom_end;
  3105.     uint32_t              entries;
  3106.     ngx_buf_t            *atom, *data;
  3107.     ngx_mp4_stco_atom_t  *stco_atom;
  3108.     ngx_http_mp4_trak_t  *trak;

  3110.     /* chunk offsets atom */

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

  3114.     atom_header = ngx_mp4_atom_header(mp4);
  3115.     stco_atom = (ngx_mp4_stco_atom_t *) atom_header;
  3116.     ngx_mp4_set_atom_name(stco_atom, 's', 't', 'c', 'o');

  3118.     if (ngx_mp4_atom_data_size(ngx_mp4_stco_atom_t) > atom_data_size) {
  3119.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3120.                       "\"%s\" mp4 stco atom too small", mp4->file.name.data);
  3121.         return NGX_ERROR;
  3122.     }

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

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

  3128.     if (ngx_mp4_atom_data_size(ngx_mp4_stco_atom_t)
  3129.         + entries * sizeof(uint32_t) > atom_data_size)
  3130.     {
  3131.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3132.                       "\"%s\" mp4 stco atom too small", mp4->file.name.data);
  3133.         return NGX_ERROR;
  3134.     }

  3136.     atom_table = atom_header + sizeof(ngx_mp4_stco_atom_t);
  3137.     atom_end = atom_table + entries * sizeof(uint32_t);

  3139.     trak = ngx_mp4_last_trak(mp4);
  3140.     trak->chunks = entries;

  3142.     atom = &trak->stco_atom_buf;
  3143.     atom->temporary = 1;
  3144.     atom->pos = atom_header;
  3145.     atom->last = atom_table;

  3147.     data = &trak->stco_data_buf;
  3148.     data->temporary = 1;
  3149.     data->pos = atom_table;
  3150.     data->last = atom_end;

  3152.     trak->out[NGX_HTTP_MP4_STCO_ATOM].buf = atom;
  3153.     trak->out[NGX_HTTP_MP4_STCO_DATA].buf = data;

  3155.     ngx_mp4_atom_next(mp4, atom_data_size);

  3157.     return NGX_OK;
  3158. }


  3161. static ngx_int_t
  3162. ‌ngx_http_mp4_update_stco_atom(ngx_http_mp4_file_t *mp4,
  3163.     ngx_http_mp4_trak_t *trak)
  3164. {
  3165.     size_t                atom_size;
  3166.     uint32_t              entries;
  3167.     ngx_buf_t            *atom, *data;
  3168.     ngx_mp4_stco_atom_t  *stco_atom;

  3170.     /*
  3171.      * mdia.minf.stbl.stco updating requires trak->start_chunk
  3172.      * from mdia.minf.stbl.stsc which depends on value from mdia.mdhd
  3173.      * atom which may reside after mdia.minf
  3174.      */

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

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

  3181.     if (data == NULL) {
  3182.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3183.                       "no mp4 stco atoms were found in \"%s\"",
  3184.                       mp4->file.name.data);
  3185.         return NGX_ERROR;
  3186.     }

  3188.     if (trak->start_chunk > trak->chunks) {
  3189.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3190.                       "start time is out mp4 stco chunks in \"%s\"",
  3191.                       mp4->file.name.data);
  3192.         return NGX_ERROR;
  3193.     }

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

  3197.     trak->start_offset = ngx_mp4_get_32value(data->pos);
  3198.     trak->start_offset += trak->start_chunk_samples_size;
  3199.     ngx_mp4_set_32value(data->pos, trak->start_offset);

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

  3204.     if (mp4->length) {

  3206.         if (trak->end_chunk > trak->chunks) {
  3207.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3208.                           "end time is out mp4 stco chunks in \"%s\"",
  3209.                           mp4->file.name.data);
  3210.             return NGX_ERROR;
  3211.         }

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

  3216.         if (entries) {
  3217.             trak->end_offset =
  3218.                             ngx_mp4_get_32value(data->last - sizeof(uint32_t));
  3219.             trak->end_offset += trak->end_chunk_samples_size;

  3221.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3222.                            "end chunk offset:%O", trak->end_offset);
  3223.         }

  3225.     } else {
  3226.         entries = trak->chunks - trak->start_chunk;
  3227.         trak->end_offset = mp4->mdat_data.buf->file_last;
  3228.     }

  3230.     if (entries == 0) {
  3231.         trak->start_offset = mp4->end;
  3232.         trak->end_offset = 0;
  3233.     }

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

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

  3241.     ngx_mp4_set_32value(stco_atom->size, atom_size);
  3242.     ngx_mp4_set_32value(stco_atom->entries, entries);

  3244.     return NGX_OK;
  3245. }


  3248. static void
  3249. ‌ngx_http_mp4_adjust_stco_atom(ngx_http_mp4_file_t *mp4,
  3250.     ngx_http_mp4_trak_t *trak, int32_t adjustment)
  3251. {
  3252.     uint32_t    offset, *entry, *end;
  3253.     ngx_buf_t  *data;

  3255.     /*
  3256.      * moov.trak.mdia.minf.stbl.stco adjustment requires
  3257.      * minimal start offset of all traks and new moov atom size
  3258.      */

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

  3263.     data = trak->out[NGX_HTTP_MP4_STCO_DATA].buf;
  3264.     entry = (uint32_t *) data->pos;
  3265.     end = (uint32_t *) data->last;

  3267.     while (entry < end) {
  3268.         offset = ngx_mp4_get_32value(entry);
  3269.         offset += adjustment;
  3270.         ngx_mp4_set_32value(entry, offset);
  3271.         entry++;
  3272.     }
  3273. }


  3276. typedef struct {
  3277.     u_char    size[4];
  3278.     u_char    name[4];
  3279.     u_char    version[1];
  3280.     u_char    flags[3];
  3281.     u_char    entries[4];
  3282. ‌} ngx_mp4_co64_atom_t;


  3285. static ngx_int_t
  3286. ‌ngx_http_mp4_read_co64_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
  3287. {
  3288.     u_char               *atom_header, *atom_table, *atom_end;
  3289.     uint32_t              entries;
  3290.     ngx_buf_t            *atom, *data;
  3291.     ngx_mp4_co64_atom_t  *co64_atom;
  3292.     ngx_http_mp4_trak_t  *trak;

  3294.     /* chunk offsets atom */

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

  3298.     atom_header = ngx_mp4_atom_header(mp4);
  3299.     co64_atom = (ngx_mp4_co64_atom_t *) atom_header;
  3300.     ngx_mp4_set_atom_name(co64_atom, 'c', 'o', '6', '4');

  3302.     if (ngx_mp4_atom_data_size(ngx_mp4_co64_atom_t) > atom_data_size) {
  3303.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3304.                       "\"%s\" mp4 co64 atom too small", mp4->file.name.data);
  3305.         return NGX_ERROR;
  3306.     }

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

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

  3312.     if (ngx_mp4_atom_data_size(ngx_mp4_co64_atom_t)
  3313.         + entries * sizeof(uint64_t) > atom_data_size)
  3314.     {
  3315.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3316.                       "\"%s\" mp4 co64 atom too small", mp4->file.name.data);
  3317.         return NGX_ERROR;
  3318.     }

  3320.     atom_table = atom_header + sizeof(ngx_mp4_co64_atom_t);
  3321.     atom_end = atom_table + entries * sizeof(uint64_t);

  3323.     trak = ngx_mp4_last_trak(mp4);
  3324.     trak->chunks = entries;

  3326.     atom = &trak->co64_atom_buf;
  3327.     atom->temporary = 1;
  3328.     atom->pos = atom_header;
  3329.     atom->last = atom_table;

  3331.     data = &trak->co64_data_buf;
  3332.     data->temporary = 1;
  3333.     data->pos = atom_table;
  3334.     data->last = atom_end;

  3336.     trak->out[NGX_HTTP_MP4_CO64_ATOM].buf = atom;
  3337.     trak->out[NGX_HTTP_MP4_CO64_DATA].buf = data;

  3339.     ngx_mp4_atom_next(mp4, atom_data_size);

  3341.     return NGX_OK;
  3342. }


  3345. static ngx_int_t
  3346. ‌ngx_http_mp4_update_co64_atom(ngx_http_mp4_file_t *mp4,
  3347.     ngx_http_mp4_trak_t *trak)
  3348. {
  3349.     size_t                atom_size;
  3350.     uint64_t              entries;
  3351.     ngx_buf_t            *atom, *data;
  3352.     ngx_mp4_co64_atom_t  *co64_atom;

  3354.     /*
  3355.      * mdia.minf.stbl.co64 updating requires trak->start_chunk
  3356.      * from mdia.minf.stbl.stsc which depends on value from mdia.mdhd
  3357.      * atom which may reside after mdia.minf
  3358.      */

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

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

  3365.     if (data == NULL) {
  3366.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3367.                       "no mp4 co64 atoms were found in \"%s\"",
  3368.                       mp4->file.name.data);
  3369.         return NGX_ERROR;
  3370.     }

  3372.     if (trak->start_chunk > trak->chunks) {
  3373.         ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3374.                       "start time is out mp4 co64 chunks in \"%s\"",
  3375.                       mp4->file.name.data);
  3376.         return NGX_ERROR;
  3377.     }

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

  3381.     trak->start_offset = ngx_mp4_get_64value(data->pos);
  3382.     trak->start_offset += trak->start_chunk_samples_size;
  3383.     ngx_mp4_set_64value(data->pos, trak->start_offset);

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

  3388.     if (mp4->length) {

  3390.         if (trak->end_chunk > trak->chunks) {
  3391.             ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
  3392.                           "end time is out mp4 co64 chunks in \"%s\"",
  3393.                           mp4->file.name.data);
  3394.             return NGX_ERROR;
  3395.         }

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

  3400.         if (entries) {
  3401.             trak->end_offset =
  3402.                             ngx_mp4_get_64value(data->last - sizeof(uint64_t));
  3403.             trak->end_offset += trak->end_chunk_samples_size;

  3405.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
  3406.                            "end chunk offset:%O", trak->end_offset);
  3407.         }

  3409.     } else {
  3410.         entries = trak->chunks - trak->start_chunk;
  3411.         trak->end_offset = mp4->mdat_data.buf->file_last;
  3412.     }

  3414.     if (entries == 0) {
  3415.         trak->start_offset = mp4->end;
  3416.         trak->end_offset = 0;
  3417.     }

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

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

  3425.     ngx_mp4_set_32value(co64_atom->size, atom_size);
  3426.     ngx_mp4_set_32value(co64_atom->entries, entries);

  3428.     return NGX_OK;
  3429. }


  3432. static void
  3433. ‌ngx_http_mp4_adjust_co64_atom(ngx_http_mp4_file_t *mp4,
  3434.     ngx_http_mp4_trak_t *trak, off_t adjustment)
  3435. {
  3436.     uint64_t    offset, *entry, *end;
  3437.     ngx_buf_t  *data;

  3439.     /*
  3440.      * moov.trak.mdia.minf.stbl.co64 adjustment requires
  3441.      * minimal start offset of all traks and new moov atom size
  3442.      */

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

  3447.     data = trak->out[NGX_HTTP_MP4_CO64_DATA].buf;
  3448.     entry = (uint64_t *) data->pos;
  3449.     end = (uint64_t *) data->last;

  3451.     while (entry < end) {
  3452.         offset = ngx_mp4_get_64value(entry);
  3453.         offset += adjustment;
  3454.         ngx_mp4_set_64value(entry, offset);
  3455.         entry++;
  3456.     }
  3457. }


  3460. static char *
  3461. ‌ngx_http_mp4(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3462. {
  3463.     ngx_http_core_loc_conf_t  *clcf;

  3465.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  3466.     clcf->handler = ngx_http_mp4_handler;

  3468.     return NGX_CONF_OK;
  3469. }


  3472. static void *
  3473. ‌ngx_http_mp4_create_conf(ngx_conf_t *cf)
  3474. {
  3475.     ngx_http_mp4_conf_t  *conf;

  3477.     conf = ngx_palloc(cf->pool, sizeof(ngx_http_mp4_conf_t));
  3478.     if (conf == NULL) {
  3479.         return NULL;
  3480.     }

  3482.     conf->buffer_size = NGX_CONF_UNSET_SIZE;
  3483.     conf->max_buffer_size = NGX_CONF_UNSET_SIZE;

  3485.     return conf;
  3486. }


  3489. static char *
  3490. ‌ngx_http_mp4_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  3491. {
  3492.     ngx_http_mp4_conf_t *prev = parent;
  3493.     ngx_http_mp4_conf_t *conf = child;

  3495.     ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size, 512 * 1024);
  3496.     ngx_conf_merge_size_value(conf->max_buffer_size, prev->max_buffer_size,
  3497.                               10 * 1024 * 1024);

  3499.     return NGX_CONF_OK;
  3500. }

One Level Up Top Level