?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update and clean Tomato RAF files
[tomato.git] / release / src / router / nginx / src / http / modules / ngx_http_mp4_module.c
blob20ef51af2b648c5a97a2ff78b3609d01d0aca3d6
1
2 /*
3 * Copyright (C) Igor Sysoev
4 * Copyright (C) Nginx, Inc.
5 */
6
7 #include <ngx_config.h>
8 #include <ngx_core.h>
9 #include <ngx_http.h>
10
11
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_CHUNK 18
31 #define NGX_HTTP_MP4_STSC_DATA 19
32 #define NGX_HTTP_MP4_STSZ_ATOM 20
33 #define NGX_HTTP_MP4_STSZ_DATA 21
34 #define NGX_HTTP_MP4_STCO_ATOM 22
35 #define NGX_HTTP_MP4_STCO_DATA 23
36 #define NGX_HTTP_MP4_CO64_ATOM 24
37 #define NGX_HTTP_MP4_CO64_DATA 25
38
39 #define NGX_HTTP_MP4_LAST_ATOM NGX_HTTP_MP4_CO64_DATA
40
41
42 typedef struct {
43 size_t buffer_size;
44 size_t max_buffer_size;
45 } ngx_http_mp4_conf_t;
46
47
48 typedef struct {
49 u_char chunk[4];
50 u_char samples[4];
51 u_char id[4];
52 } ngx_mp4_stsc_entry_t;
53
54
55 typedef struct {
56 uint32_t timescale;
57 uint32_t time_to_sample_entries;
58 uint32_t sample_to_chunk_entries;
59 uint32_t sync_samples_entries;
60 uint32_t composition_offset_entries;
61 uint32_t sample_sizes_entries;
62 uint32_t chunks;
63
64 ngx_uint_t start_sample;
65 ngx_uint_t start_chunk;
66 ngx_uint_t chunk_samples;
67 uint64_t chunk_samples_size;
68 off_t start_offset;
69
70 size_t tkhd_size;
71 size_t mdhd_size;
72 size_t hdlr_size;
73 size_t vmhd_size;
74 size_t smhd_size;
75 size_t dinf_size;
76 size_t size;
77
78 ngx_chain_t out[NGX_HTTP_MP4_LAST_ATOM + 1];
79
80 ngx_buf_t trak_atom_buf;
81 ngx_buf_t tkhd_atom_buf;
82 ngx_buf_t mdia_atom_buf;
83 ngx_buf_t mdhd_atom_buf;
84 ngx_buf_t hdlr_atom_buf;
85 ngx_buf_t minf_atom_buf;
86 ngx_buf_t vmhd_atom_buf;
87 ngx_buf_t smhd_atom_buf;
88 ngx_buf_t dinf_atom_buf;
89 ngx_buf_t stbl_atom_buf;
90 ngx_buf_t stsd_atom_buf;
91 ngx_buf_t stts_atom_buf;
92 ngx_buf_t stts_data_buf;
93 ngx_buf_t stss_atom_buf;
94 ngx_buf_t stss_data_buf;
95 ngx_buf_t ctts_atom_buf;
96 ngx_buf_t ctts_data_buf;
97 ngx_buf_t stsc_atom_buf;
98 ngx_buf_t stsc_chunk_buf;
99 ngx_buf_t stsc_data_buf;
100 ngx_buf_t stsz_atom_buf;
101 ngx_buf_t stsz_data_buf;
102 ngx_buf_t stco_atom_buf;
103 ngx_buf_t stco_data_buf;
104 ngx_buf_t co64_atom_buf;
105 ngx_buf_t co64_data_buf;
106
107 ngx_mp4_stsc_entry_t stsc_chunk_entry;
108 } ngx_http_mp4_trak_t;
109
110
111 typedef struct {
112 ngx_file_t file;
113
114 u_char *buffer;
115 u_char *buffer_start;
116 u_char *buffer_pos;
117 u_char *buffer_end;
118 size_t buffer_size;
119
120 off_t offset;
121 off_t end;
122 off_t content_length;
123 ngx_uint_t start;
124 uint32_t timescale;
125 ngx_http_request_t *request;
126 ngx_array_t trak;
127 ngx_http_mp4_trak_t traks[2];
128
129 size_t ftyp_size;
130 size_t moov_size;
131
132 ngx_chain_t *out;
133 ngx_chain_t ftyp_atom;
134 ngx_chain_t moov_atom;
135 ngx_chain_t mvhd_atom;
136 ngx_chain_t mdat_atom;
137 ngx_chain_t mdat_data;
138
139 ngx_buf_t ftyp_atom_buf;
140 ngx_buf_t moov_atom_buf;
141 ngx_buf_t mvhd_atom_buf;
142 ngx_buf_t mdat_atom_buf;
143 ngx_buf_t mdat_data_buf;
144
145 u_char moov_atom_header[8];
146 u_char mdat_atom_header[16];
147 } ngx_http_mp4_file_t;
148
149
150 typedef struct {
151 char *name;
152 ngx_int_t (*handler)(ngx_http_mp4_file_t *mp4,
153 uint64_t atom_data_size);
154 } ngx_http_mp4_atom_handler_t;
155
156
157 #define ngx_mp4_atom_header(mp4) (mp4->buffer_pos - 8)
158 #define ngx_mp4_atom_data(mp4) mp4->buffer_pos
159 #define ngx_mp4_atom_data_size(t) (uint64_t) (sizeof(t) - 8)
160 #define ngx_mp4_atom_next(mp4, n) mp4->buffer_pos += n; mp4->offset += n
161
162
163 #define ngx_mp4_set_atom_name(p, n1, n2, n3, n4) \
164 ((u_char *) (p))[4] = n1; \
165 ((u_char *) (p))[5] = n2; \
166 ((u_char *) (p))[6] = n3; \
167 ((u_char *) (p))[7] = n4
168
169 #define ngx_mp4_get_32value(p) \
170 ( ((uint32_t) ((u_char *) (p))[0] << 24) \
171 + ( ((u_char *) (p))[1] << 16) \
172 + ( ((u_char *) (p))[2] << 8) \
173 + ( ((u_char *) (p))[3]) )
174
175 #define ngx_mp4_set_32value(p, n) \
176 ((u_char *) (p))[0] = (u_char) ((n) >> 24); \
177 ((u_char *) (p))[1] = (u_char) ((n) >> 16); \
178 ((u_char *) (p))[2] = (u_char) ((n) >> 8); \
179 ((u_char *) (p))[3] = (u_char) (n)
180
181 #define ngx_mp4_get_64value(p) \
182 ( ((uint64_t) ((u_char *) (p))[0] << 56) \
183 + ((uint64_t) ((u_char *) (p))[1] << 48) \
184 + ((uint64_t) ((u_char *) (p))[2] << 40) \
185 + ((uint64_t) ((u_char *) (p))[3] << 32) \
186 + ((uint64_t) ((u_char *) (p))[4] << 24) \
187 + ( ((u_char *) (p))[5] << 16) \
188 + ( ((u_char *) (p))[6] << 8) \
189 + ( ((u_char *) (p))[7]) )
190
191 #define ngx_mp4_set_64value(p, n) \
192 ((u_char *) (p))[0] = (u_char) ((uint64_t) (n) >> 56); \
193 ((u_char *) (p))[1] = (u_char) ((uint64_t) (n) >> 48); \
194 ((u_char *) (p))[2] = (u_char) ((uint64_t) (n) >> 40); \
195 ((u_char *) (p))[3] = (u_char) ((uint64_t) (n) >> 32); \
196 ((u_char *) (p))[4] = (u_char) ( (n) >> 24); \
197 ((u_char *) (p))[5] = (u_char) ( (n) >> 16); \
198 ((u_char *) (p))[6] = (u_char) ( (n) >> 8); \
199 ((u_char *) (p))[7] = (u_char) (n)
200
201 #define ngx_mp4_last_trak(mp4) \
202 &((ngx_http_mp4_trak_t *) mp4->trak.elts)[mp4->trak.nelts - 1]
203
204
205 static ngx_int_t ngx_http_mp4_process(ngx_http_mp4_file_t *mp4);
206 static ngx_int_t ngx_http_mp4_read_atom(ngx_http_mp4_file_t *mp4,
207 ngx_http_mp4_atom_handler_t *atom, uint64_t atom_data_size);
208 static ngx_int_t ngx_http_mp4_read(ngx_http_mp4_file_t *mp4, size_t size);
209 static ngx_int_t ngx_http_mp4_read_ftyp_atom(ngx_http_mp4_file_t *mp4,
210 uint64_t atom_data_size);
211 static ngx_int_t ngx_http_mp4_read_moov_atom(ngx_http_mp4_file_t *mp4,
212 uint64_t atom_data_size);
213 static ngx_int_t ngx_http_mp4_read_mdat_atom(ngx_http_mp4_file_t *mp4,
214 uint64_t atom_data_size);
215 static size_t ngx_http_mp4_update_mdat_atom(ngx_http_mp4_file_t *mp4,
216 off_t start_offset);
217 static ngx_int_t ngx_http_mp4_read_mvhd_atom(ngx_http_mp4_file_t *mp4,
218 uint64_t atom_data_size);
219 static ngx_int_t ngx_http_mp4_read_trak_atom(ngx_http_mp4_file_t *mp4,
220 uint64_t atom_data_size);
221 static void ngx_http_mp4_update_trak_atom(ngx_http_mp4_file_t *mp4,
222 ngx_http_mp4_trak_t *trak);
223 static ngx_int_t ngx_http_mp4_read_cmov_atom(ngx_http_mp4_file_t *mp4,
224 uint64_t atom_data_size);
225 static ngx_int_t ngx_http_mp4_read_tkhd_atom(ngx_http_mp4_file_t *mp4,
226 uint64_t atom_data_size);
227 static ngx_int_t ngx_http_mp4_read_mdia_atom(ngx_http_mp4_file_t *mp4,
228 uint64_t atom_data_size);
229 static void ngx_http_mp4_update_mdia_atom(ngx_http_mp4_file_t *mp4,
230 ngx_http_mp4_trak_t *trak);
231 static ngx_int_t ngx_http_mp4_read_mdhd_atom(ngx_http_mp4_file_t *mp4,
232 uint64_t atom_data_size);
233 static ngx_int_t ngx_http_mp4_read_hdlr_atom(ngx_http_mp4_file_t *mp4,
234 uint64_t atom_data_size);
235 static ngx_int_t ngx_http_mp4_read_minf_atom(ngx_http_mp4_file_t *mp4,
236 uint64_t atom_data_size);
237 static void ngx_http_mp4_update_minf_atom(ngx_http_mp4_file_t *mp4,
238 ngx_http_mp4_trak_t *trak);
239 static ngx_int_t ngx_http_mp4_read_dinf_atom(ngx_http_mp4_file_t *mp4,
240 uint64_t atom_data_size);
241 static ngx_int_t ngx_http_mp4_read_vmhd_atom(ngx_http_mp4_file_t *mp4,
242 uint64_t atom_data_size);
243 static ngx_int_t ngx_http_mp4_read_smhd_atom(ngx_http_mp4_file_t *mp4,
244 uint64_t atom_data_size);
245 static ngx_int_t ngx_http_mp4_read_stbl_atom(ngx_http_mp4_file_t *mp4,
246 uint64_t atom_data_size);
247 static void ngx_http_mp4_update_stbl_atom(ngx_http_mp4_file_t *mp4,
248 ngx_http_mp4_trak_t *trak);
249 static ngx_int_t ngx_http_mp4_read_stsd_atom(ngx_http_mp4_file_t *mp4,
250 uint64_t atom_data_size);
251 static ngx_int_t ngx_http_mp4_read_stts_atom(ngx_http_mp4_file_t *mp4,
252 uint64_t atom_data_size);
253 static ngx_int_t ngx_http_mp4_update_stts_atom(ngx_http_mp4_file_t *mp4,
254 ngx_http_mp4_trak_t *trak);
255 static ngx_int_t ngx_http_mp4_read_stss_atom(ngx_http_mp4_file_t *mp4,
256 uint64_t atom_data_size);
257 static ngx_int_t ngx_http_mp4_update_stss_atom(ngx_http_mp4_file_t *mp4,
258 ngx_http_mp4_trak_t *trak);
259 static ngx_int_t ngx_http_mp4_read_ctts_atom(ngx_http_mp4_file_t *mp4,
260 uint64_t atom_data_size);
261 static void ngx_http_mp4_update_ctts_atom(ngx_http_mp4_file_t *mp4,
262 ngx_http_mp4_trak_t *trak);
263 static ngx_int_t ngx_http_mp4_read_stsc_atom(ngx_http_mp4_file_t *mp4,
264 uint64_t atom_data_size);
265 static ngx_int_t ngx_http_mp4_update_stsc_atom(ngx_http_mp4_file_t *mp4,
266 ngx_http_mp4_trak_t *trak);
267 static ngx_int_t ngx_http_mp4_read_stsz_atom(ngx_http_mp4_file_t *mp4,
268 uint64_t atom_data_size);
269 static ngx_int_t ngx_http_mp4_update_stsz_atom(ngx_http_mp4_file_t *mp4,
270 ngx_http_mp4_trak_t *trak);
271 static ngx_int_t ngx_http_mp4_read_stco_atom(ngx_http_mp4_file_t *mp4,
272 uint64_t atom_data_size);
273 static ngx_int_t ngx_http_mp4_update_stco_atom(ngx_http_mp4_file_t *mp4,
274 ngx_http_mp4_trak_t *trak);
275 static void ngx_http_mp4_adjust_stco_atom(ngx_http_mp4_file_t *mp4,
276 ngx_http_mp4_trak_t *trak, int32_t adjustment);
277 static ngx_int_t ngx_http_mp4_read_co64_atom(ngx_http_mp4_file_t *mp4,
278 uint64_t atom_data_size);
279 static ngx_int_t ngx_http_mp4_update_co64_atom(ngx_http_mp4_file_t *mp4,
280 ngx_http_mp4_trak_t *trak);
281 static void ngx_http_mp4_adjust_co64_atom(ngx_http_mp4_file_t *mp4,
282 ngx_http_mp4_trak_t *trak, off_t adjustment);
283 static char *ngx_http_mp4(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
284 static void *ngx_http_mp4_create_conf(ngx_conf_t *cf);
285 static char *ngx_http_mp4_merge_conf(ngx_conf_t *cf, void *parent, void *child);
286
287 static ngx_command_t ngx_http_mp4_commands[] = {
288
289 { ngx_string("mp4"),
290 NGX_HTTP_LOC_CONF|NGX_CONF_NOARGS,
291 ngx_http_mp4,
292 0,
293 0,
294 NULL },
295
296 { ngx_string("mp4_buffer_size"),
297 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
298 ngx_conf_set_size_slot,
299 NGX_HTTP_LOC_CONF_OFFSET,
300 offsetof(ngx_http_mp4_conf_t, buffer_size),
301 NULL },
302
303 { ngx_string("mp4_max_buffer_size"),
304 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
305 ngx_conf_set_size_slot,
306 NGX_HTTP_LOC_CONF_OFFSET,
307 offsetof(ngx_http_mp4_conf_t, max_buffer_size),
308 NULL },
309
310 ngx_null_command
311 };
312
313
314 static ngx_http_module_t ngx_http_mp4_module_ctx = {
315 NULL, /* preconfiguration */
316 NULL, /* postconfiguration */
317
318 NULL, /* create main configuration */
319 NULL, /* init main configuration */
320
321 NULL, /* create server configuration */
322 NULL, /* merge server configuration */
323
324 ngx_http_mp4_create_conf, /* create location configuration */
325 ngx_http_mp4_merge_conf /* merge location configuration */
326 };
327
328
329 ngx_module_t ngx_http_mp4_module = {
330 NGX_MODULE_V1,
331 &ngx_http_mp4_module_ctx, /* module context */
332 ngx_http_mp4_commands, /* module directives */
333 NGX_HTTP_MODULE, /* module type */
334 NULL, /* init master */
335 NULL, /* init module */
336 NULL, /* init process */
337 NULL, /* init thread */
338 NULL, /* exit thread */
339 NULL, /* exit process */
340 NULL, /* exit master */
341 NGX_MODULE_V1_PADDING
342 };
343
344
345 static ngx_http_mp4_atom_handler_t ngx_http_mp4_atoms[] = {
346 { "ftyp", ngx_http_mp4_read_ftyp_atom },
347 { "moov", ngx_http_mp4_read_moov_atom },
348 { "mdat", ngx_http_mp4_read_mdat_atom },
349 { NULL, NULL }
350 };
351
352 static ngx_http_mp4_atom_handler_t ngx_http_mp4_moov_atoms[] = {
353 { "mvhd", ngx_http_mp4_read_mvhd_atom },
354 { "trak", ngx_http_mp4_read_trak_atom },
355 { "cmov", ngx_http_mp4_read_cmov_atom },
356 { NULL, NULL }
357 };
358
359 static ngx_http_mp4_atom_handler_t ngx_http_mp4_trak_atoms[] = {
360 { "tkhd", ngx_http_mp4_read_tkhd_atom },
361 { "mdia", ngx_http_mp4_read_mdia_atom },
362 { NULL, NULL }
363 };
364
365 static ngx_http_mp4_atom_handler_t ngx_http_mp4_mdia_atoms[] = {
366 { "mdhd", ngx_http_mp4_read_mdhd_atom },
367 { "hdlr", ngx_http_mp4_read_hdlr_atom },
368 { "minf", ngx_http_mp4_read_minf_atom },
369 { NULL, NULL }
370 };
371
372 static ngx_http_mp4_atom_handler_t ngx_http_mp4_minf_atoms[] = {
373 { "vmhd", ngx_http_mp4_read_vmhd_atom },
374 { "smhd", ngx_http_mp4_read_smhd_atom },
375 { "dinf", ngx_http_mp4_read_dinf_atom },
376 { "stbl", ngx_http_mp4_read_stbl_atom },
377 { NULL, NULL }
378 };
379
380 static ngx_http_mp4_atom_handler_t ngx_http_mp4_stbl_atoms[] = {
381 { "stsd", ngx_http_mp4_read_stsd_atom },
382 { "stts", ngx_http_mp4_read_stts_atom },
383 { "stss", ngx_http_mp4_read_stss_atom },
384 { "ctts", ngx_http_mp4_read_ctts_atom },
385 { "stsc", ngx_http_mp4_read_stsc_atom },
386 { "stsz", ngx_http_mp4_read_stsz_atom },
387 { "stco", ngx_http_mp4_read_stco_atom },
388 { "co64", ngx_http_mp4_read_co64_atom },
389 { NULL, NULL }
390 };
391
392
393 static ngx_int_t
394 ngx_http_mp4_handler(ngx_http_request_t *r)
395 {
396 u_char *last;
397 size_t root;
398 ngx_int_t rc, start;
399 ngx_uint_t level;
400 ngx_str_t path, value;
401 ngx_log_t *log;
402 ngx_buf_t *b;
403 ngx_chain_t out;
404 ngx_http_mp4_file_t *mp4;
405 ngx_open_file_info_t of;
406 ngx_http_core_loc_conf_t *clcf;
407
408 if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD))) {
409 return NGX_HTTP_NOT_ALLOWED;
410 }
411
412 if (r->uri.data[r->uri.len - 1] == '/') {
413 return NGX_DECLINED;
414 }
415
416 rc = ngx_http_discard_request_body(r);
417
418 if (rc != NGX_OK) {
419 return rc;
420 }
421
422 last = ngx_http_map_uri_to_path(r, &path, &root, 0);
423 if (last == NULL) {
424 return NGX_HTTP_INTERNAL_SERVER_ERROR;
425 }
426
427 log = r->connection->log;
428
429 path.len = last - path.data;
430
431 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
432 "http mp4 filename: \"%V\"", &path);
433
434 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
435
436 ngx_memzero(&of, sizeof(ngx_open_file_info_t));
437
438 of.read_ahead = clcf->read_ahead;
439 of.directio = NGX_MAX_OFF_T_VALUE;
440 of.valid = clcf->open_file_cache_valid;
441 of.min_uses = clcf->open_file_cache_min_uses;
442 of.errors = clcf->open_file_cache_errors;
443 of.events = clcf->open_file_cache_events;
444
445 if (ngx_http_set_disable_symlinks(r, clcf, &path, &of) != NGX_OK) {
446 return NGX_HTTP_INTERNAL_SERVER_ERROR;
447 }
448
449 if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
450 != NGX_OK)
451 {
452 switch (of.err) {
453
454 case 0:
455 return NGX_HTTP_INTERNAL_SERVER_ERROR;
456
457 case NGX_ENOENT:
458 case NGX_ENOTDIR:
459 case NGX_ENAMETOOLONG:
460
461 level = NGX_LOG_ERR;
462 rc = NGX_HTTP_NOT_FOUND;
463 break;
464
465 case NGX_EACCES:
466 #if (NGX_HAVE_OPENAT)
467 case NGX_EMLINK:
468 case NGX_ELOOP:
469 #endif
470
471 level = NGX_LOG_ERR;
472 rc = NGX_HTTP_FORBIDDEN;
473 break;
474
475 default:
476
477 level = NGX_LOG_CRIT;
478 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
479 break;
480 }
481
482 if (rc != NGX_HTTP_NOT_FOUND || clcf->log_not_found) {
483 ngx_log_error(level, log, of.err,
484 "%s \"%s\" failed", of.failed, path.data);
485 }
486
487 return rc;
488 }
489
490 if (!of.is_file) {
491
492 if (ngx_close_file(of.fd) == NGX_FILE_ERROR) {
493 ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
494 ngx_close_file_n " \"%s\" failed", path.data);
495 }
496
497 return NGX_DECLINED;
498 }
499
500 r->root_tested = !r->error_page;
501 r->allow_ranges = 1;
502
503 start = -1;
504 r->headers_out.content_length_n = of.size;
505 mp4 = NULL;
506 b = NULL;
507
508 if (r->args.len) {
509
510 if (ngx_http_arg(r, (u_char *) "start", 5, &value) == NGX_OK) {
511
512 /*
513 * A Flash player may send start value with a lot of digits
514 * after dot so strtod() is used instead of atofp(). NaNs and
515 * infinities become negative numbers after (int) conversion.
516 */
517
518 ngx_set_errno(0);
519 start = (int) (strtod((char *) value.data, NULL) * 1000);
520
521 if (ngx_errno == 0 && start >= 0) {
522 r->allow_ranges = 0;
523
524 mp4 = ngx_pcalloc(r->pool, sizeof(ngx_http_mp4_file_t));
525 if (mp4 == NULL) {
526 return NGX_HTTP_INTERNAL_SERVER_ERROR;
527 }
528
529 mp4->file.fd = of.fd;
530 mp4->file.name = path;
531 mp4->file.log = r->connection->log;;
532 mp4->end = of.size;
533 mp4->start = (ngx_uint_t) start;
534 mp4->request = r;
535
536 switch (ngx_http_mp4_process(mp4)) {
537
538 case NGX_DECLINED:
539 if (mp4->buffer) {
540 ngx_pfree(r->pool, mp4->buffer);
541 }
542
543 ngx_pfree(r->pool, mp4);
544 mp4 = NULL;
545
546 break;
547
548 case NGX_OK:
549 r->headers_out.content_length_n = mp4->content_length;
550 break;
551
552 default: /* NGX_ERROR */
553 if (mp4->buffer) {
554 ngx_pfree(r->pool, mp4->buffer);
555 }
556
557 ngx_pfree(r->pool, mp4);
558
559 return NGX_HTTP_INTERNAL_SERVER_ERROR;
560 }
561 }
562 }
563 }
564
565 log->action = "sending mp4 to client";
566
567 if (clcf->directio <= of.size) {
568
569 /*
570 * DIRECTIO is set on transfer only
571 * to allow kernel to cache "moov" atom
572 */
573
574 if (ngx_directio_on(of.fd) == NGX_FILE_ERROR) {
575 ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
576 ngx_directio_on_n " \"%s\" failed", path.data);
577 }
578
579 of.is_directio = 1;
580
581 if (mp4) {
582 mp4->file.directio = 1;
583 }
584 }
585
586 r->headers_out.status = NGX_HTTP_OK;
587 r->headers_out.last_modified_time = of.mtime;
588
589 if (ngx_http_set_etag(r) != NGX_OK) {
590 return NGX_HTTP_INTERNAL_SERVER_ERROR;
591 }
592
593 if (ngx_http_set_content_type(r) != NGX_OK) {
594 return NGX_HTTP_INTERNAL_SERVER_ERROR;
595 }
596
597 if (mp4 == NULL) {
598 b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
599 if (b == NULL) {
600 return NGX_HTTP_INTERNAL_SERVER_ERROR;
601 }
602
603 b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
604 if (b->file == NULL) {
605 return NGX_HTTP_INTERNAL_SERVER_ERROR;
606 }
607 }
608
609 rc = ngx_http_send_header(r);
610
611 if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
612 return rc;
613 }
614
615 if (mp4) {
616 return ngx_http_output_filter(r, mp4->out);
617 }
618
619 b->file_pos = 0;
620 b->file_last = of.size;
621
622 b->in_file = b->file_last ? 1 : 0;
623 b->last_buf = (r == r->main) ? 1 : 0;
624 b->last_in_chain = 1;
625
626 b->file->fd = of.fd;
627 b->file->name = path;
628 b->file->log = log;
629 b->file->directio = of.is_directio;
630
631 out.buf = b;
632 out.next = NULL;
633
634 return ngx_http_output_filter(r, &out);
635 }
636
637
638 static ngx_int_t
639 ngx_http_mp4_process(ngx_http_mp4_file_t *mp4)
640 {
641 off_t start_offset, adjustment;
642 ngx_int_t rc;
643 ngx_uint_t i, j;
644 ngx_chain_t **prev;
645 ngx_http_mp4_trak_t *trak;
646 ngx_http_mp4_conf_t *conf;
647
648 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
649 "mp4 start:%ui", mp4->start);
650
651 conf = ngx_http_get_module_loc_conf(mp4->request, ngx_http_mp4_module);
652
653 mp4->buffer_size = conf->buffer_size;
654
655 rc = ngx_http_mp4_read_atom(mp4, ngx_http_mp4_atoms, mp4->end);
656 if (rc != NGX_OK) {
657 return rc;
658 }
659
660 if (mp4->trak.nelts == 0) {
661 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
662 "no mp4 trak atoms were found in \"%s\"",
663 mp4->file.name.data);
664 return NGX_ERROR;
665 }
666
667 if (mp4->mdat_atom.buf == NULL) {
668 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
669 "no mp4 mdat atom was found in \"%s\"",
670 mp4->file.name.data);
671 return NGX_ERROR;
672 }
673
674 prev = &mp4->out;
675
676 if (mp4->ftyp_atom.buf) {
677 *prev = &mp4->ftyp_atom;
678 prev = &mp4->ftyp_atom.next;
679 }
680
681 *prev = &mp4->moov_atom;
682 prev = &mp4->moov_atom.next;
683
684 if (mp4->mvhd_atom.buf) {
685 mp4->moov_size += mp4->mvhd_atom_buf.last - mp4->mvhd_atom_buf.pos;
686 *prev = &mp4->mvhd_atom;
687 prev = &mp4->mvhd_atom.next;
688 }
689
690 start_offset = mp4->end;
691 trak = mp4->trak.elts;
692
693 for (i = 0; i < mp4->trak.nelts; i++) {
694
695 if (ngx_http_mp4_update_stts_atom(mp4, &trak[i]) != NGX_OK) {
696 return NGX_ERROR;
697 }
698
699 if (ngx_http_mp4_update_stss_atom(mp4, &trak[i]) != NGX_OK) {
700 return NGX_ERROR;
701 }
702
703 ngx_http_mp4_update_ctts_atom(mp4, &trak[i]);
704
705 if (ngx_http_mp4_update_stsc_atom(mp4, &trak[i]) != NGX_OK) {
706 return NGX_ERROR;
707 }
708
709 if (ngx_http_mp4_update_stsz_atom(mp4, &trak[i]) != NGX_OK) {
710 return NGX_ERROR;
711 }
712
713 if (trak[i].out[NGX_HTTP_MP4_CO64_DATA].buf) {
714 if (ngx_http_mp4_update_co64_atom(mp4, &trak[i]) != NGX_OK) {
715 return NGX_ERROR;
716 }
717
718 } else {
719 if (ngx_http_mp4_update_stco_atom(mp4, &trak[i]) != NGX_OK) {
720 return NGX_ERROR;
721 }
722 }
723
724 ngx_http_mp4_update_stbl_atom(mp4, &trak[i]);
725 ngx_http_mp4_update_minf_atom(mp4, &trak[i]);
726 trak[i].size += trak[i].mdhd_size;
727 trak[i].size += trak[i].hdlr_size;
728 ngx_http_mp4_update_mdia_atom(mp4, &trak[i]);
729 trak[i].size += trak[i].tkhd_size;
730 ngx_http_mp4_update_trak_atom(mp4, &trak[i]);
731
732 mp4->moov_size += trak[i].size;
733
734 if (start_offset > trak[i].start_offset) {
735 start_offset = trak[i].start_offset;
736 }
737
738 *prev = &trak[i].out[NGX_HTTP_MP4_TRAK_ATOM];
739 prev = &trak[i].out[NGX_HTTP_MP4_TRAK_ATOM].next;
740
741 for (j = 0; j < NGX_HTTP_MP4_LAST_ATOM + 1; j++) {
742 if (trak[i].out[j].buf) {
743 *prev = &trak[i].out[j];
744 prev = &trak[i].out[j].next;
745 }
746 }
747 }
748
749 mp4->moov_size += 8;
750
751 ngx_mp4_set_32value(mp4->moov_atom_header, mp4->moov_size);
752 ngx_mp4_set_atom_name(mp4->moov_atom_header, 'm', 'o', 'o', 'v');
753 mp4->content_length += mp4->moov_size;
754
755 *prev = &mp4->mdat_atom;
756
757 if (start_offset > mp4->mdat_data.buf->file_last) {
758 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
759 "start time is out mp4 mdat atom in \"%s\"",
760 mp4->file.name.data);
761 return NGX_ERROR;
762 }
763
764 adjustment = mp4->ftyp_size + mp4->moov_size
765 + ngx_http_mp4_update_mdat_atom(mp4, start_offset)
766 - start_offset;
767
768 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
769 "mp4 adjustment:%O", adjustment);
770
771 for (i = 0; i < mp4->trak.nelts; i++) {
772 if (trak[i].out[NGX_HTTP_MP4_CO64_DATA].buf) {
773 ngx_http_mp4_adjust_co64_atom(mp4, &trak[i], adjustment);
774 } else {
775 ngx_http_mp4_adjust_stco_atom(mp4, &trak[i], (int32_t) adjustment);
776 }
777 }
778
779 return NGX_OK;
780 }
781
782
783 typedef struct {
784 u_char size[4];
785 u_char name[4];
786 } ngx_mp4_atom_header_t;
787
788 typedef struct {
789 u_char size[4];
790 u_char name[4];
791 u_char size64[8];
792 } ngx_mp4_atom_header64_t;
793
794
795 static ngx_int_t
796 ngx_http_mp4_read_atom(ngx_http_mp4_file_t *mp4,
797 ngx_http_mp4_atom_handler_t *atom, uint64_t atom_data_size)
798 {
799 off_t end;
800 size_t atom_header_size;
801 u_char *atom_header, *atom_name;
802 uint64_t atom_size;
803 ngx_int_t rc;
804 ngx_uint_t n;
805
806 end = mp4->offset + atom_data_size;
807
808 while (mp4->offset < end) {
809
810 if (ngx_http_mp4_read(mp4, sizeof(uint32_t)) != NGX_OK) {
811 return NGX_ERROR;
812 }
813
814 atom_header = mp4->buffer_pos;
815 atom_size = ngx_mp4_get_32value(atom_header);
816 atom_header_size = sizeof(ngx_mp4_atom_header_t);
817
818 if (atom_size == 0) {
819 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
820 "mp4 atom end");
821 return NGX_OK;
822 }
823
824 if (atom_size < sizeof(ngx_mp4_atom_header_t)) {
825
826 if (atom_size == 1) {
827
828 if (ngx_http_mp4_read(mp4, sizeof(ngx_mp4_atom_header64_t))
829 != NGX_OK)
830 {
831 return NGX_ERROR;
832 }
833
834 /* 64-bit atom size */
835 atom_header = mp4->buffer_pos;
836 atom_size = ngx_mp4_get_64value(atom_header + 8);
837 atom_header_size = sizeof(ngx_mp4_atom_header64_t);
838
839 } else {
840 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
841 "\"%s\" mp4 atom is too small:%uL",
842 mp4->file.name.data, atom_size);
843 return NGX_ERROR;
844 }
845 }
846
847 if (ngx_http_mp4_read(mp4, sizeof(ngx_mp4_atom_header_t)) != NGX_OK) {
848 return NGX_ERROR;
849 }
850
851 atom_header = mp4->buffer_pos;
852 atom_name = atom_header + sizeof(uint32_t);
853
854 ngx_log_debug4(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
855 "mp4 atom: %*s @%O:%uL",
856 4, atom_name, mp4->offset, atom_size);
857
858 if (atom_size > (uint64_t) (NGX_MAX_OFF_T_VALUE - mp4->offset)
859 || mp4->offset + (off_t) atom_size > end)
860 {
861 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
862 "\"%s\" mp4 atom too large:%uL",
863 mp4->file.name.data, atom_size);
864 return NGX_ERROR;
865 }
866
867 for (n = 0; atom[n].name; n++) {
868
869 if (ngx_strncmp(atom_name, atom[n].name, 4) == 0) {
870
871 ngx_mp4_atom_next(mp4, atom_header_size);
872
873 rc = atom[n].handler(mp4, atom_size - atom_header_size);
874 if (rc != NGX_OK) {
875 return rc;
876 }
877
878 goto next;
879 }
880 }
881
882 ngx_mp4_atom_next(mp4, atom_size);
883
884 next:
885 continue;
886 }
887
888 return NGX_OK;
889 }
890
891
892 static ngx_int_t
893 ngx_http_mp4_read(ngx_http_mp4_file_t *mp4, size_t size)
894 {
895 ssize_t n;
896
897 if (mp4->buffer_pos + size <= mp4->buffer_end) {
898 return NGX_OK;
899 }
900
901 if (mp4->offset + (off_t) mp4->buffer_size > mp4->end) {
902 mp4->buffer_size = (size_t) (mp4->end - mp4->offset);
903 }
904
905 if (mp4->buffer_size < size) {
906 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
907 "\"%s\" mp4 file truncated", mp4->file.name.data);
908 return NGX_ERROR;
909 }
910
911 if (mp4->buffer == NULL) {
912 mp4->buffer = ngx_palloc(mp4->request->pool, mp4->buffer_size);
913 if (mp4->buffer == NULL) {
914 return NGX_ERROR;
915 }
916
917 mp4->buffer_start = mp4->buffer;
918 }
919
920 n = ngx_read_file(&mp4->file, mp4->buffer_start, mp4->buffer_size,
921 mp4->offset);
922
923 if (n == NGX_ERROR) {
924 return NGX_ERROR;
925 }
926
927 if ((size_t) n != mp4->buffer_size) {
928 ngx_log_error(NGX_LOG_CRIT, mp4->file.log, 0,
929 ngx_read_file_n " read only %z of %z from \"%s\"",
930 n, mp4->buffer_size, mp4->file.name.data);
931 return NGX_ERROR;
932 }
933
934 mp4->buffer_pos = mp4->buffer_start;
935 mp4->buffer_end = mp4->buffer_start + mp4->buffer_size;
936
937 return NGX_OK;
938 }
939
940
941 static ngx_int_t
942 ngx_http_mp4_read_ftyp_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
943 {
944 u_char *ftyp_atom;
945 size_t atom_size;
946 ngx_buf_t *atom;
947
948 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 ftyp atom");
949
950 if (atom_data_size > 1024
951 || ngx_mp4_atom_data(mp4) + atom_data_size > mp4->buffer_end)
952 {
953 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
954 "\"%s\" mp4 ftyp atom is too large:%uL",
955 mp4->file.name.data, atom_data_size);
956 return NGX_ERROR;
957 }
958
959 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
960
961 ftyp_atom = ngx_palloc(mp4->request->pool, atom_size);
962 if (ftyp_atom == NULL) {
963 return NGX_ERROR;
964 }
965
966 ngx_mp4_set_32value(ftyp_atom, atom_size);
967 ngx_mp4_set_atom_name(ftyp_atom, 'f', 't', 'y', 'p');
968
969 /*
970 * only moov atom content is guaranteed to be in mp4->buffer
971 * during sending response, so ftyp atom content should be copied
972 */
973 ngx_memcpy(ftyp_atom + sizeof(ngx_mp4_atom_header_t),
974 ngx_mp4_atom_data(mp4), (size_t) atom_data_size);
975
976 atom = &mp4->ftyp_atom_buf;
977 atom->temporary = 1;
978 atom->pos = ftyp_atom;
979 atom->last = ftyp_atom + atom_size;
980
981 mp4->ftyp_atom.buf = atom;
982 mp4->ftyp_size = atom_size;
983 mp4->content_length = atom_size;
984
985 ngx_mp4_atom_next(mp4, atom_data_size);
986
987 return NGX_OK;
988 }
989
990
991 /*
992 * Small excess buffer to process atoms after moov atom, mp4->buffer_start
993 * will be set to this buffer part after moov atom processing.
994 */
995 #define NGX_HTTP_MP4_MOOV_BUFFER_EXCESS (4 * 1024)
996
997 static ngx_int_t
998 ngx_http_mp4_read_moov_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
999 {
1000 ngx_int_t rc;
1001 ngx_uint_t no_mdat;
1002 ngx_buf_t *atom;
1003 ngx_http_mp4_conf_t *conf;
1004
1005 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 moov atom");
1006
1007 no_mdat = (mp4->mdat_atom.buf == NULL);
1008
1009 if (no_mdat && mp4->start == 0) {
1010 /*
1011 * send original file if moov atom resides before
1012 * mdat atom and client requests integral file
1013 */
1014 return NGX_DECLINED;
1015 }
1016
1017 conf = ngx_http_get_module_loc_conf(mp4->request, ngx_http_mp4_module);
1018
1019 if (atom_data_size > mp4->buffer_size) {
1020
1021 if (atom_data_size > conf->max_buffer_size) {
1022 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1023 "\"%s\" mp4 moov atom is too large:%uL, "
1024 "you may want to increase mp4_max_buffer_size",
1025 mp4->file.name.data, atom_data_size);
1026 return NGX_ERROR;
1027 }
1028
1029 ngx_pfree(mp4->request->pool, mp4->buffer);
1030 mp4->buffer = NULL;
1031 mp4->buffer_pos = NULL;
1032 mp4->buffer_end = NULL;
1033
1034 mp4->buffer_size = (size_t) atom_data_size
1035 + NGX_HTTP_MP4_MOOV_BUFFER_EXCESS * no_mdat;
1036 }
1037
1038 if (ngx_http_mp4_read(mp4, (size_t) atom_data_size) != NGX_OK) {
1039 return NGX_ERROR;
1040 }
1041
1042 mp4->trak.elts = &mp4->traks;
1043 mp4->trak.size = sizeof(ngx_http_mp4_trak_t);
1044 mp4->trak.nalloc = 2;
1045 mp4->trak.pool = mp4->request->pool;
1046
1047 atom = &mp4->moov_atom_buf;
1048 atom->temporary = 1;
1049 atom->pos = mp4->moov_atom_header;
1050 atom->last = mp4->moov_atom_header + 8;
1051
1052 mp4->moov_atom.buf = &mp4->moov_atom_buf;
1053
1054 rc = ngx_http_mp4_read_atom(mp4, ngx_http_mp4_moov_atoms, atom_data_size);
1055
1056 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 moov atom done");
1057
1058 if (no_mdat) {
1059 mp4->buffer_start = mp4->buffer_pos;
1060 mp4->buffer_size = NGX_HTTP_MP4_MOOV_BUFFER_EXCESS;
1061
1062 if (mp4->buffer_start + mp4->buffer_size > mp4->buffer_end) {
1063 mp4->buffer = NULL;
1064 mp4->buffer_pos = NULL;
1065 mp4->buffer_end = NULL;
1066 }
1067
1068 } else {
1069 /* skip atoms after moov atom */
1070 mp4->offset = mp4->end;
1071 }
1072
1073 return rc;
1074 }
1075
1076
1077 static ngx_int_t
1078 ngx_http_mp4_read_mdat_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1079 {
1080 ngx_buf_t *data;
1081
1082 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 mdat atom");
1083
1084 data = &mp4->mdat_data_buf;
1085 data->file = &mp4->file;
1086 data->in_file = 1;
1087 data->last_buf = 1;
1088 data->last_in_chain = 1;
1089 data->file_last = mp4->offset + atom_data_size;
1090
1091 mp4->mdat_atom.buf = &mp4->mdat_atom_buf;
1092 mp4->mdat_atom.next = &mp4->mdat_data;
1093 mp4->mdat_data.buf = data;
1094
1095 if (mp4->trak.nelts) {
1096 /* skip atoms after mdat atom */
1097 mp4->offset = mp4->end;
1098
1099 } else {
1100 ngx_mp4_atom_next(mp4, atom_data_size);
1101 }
1102
1103 return NGX_OK;
1104 }
1105
1106
1107 static size_t
1108 ngx_http_mp4_update_mdat_atom(ngx_http_mp4_file_t *mp4, off_t start_offset)
1109 {
1110 off_t atom_data_size;
1111 u_char *atom_header;
1112 uint32_t atom_header_size;
1113 uint64_t atom_size;
1114 ngx_buf_t *atom;
1115
1116 atom_data_size = mp4->mdat_data.buf->file_last - start_offset;
1117 mp4->mdat_data.buf->file_pos = start_offset;
1118
1119 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1120 "mdat new offset @%O:%O", start_offset, atom_data_size);
1121
1122 atom_header = mp4->mdat_atom_header;
1123
1124 if ((uint64_t) atom_data_size > 0xffffffff) {
1125 atom_size = 1;
1126 atom_header_size = sizeof(ngx_mp4_atom_header64_t);
1127 ngx_mp4_set_64value(atom_header + sizeof(ngx_mp4_atom_header_t),
1128 sizeof(ngx_mp4_atom_header64_t) + atom_data_size);
1129 } else {
1130 atom_size = sizeof(ngx_mp4_atom_header_t) + atom_data_size;
1131 atom_header_size = sizeof(ngx_mp4_atom_header_t);
1132 }
1133
1134 mp4->content_length += atom_header_size + atom_data_size;
1135
1136 ngx_mp4_set_32value(atom_header, atom_size);
1137 ngx_mp4_set_atom_name(atom_header, 'm', 'd', 'a', 't');
1138
1139 atom = &mp4->mdat_atom_buf;
1140 atom->temporary = 1;
1141 atom->pos = atom_header;
1142 atom->last = atom_header + atom_header_size;
1143
1144 return atom_header_size;
1145 }
1146
1147
1148 typedef struct {
1149 u_char size[4];
1150 u_char name[4];
1151 u_char version[1];
1152 u_char flags[3];
1153 u_char creation_time[4];
1154 u_char modification_time[4];
1155 u_char timescale[4];
1156 u_char duration[4];
1157 u_char rate[4];
1158 u_char volume[2];
1159 u_char reserved[10];
1160 u_char matrix[36];
1161 u_char preview_time[4];
1162 u_char preview_duration[4];
1163 u_char poster_time[4];
1164 u_char selection_time[4];
1165 u_char selection_duration[4];
1166 u_char current_time[4];
1167 u_char next_track_id[4];
1168 } ngx_mp4_mvhd_atom_t;
1169
1170 typedef struct {
1171 u_char size[4];
1172 u_char name[4];
1173 u_char version[1];
1174 u_char flags[3];
1175 u_char creation_time[8];
1176 u_char modification_time[8];
1177 u_char timescale[4];
1178 u_char duration[8];
1179 u_char rate[4];
1180 u_char volume[2];
1181 u_char reserved[10];
1182 u_char matrix[36];
1183 u_char preview_time[4];
1184 u_char preview_duration[4];
1185 u_char poster_time[4];
1186 u_char selection_time[4];
1187 u_char selection_duration[4];
1188 u_char current_time[4];
1189 u_char next_track_id[4];
1190 } ngx_mp4_mvhd64_atom_t;
1191
1192
1193 static ngx_int_t
1194 ngx_http_mp4_read_mvhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1195 {
1196 u_char *atom_header;
1197 size_t atom_size;
1198 uint32_t timescale;
1199 uint64_t duration;
1200 ngx_buf_t *atom;
1201 ngx_mp4_mvhd_atom_t *mvhd_atom;
1202 ngx_mp4_mvhd64_atom_t *mvhd64_atom;
1203
1204 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 mvhd atom");
1205
1206 atom_header = ngx_mp4_atom_header(mp4);
1207 mvhd_atom = (ngx_mp4_mvhd_atom_t *) atom_header;
1208 mvhd64_atom = (ngx_mp4_mvhd64_atom_t *) atom_header;
1209 ngx_mp4_set_atom_name(atom_header, 'm', 'v', 'h', 'd');
1210
1211 if (ngx_mp4_atom_data_size(ngx_mp4_mvhd_atom_t) > atom_data_size) {
1212 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1213 "\"%s\" mp4 mvhd atom too small", mp4->file.name.data);
1214 return NGX_ERROR;
1215 }
1216
1217 if (mvhd_atom->version[0] == 0) {
1218 /* version 0: 32-bit duration */
1219 timescale = ngx_mp4_get_32value(mvhd_atom->timescale);
1220 duration = ngx_mp4_get_32value(mvhd_atom->duration);
1221
1222 } else {
1223 /* version 1: 64-bit duration */
1224
1225 if (ngx_mp4_atom_data_size(ngx_mp4_mvhd64_atom_t) > atom_data_size) {
1226 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1227 "\"%s\" mp4 mvhd atom too small",
1228 mp4->file.name.data);
1229 return NGX_ERROR;
1230 }
1231
1232 timescale = ngx_mp4_get_32value(mvhd64_atom->timescale);
1233 duration = ngx_mp4_get_64value(mvhd64_atom->duration);
1234 }
1235
1236 mp4->timescale = timescale;
1237
1238 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1239 "mvhd timescale:%uD, duration:%uL, time:%.3fs",
1240 timescale, duration, (double) duration / timescale);
1241
1242 duration -= (uint64_t) mp4->start * timescale / 1000;
1243
1244 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1245 "mvhd new duration:%uL, time:%.3fs",
1246 duration, (double) duration / timescale);
1247
1248 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
1249 ngx_mp4_set_32value(mvhd_atom->size, atom_size);
1250
1251 if (mvhd_atom->version[0] == 0) {
1252 ngx_mp4_set_32value(mvhd_atom->duration, duration);
1253
1254 } else {
1255 ngx_mp4_set_64value(mvhd64_atom->duration, duration);
1256 }
1257
1258 atom = &mp4->mvhd_atom_buf;
1259 atom->temporary = 1;
1260 atom->pos = atom_header;
1261 atom->last = atom_header + atom_size;
1262
1263 mp4->mvhd_atom.buf = atom;
1264
1265 ngx_mp4_atom_next(mp4, atom_data_size);
1266
1267 return NGX_OK;
1268 }
1269
1270
1271 static ngx_int_t
1272 ngx_http_mp4_read_trak_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1273 {
1274 u_char *atom_header, *atom_end;
1275 off_t atom_file_end;
1276 ngx_int_t rc;
1277 ngx_buf_t *atom;
1278 ngx_http_mp4_trak_t *trak;
1279
1280 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 trak atom");
1281
1282 trak = ngx_array_push(&mp4->trak);
1283 if (trak == NULL) {
1284 return NGX_ERROR;
1285 }
1286
1287 ngx_memzero(trak, sizeof(ngx_http_mp4_trak_t));
1288
1289 atom_header = ngx_mp4_atom_header(mp4);
1290 ngx_mp4_set_atom_name(atom_header, 't', 'r', 'a', 'k');
1291
1292 atom = &trak->trak_atom_buf;
1293 atom->temporary = 1;
1294 atom->pos = atom_header;
1295 atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);
1296
1297 trak->out[NGX_HTTP_MP4_TRAK_ATOM].buf = atom;
1298
1299 atom_end = mp4->buffer_pos + atom_data_size;
1300 atom_file_end = mp4->offset + atom_data_size;
1301
1302 rc = ngx_http_mp4_read_atom(mp4, ngx_http_mp4_trak_atoms, atom_data_size);
1303
1304 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1305 "mp4 trak atom: %i", rc);
1306
1307 if (rc == NGX_DECLINED) {
1308 /* skip this trak */
1309 ngx_memzero(trak, sizeof(ngx_http_mp4_trak_t));
1310 mp4->trak.nelts--;
1311 mp4->buffer_pos = atom_end;
1312 mp4->offset = atom_file_end;
1313 return NGX_OK;
1314 }
1315
1316 return rc;
1317 }
1318
1319
1320 static void
1321 ngx_http_mp4_update_trak_atom(ngx_http_mp4_file_t *mp4,
1322 ngx_http_mp4_trak_t *trak)
1323 {
1324 ngx_buf_t *atom;
1325
1326 trak->size += sizeof(ngx_mp4_atom_header_t);
1327 atom = &trak->trak_atom_buf;
1328 ngx_mp4_set_32value(atom->pos, trak->size);
1329 }
1330
1331
1332 static ngx_int_t
1333 ngx_http_mp4_read_cmov_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1334 {
1335 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1336 "\"%s\" mp4 compressed moov atom (cmov) is not supported",
1337 mp4->file.name.data);
1338
1339 return NGX_ERROR;
1340 }
1341
1342
1343 typedef struct {
1344 u_char size[4];
1345 u_char name[4];
1346 u_char version[1];
1347 u_char flags[3];
1348 u_char creation_time[4];
1349 u_char modification_time[4];
1350 u_char track_id[4];
1351 u_char reserved1[4];
1352 u_char duration[4];
1353 u_char reserved2[8];
1354 u_char layer[2];
1355 u_char group[2];
1356 u_char volume[2];
1357 u_char reverved3[2];
1358 u_char matrix[36];
1359 u_char width[4];
1360 u_char heigth[4];
1361 } ngx_mp4_tkhd_atom_t;
1362
1363 typedef struct {
1364 u_char size[4];
1365 u_char name[4];
1366 u_char version[1];
1367 u_char flags[3];
1368 u_char creation_time[8];
1369 u_char modification_time[8];
1370 u_char track_id[4];
1371 u_char reserved1[4];
1372 u_char duration[8];
1373 u_char reserved2[8];
1374 u_char layer[2];
1375 u_char group[2];
1376 u_char volume[2];
1377 u_char reverved3[2];
1378 u_char matrix[36];
1379 u_char width[4];
1380 u_char heigth[4];
1381 } ngx_mp4_tkhd64_atom_t;
1382
1383
1384 static ngx_int_t
1385 ngx_http_mp4_read_tkhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1386 {
1387 u_char *atom_header;
1388 size_t atom_size;
1389 uint64_t duration;
1390 ngx_buf_t *atom;
1391 ngx_http_mp4_trak_t *trak;
1392 ngx_mp4_tkhd_atom_t *tkhd_atom;
1393 ngx_mp4_tkhd64_atom_t *tkhd64_atom;
1394
1395 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 tkhd atom");
1396
1397 atom_header = ngx_mp4_atom_header(mp4);
1398 tkhd_atom = (ngx_mp4_tkhd_atom_t *) atom_header;
1399 tkhd64_atom = (ngx_mp4_tkhd64_atom_t *) atom_header;
1400 ngx_mp4_set_atom_name(tkhd_atom, 't', 'k', 'h', 'd');
1401
1402 if (ngx_mp4_atom_data_size(ngx_mp4_tkhd_atom_t) > atom_data_size) {
1403 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1404 "\"%s\" mp4 tkhd atom too small", mp4->file.name.data);
1405 return NGX_ERROR;
1406 }
1407
1408 if (tkhd_atom->version[0] == 0) {
1409 /* version 0: 32-bit duration */
1410 duration = ngx_mp4_get_32value(tkhd_atom->duration);
1411
1412 } else {
1413 /* version 1: 64-bit duration */
1414
1415 if (ngx_mp4_atom_data_size(ngx_mp4_tkhd64_atom_t) > atom_data_size) {
1416 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1417 "\"%s\" mp4 tkhd atom too small",
1418 mp4->file.name.data);
1419 return NGX_ERROR;
1420 }
1421
1422 duration = ngx_mp4_get_64value(tkhd64_atom->duration);
1423 }
1424
1425 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1426 "tkhd duration:%uL, time:%.3fs",
1427 duration, (double) duration / mp4->timescale);
1428
1429 duration -= (uint64_t) mp4->start * mp4->timescale / 1000;
1430
1431 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1432 "tkhd new duration:%uL, time:%.3fs",
1433 duration, (double) duration / mp4->timescale);
1434
1435 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
1436
1437 trak = ngx_mp4_last_trak(mp4);
1438 trak->tkhd_size = atom_size;
1439
1440 ngx_mp4_set_32value(tkhd_atom->size, atom_size);
1441
1442 if (tkhd_atom->version[0] == 0) {
1443 ngx_mp4_set_32value(tkhd_atom->duration, duration);
1444
1445 } else {
1446 ngx_mp4_set_64value(tkhd64_atom->duration, duration);
1447 }
1448
1449 atom = &trak->tkhd_atom_buf;
1450 atom->temporary = 1;
1451 atom->pos = atom_header;
1452 atom->last = atom_header + atom_size;
1453
1454 trak->out[NGX_HTTP_MP4_TKHD_ATOM].buf = atom;
1455
1456 ngx_mp4_atom_next(mp4, atom_data_size);
1457
1458 return NGX_OK;
1459 }
1460
1461
1462 static ngx_int_t
1463 ngx_http_mp4_read_mdia_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1464 {
1465 u_char *atom_header;
1466 ngx_buf_t *atom;
1467 ngx_http_mp4_trak_t *trak;
1468
1469 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "process mdia atom");
1470
1471 atom_header = ngx_mp4_atom_header(mp4);
1472 ngx_mp4_set_atom_name(atom_header, 'm', 'd', 'i', 'a');
1473
1474 trak = ngx_mp4_last_trak(mp4);
1475
1476 atom = &trak->mdia_atom_buf;
1477 atom->temporary = 1;
1478 atom->pos = atom_header;
1479 atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);
1480
1481 trak->out[NGX_HTTP_MP4_MDIA_ATOM].buf = atom;
1482
1483 return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_mdia_atoms, atom_data_size);
1484 }
1485
1486
1487 static void
1488 ngx_http_mp4_update_mdia_atom(ngx_http_mp4_file_t *mp4,
1489 ngx_http_mp4_trak_t *trak)
1490 {
1491 ngx_buf_t *atom;
1492
1493 trak->size += sizeof(ngx_mp4_atom_header_t);
1494 atom = &trak->mdia_atom_buf;
1495 ngx_mp4_set_32value(atom->pos, trak->size);
1496 }
1497
1498
1499 typedef struct {
1500 u_char size[4];
1501 u_char name[4];
1502 u_char version[1];
1503 u_char flags[3];
1504 u_char creation_time[4];
1505 u_char modification_time[4];
1506 u_char timescale[4];
1507 u_char duration[4];
1508 u_char language[2];
1509 u_char quality[2];
1510 } ngx_mp4_mdhd_atom_t;
1511
1512 typedef struct {
1513 u_char size[4];
1514 u_char name[4];
1515 u_char version[1];
1516 u_char flags[3];
1517 u_char creation_time[8];
1518 u_char modification_time[8];
1519 u_char timescale[4];
1520 u_char duration[8];
1521 u_char language[2];
1522 u_char quality[2];
1523 } ngx_mp4_mdhd64_atom_t;
1524
1525
1526 static ngx_int_t
1527 ngx_http_mp4_read_mdhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1528 {
1529 u_char *atom_header;
1530 size_t atom_size;
1531 uint32_t timescale;
1532 uint64_t duration;
1533 ngx_buf_t *atom;
1534 ngx_http_mp4_trak_t *trak;
1535 ngx_mp4_mdhd_atom_t *mdhd_atom;
1536 ngx_mp4_mdhd64_atom_t *mdhd64_atom;
1537
1538 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 mdhd atom");
1539
1540 atom_header = ngx_mp4_atom_header(mp4);
1541 mdhd_atom = (ngx_mp4_mdhd_atom_t *) atom_header;
1542 mdhd64_atom = (ngx_mp4_mdhd64_atom_t *) atom_header;
1543 ngx_mp4_set_atom_name(mdhd_atom, 'm', 'd', 'h', 'd');
1544
1545 if (ngx_mp4_atom_data_size(ngx_mp4_mdhd_atom_t) > atom_data_size) {
1546 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1547 "\"%s\" mp4 mdhd atom too small", mp4->file.name.data);
1548 return NGX_ERROR;
1549 }
1550
1551 if (mdhd_atom->version[0] == 0) {
1552 /* version 0: everything is 32-bit */
1553 timescale = ngx_mp4_get_32value(mdhd_atom->timescale);
1554 duration = ngx_mp4_get_32value(mdhd_atom->duration);
1555
1556 } else {
1557 /* version 1: 64-bit duration and 32-bit timescale */
1558
1559 if (ngx_mp4_atom_data_size(ngx_mp4_mdhd64_atom_t) > atom_data_size) {
1560 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1561 "\"%s\" mp4 mdhd atom too small",
1562 mp4->file.name.data);
1563 return NGX_ERROR;
1564 }
1565
1566 timescale = ngx_mp4_get_32value(mdhd64_atom->timescale);
1567 duration = ngx_mp4_get_64value(mdhd64_atom->duration);
1568 }
1569
1570 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1571 "mdhd timescale:%uD, duration:%uL, time:%.3fs",
1572 timescale, duration, (double) duration / timescale);
1573
1574 duration -= (uint64_t) mp4->start * timescale / 1000;
1575
1576 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1577 "mdhd new duration:%uL, time:%.3fs",
1578 duration, (double) duration / timescale);
1579
1580 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
1581
1582 trak = ngx_mp4_last_trak(mp4);
1583 trak->mdhd_size = atom_size;
1584 trak->timescale = timescale;
1585
1586 ngx_mp4_set_32value(mdhd_atom->size, atom_size);
1587
1588 if (mdhd_atom->version[0] == 0) {
1589 ngx_mp4_set_32value(mdhd_atom->duration, duration);
1590
1591 } else {
1592 ngx_mp4_set_64value(mdhd64_atom->duration, duration);
1593 }
1594
1595 atom = &trak->mdhd_atom_buf;
1596 atom->temporary = 1;
1597 atom->pos = atom_header;
1598 atom->last = atom_header + atom_size;
1599
1600 trak->out[NGX_HTTP_MP4_MDHD_ATOM].buf = atom;
1601
1602 ngx_mp4_atom_next(mp4, atom_data_size);
1603
1604 return NGX_OK;
1605 }
1606
1607
1608 static ngx_int_t
1609 ngx_http_mp4_read_hdlr_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1610 {
1611 u_char *atom_header;
1612 size_t atom_size;
1613 ngx_buf_t *atom;
1614 ngx_http_mp4_trak_t *trak;
1615
1616 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 hdlr atom");
1617
1618 atom_header = ngx_mp4_atom_header(mp4);
1619 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
1620 ngx_mp4_set_32value(atom_header, atom_size);
1621 ngx_mp4_set_atom_name(atom_header, 'h', 'd', 'l', 'r');
1622
1623 trak = ngx_mp4_last_trak(mp4);
1624
1625 atom = &trak->hdlr_atom_buf;
1626 atom->temporary = 1;
1627 atom->pos = atom_header;
1628 atom->last = atom_header + atom_size;
1629
1630 trak->hdlr_size = atom_size;
1631 trak->out[NGX_HTTP_MP4_HDLR_ATOM].buf = atom;
1632
1633 ngx_mp4_atom_next(mp4, atom_data_size);
1634
1635 return NGX_OK;
1636 }
1637
1638
1639 static ngx_int_t
1640 ngx_http_mp4_read_minf_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1641 {
1642 u_char *atom_header;
1643 ngx_buf_t *atom;
1644 ngx_http_mp4_trak_t *trak;
1645
1646 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "process minf atom");
1647
1648 atom_header = ngx_mp4_atom_header(mp4);
1649 ngx_mp4_set_atom_name(atom_header, 'm', 'i', 'n', 'f');
1650
1651 trak = ngx_mp4_last_trak(mp4);
1652
1653 atom = &trak->minf_atom_buf;
1654 atom->temporary = 1;
1655 atom->pos = atom_header;
1656 atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);
1657
1658 trak->out[NGX_HTTP_MP4_MINF_ATOM].buf = atom;
1659
1660 return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_minf_atoms, atom_data_size);
1661 }
1662
1663
1664 static void
1665 ngx_http_mp4_update_minf_atom(ngx_http_mp4_file_t *mp4,
1666 ngx_http_mp4_trak_t *trak)
1667 {
1668 ngx_buf_t *atom;
1669
1670 trak->size += sizeof(ngx_mp4_atom_header_t)
1671 + trak->vmhd_size
1672 + trak->smhd_size
1673 + trak->dinf_size;
1674 atom = &trak->minf_atom_buf;
1675 ngx_mp4_set_32value(atom->pos, trak->size);
1676 }
1677
1678
1679 static ngx_int_t
1680 ngx_http_mp4_read_vmhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1681 {
1682 u_char *atom_header;
1683 size_t atom_size;
1684 ngx_buf_t *atom;
1685 ngx_http_mp4_trak_t *trak;
1686
1687 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 vmhd atom");
1688
1689 atom_header = ngx_mp4_atom_header(mp4);
1690 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
1691 ngx_mp4_set_32value(atom_header, atom_size);
1692 ngx_mp4_set_atom_name(atom_header, 'v', 'm', 'h', 'd');
1693
1694 trak = ngx_mp4_last_trak(mp4);
1695
1696 atom = &trak->vmhd_atom_buf;
1697 atom->temporary = 1;
1698 atom->pos = atom_header;
1699 atom->last = atom_header + atom_size;
1700
1701 trak->vmhd_size += atom_size;
1702 trak->out[NGX_HTTP_MP4_VMHD_ATOM].buf = atom;
1703
1704 ngx_mp4_atom_next(mp4, atom_data_size);
1705
1706 return NGX_OK;
1707 }
1708
1709
1710 static ngx_int_t
1711 ngx_http_mp4_read_smhd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1712 {
1713 u_char *atom_header;
1714 size_t atom_size;
1715 ngx_buf_t *atom;
1716 ngx_http_mp4_trak_t *trak;
1717
1718 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 smhd atom");
1719
1720 atom_header = ngx_mp4_atom_header(mp4);
1721 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
1722 ngx_mp4_set_32value(atom_header, atom_size);
1723 ngx_mp4_set_atom_name(atom_header, 's', 'm', 'h', 'd');
1724
1725 trak = ngx_mp4_last_trak(mp4);
1726
1727 atom = &trak->smhd_atom_buf;
1728 atom->temporary = 1;
1729 atom->pos = atom_header;
1730 atom->last = atom_header + atom_size;
1731
1732 trak->vmhd_size += atom_size;
1733 trak->out[NGX_HTTP_MP4_SMHD_ATOM].buf = atom;
1734
1735 ngx_mp4_atom_next(mp4, atom_data_size);
1736
1737 return NGX_OK;
1738 }
1739
1740
1741 static ngx_int_t
1742 ngx_http_mp4_read_dinf_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1743 {
1744 u_char *atom_header;
1745 size_t atom_size;
1746 ngx_buf_t *atom;
1747 ngx_http_mp4_trak_t *trak;
1748
1749 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 dinf atom");
1750
1751 atom_header = ngx_mp4_atom_header(mp4);
1752 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
1753 ngx_mp4_set_32value(atom_header, atom_size);
1754 ngx_mp4_set_atom_name(atom_header, 'd', 'i', 'n', 'f');
1755
1756 trak = ngx_mp4_last_trak(mp4);
1757
1758 atom = &trak->dinf_atom_buf;
1759 atom->temporary = 1;
1760 atom->pos = atom_header;
1761 atom->last = atom_header + atom_size;
1762
1763 trak->dinf_size += atom_size;
1764 trak->out[NGX_HTTP_MP4_DINF_ATOM].buf = atom;
1765
1766 ngx_mp4_atom_next(mp4, atom_data_size);
1767
1768 return NGX_OK;
1769 }
1770
1771
1772 static ngx_int_t
1773 ngx_http_mp4_read_stbl_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1774 {
1775 u_char *atom_header;
1776 ngx_buf_t *atom;
1777 ngx_http_mp4_trak_t *trak;
1778
1779 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "process stbl atom");
1780
1781 atom_header = ngx_mp4_atom_header(mp4);
1782 ngx_mp4_set_atom_name(atom_header, 's', 't', 'b', 'l');
1783
1784 trak = ngx_mp4_last_trak(mp4);
1785
1786 atom = &trak->stbl_atom_buf;
1787 atom->temporary = 1;
1788 atom->pos = atom_header;
1789 atom->last = atom_header + sizeof(ngx_mp4_atom_header_t);
1790
1791 trak->out[NGX_HTTP_MP4_STBL_ATOM].buf = atom;
1792
1793 return ngx_http_mp4_read_atom(mp4, ngx_http_mp4_stbl_atoms, atom_data_size);
1794 }
1795
1796
1797 static void
1798 ngx_http_mp4_update_stbl_atom(ngx_http_mp4_file_t *mp4,
1799 ngx_http_mp4_trak_t *trak)
1800 {
1801 ngx_buf_t *atom;
1802
1803 trak->size += sizeof(ngx_mp4_atom_header_t);
1804 atom = &trak->stbl_atom_buf;
1805 ngx_mp4_set_32value(atom->pos, trak->size);
1806 }
1807
1808
1809 typedef struct {
1810 u_char size[4];
1811 u_char name[4];
1812 u_char version[1];
1813 u_char flags[3];
1814 u_char entries[4];
1815
1816 u_char media_size[4];
1817 u_char media_name[4];
1818 } ngx_mp4_stsd_atom_t;
1819
1820
1821 static ngx_int_t
1822 ngx_http_mp4_read_stsd_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1823 {
1824 u_char *atom_header, *atom_table;
1825 size_t atom_size;
1826 ngx_buf_t *atom;
1827 ngx_mp4_stsd_atom_t *stsd_atom;
1828 ngx_http_mp4_trak_t *trak;
1829
1830 /* sample description atom */
1831
1832 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stsd atom");
1833
1834 atom_header = ngx_mp4_atom_header(mp4);
1835 stsd_atom = (ngx_mp4_stsd_atom_t *) atom_header;
1836 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
1837 atom_table = atom_header + atom_size;
1838 ngx_mp4_set_32value(stsd_atom->size, atom_size);
1839 ngx_mp4_set_atom_name(stsd_atom, 's', 't', 's', 'd');
1840
1841 if (ngx_mp4_atom_data_size(ngx_mp4_stsd_atom_t) > atom_data_size) {
1842 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1843 "\"%s\" mp4 stsd atom too small", mp4->file.name.data);
1844 return NGX_ERROR;
1845 }
1846
1847 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1848 "stsd entries:%uD, media:%*s",
1849 ngx_mp4_get_32value(stsd_atom->entries),
1850 4, stsd_atom->media_name);
1851
1852 trak = ngx_mp4_last_trak(mp4);
1853
1854 atom = &trak->stsd_atom_buf;
1855 atom->temporary = 1;
1856 atom->pos = atom_header;
1857 atom->last = atom_table;
1858
1859 trak->out[NGX_HTTP_MP4_STSD_ATOM].buf = atom;
1860 trak->size += atom_size;
1861
1862 ngx_mp4_atom_next(mp4, atom_data_size);
1863
1864 return NGX_OK;
1865 }
1866
1867
1868 typedef struct {
1869 u_char size[4];
1870 u_char name[4];
1871 u_char version[1];
1872 u_char flags[3];
1873 u_char entries[4];
1874 } ngx_mp4_stts_atom_t;
1875
1876 typedef struct {
1877 u_char count[4];
1878 u_char duration[4];
1879 } ngx_mp4_stts_entry_t;
1880
1881
1882 static ngx_int_t
1883 ngx_http_mp4_read_stts_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
1884 {
1885 u_char *atom_header, *atom_table, *atom_end;
1886 uint32_t entries;
1887 ngx_buf_t *atom, *data;
1888 ngx_mp4_stts_atom_t *stts_atom;
1889 ngx_http_mp4_trak_t *trak;
1890
1891 /* time-to-sample atom */
1892
1893 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stts atom");
1894
1895 atom_header = ngx_mp4_atom_header(mp4);
1896 stts_atom = (ngx_mp4_stts_atom_t *) atom_header;
1897 ngx_mp4_set_atom_name(stts_atom, 's', 't', 't', 's');
1898
1899 if (ngx_mp4_atom_data_size(ngx_mp4_stts_atom_t) > atom_data_size) {
1900 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1901 "\"%s\" mp4 stts atom too small", mp4->file.name.data);
1902 return NGX_ERROR;
1903 }
1904
1905 entries = ngx_mp4_get_32value(stts_atom->entries);
1906
1907 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1908 "mp4 time-to-sample entries:%uD", entries);
1909
1910 if (ngx_mp4_atom_data_size(ngx_mp4_stts_atom_t)
1911 + entries * sizeof(ngx_mp4_stts_entry_t) > atom_data_size)
1912 {
1913 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1914 "\"%s\" mp4 stts atom too small", mp4->file.name.data);
1915 return NGX_ERROR;
1916 }
1917
1918 atom_table = atom_header + sizeof(ngx_mp4_stts_atom_t);
1919 atom_end = atom_table + entries * sizeof(ngx_mp4_stts_entry_t);
1920
1921 trak = ngx_mp4_last_trak(mp4);
1922 trak->time_to_sample_entries = entries;
1923
1924 atom = &trak->stts_atom_buf;
1925 atom->temporary = 1;
1926 atom->pos = atom_header;
1927 atom->last = atom_table;
1928
1929 data = &trak->stts_data_buf;
1930 data->temporary = 1;
1931 data->pos = atom_table;
1932 data->last = atom_end;
1933
1934 trak->out[NGX_HTTP_MP4_STTS_ATOM].buf = atom;
1935 trak->out[NGX_HTTP_MP4_STTS_DATA].buf = data;
1936
1937 ngx_mp4_atom_next(mp4, atom_data_size);
1938
1939 return NGX_OK;
1940 }
1941
1942
1943 static ngx_int_t
1944 ngx_http_mp4_update_stts_atom(ngx_http_mp4_file_t *mp4,
1945 ngx_http_mp4_trak_t *trak)
1946 {
1947 size_t atom_size;
1948 uint32_t entries, count, duration;
1949 uint64_t start_time;
1950 ngx_buf_t *atom, *data;
1951 ngx_uint_t start_sample;
1952 ngx_mp4_stts_atom_t *stts_atom;
1953 ngx_mp4_stts_entry_t *entry, *end;
1954
1955 /*
1956 * mdia.minf.stbl.stts updating requires trak->timescale
1957 * from mdia.mdhd atom which may reside after mdia.minf
1958 */
1959
1960 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1961 "mp4 stts atom update");
1962
1963 data = trak->out[NGX_HTTP_MP4_STTS_DATA].buf;
1964
1965 if (data == NULL) {
1966 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
1967 "no mp4 stts atoms were found in \"%s\"",
1968 mp4->file.name.data);
1969 return NGX_ERROR;
1970 }
1971
1972 entries = trak->time_to_sample_entries;
1973 start_time = (uint64_t) mp4->start * trak->timescale / 1000;
1974
1975 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1976 "time-to-sample start_time:%uL", start_time);
1977
1978 start_sample = 0;
1979 entry = (ngx_mp4_stts_entry_t *) data->pos;
1980 end = (ngx_mp4_stts_entry_t *) data->last;
1981
1982 while (entry < end) {
1983 count = ngx_mp4_get_32value(entry->count);
1984 duration = ngx_mp4_get_32value(entry->duration);
1985
1986 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
1987 "count:%uD, duration:%uD", count, duration);
1988
1989 if (start_time < (uint64_t) count * duration) {
1990 start_sample += (ngx_uint_t) (start_time / duration);
1991 count -= (uint32_t) (start_time / duration);
1992 ngx_mp4_set_32value(entry->count, count);
1993 goto found;
1994 }
1995
1996 start_sample += count;
1997 start_time -= count * duration;
1998 entries--;
1999 entry++;
2000 }
2001
2002 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2003 "start time is out mp4 stts samples in \"%s\"",
2004 mp4->file.name.data);
2005
2006 return NGX_ERROR;
2007
2008 found:
2009
2010 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2011 "start_sample:%ui, new count:%uD", start_sample, count);
2012
2013 trak->start_sample = start_sample;
2014
2015 data->pos = (u_char *) entry;
2016 atom_size = sizeof(ngx_mp4_stts_atom_t) + (data->last - data->pos);
2017 trak->size += atom_size;
2018
2019 atom = trak->out[NGX_HTTP_MP4_STTS_ATOM].buf;
2020 stts_atom = (ngx_mp4_stts_atom_t *) atom->pos;
2021 ngx_mp4_set_32value(stts_atom->size, atom_size);
2022 ngx_mp4_set_32value(stts_atom->entries, entries);
2023
2024 return NGX_OK;
2025 }
2026
2027
2028 typedef struct {
2029 u_char size[4];
2030 u_char name[4];
2031 u_char version[1];
2032 u_char flags[3];
2033 u_char entries[4];
2034 } ngx_http_mp4_stss_atom_t;
2035
2036
2037 static ngx_int_t
2038 ngx_http_mp4_read_stss_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
2039 {
2040 u_char *atom_header, *atom_table, *atom_end;
2041 uint32_t entries;
2042 ngx_buf_t *atom, *data;
2043 ngx_http_mp4_trak_t *trak;
2044 ngx_http_mp4_stss_atom_t *stss_atom;
2045
2046 /* sync samples atom */
2047
2048 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stss atom");
2049
2050 atom_header = ngx_mp4_atom_header(mp4);
2051 stss_atom = (ngx_http_mp4_stss_atom_t *) atom_header;
2052 ngx_mp4_set_atom_name(stss_atom, 's', 't', 's', 's');
2053
2054 if (ngx_mp4_atom_data_size(ngx_http_mp4_stss_atom_t) > atom_data_size) {
2055 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2056 "\"%s\" mp4 stss atom too small", mp4->file.name.data);
2057 return NGX_ERROR;
2058 }
2059
2060 entries = ngx_mp4_get_32value(stss_atom->entries);
2061
2062 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2063 "sync sample entries:%uD", entries);
2064
2065 trak = ngx_mp4_last_trak(mp4);
2066 trak->sync_samples_entries = entries;
2067
2068 atom_table = atom_header + sizeof(ngx_http_mp4_stss_atom_t);
2069
2070 atom = &trak->stss_atom_buf;
2071 atom->temporary = 1;
2072 atom->pos = atom_header;
2073 atom->last = atom_table;
2074
2075 if (ngx_mp4_atom_data_size(ngx_http_mp4_stss_atom_t)
2076 + entries * sizeof(uint32_t) > atom_data_size)
2077 {
2078 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2079 "\"%s\" mp4 stss atom too small", mp4->file.name.data);
2080 return NGX_ERROR;
2081 }
2082
2083 atom_end = atom_table + entries * sizeof(uint32_t);
2084
2085 data = &trak->stss_data_buf;
2086 data->temporary = 1;
2087 data->pos = atom_table;
2088 data->last = atom_end;
2089
2090 trak->out[NGX_HTTP_MP4_STSS_ATOM].buf = atom;
2091 trak->out[NGX_HTTP_MP4_STSS_DATA].buf = data;
2092
2093 ngx_mp4_atom_next(mp4, atom_data_size);
2094
2095 return NGX_OK;
2096 }
2097
2098
2099 static ngx_int_t
2100 ngx_http_mp4_update_stss_atom(ngx_http_mp4_file_t *mp4,
2101 ngx_http_mp4_trak_t *trak)
2102 {
2103 size_t atom_size;
2104 uint32_t entries, sample, start_sample, *entry, *end;
2105 ngx_buf_t *atom, *data;
2106 ngx_http_mp4_stss_atom_t *stss_atom;
2107
2108 /*
2109 * mdia.minf.stbl.stss updating requires trak->start_sample
2110 * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
2111 * atom which may reside after mdia.minf
2112 */
2113
2114 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2115 "mp4 stss atom update");
2116
2117 data = trak->out[NGX_HTTP_MP4_STSS_DATA].buf;
2118
2119 if (data == NULL) {
2120 return NGX_OK;
2121 }
2122
2123 /* sync samples starts from 1 */
2124 start_sample = trak->start_sample + 1;
2125 entries = trak->sync_samples_entries;
2126
2127 entry = (uint32_t *) data->pos;
2128 end = (uint32_t *) data->last;
2129
2130 while (entry < end) {
2131 sample = ngx_mp4_get_32value(entry);
2132
2133 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2134 "start:%uD, sync:%uD", start_sample, sample);
2135
2136 if (sample >= start_sample) {
2137 goto found;
2138 }
2139
2140 entries--;
2141 entry++;
2142 }
2143
2144 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2145 "start sample is out of mp4 stss atom in \"%s\"",
2146 mp4->file.name.data);
2147
2148 return NGX_ERROR;
2149
2150 found:
2151
2152 data->pos = (u_char *) entry;
2153
2154 start_sample = trak->start_sample;
2155
2156 while (entry < end) {
2157 sample = ngx_mp4_get_32value(entry);
2158 sample -= start_sample;
2159 ngx_mp4_set_32value(entry, sample);
2160 entry++;
2161 }
2162
2163 atom_size = sizeof(ngx_http_mp4_stss_atom_t) + (data->last - data->pos);
2164 trak->size += atom_size;
2165
2166 atom = trak->out[NGX_HTTP_MP4_STSS_ATOM].buf;
2167 stss_atom = (ngx_http_mp4_stss_atom_t *) atom->pos;
2168
2169 ngx_mp4_set_32value(stss_atom->size, atom_size);
2170 ngx_mp4_set_32value(stss_atom->entries, entries);
2171
2172 return NGX_OK;
2173 }
2174
2175
2176 typedef struct {
2177 u_char size[4];
2178 u_char name[4];
2179 u_char version[1];
2180 u_char flags[3];
2181 u_char entries[4];
2182 } ngx_mp4_ctts_atom_t;
2183
2184 typedef struct {
2185 u_char count[4];
2186 u_char offset[4];
2187 } ngx_mp4_ctts_entry_t;
2188
2189
2190 static ngx_int_t
2191 ngx_http_mp4_read_ctts_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
2192 {
2193 u_char *atom_header, *atom_table, *atom_end;
2194 uint32_t entries;
2195 ngx_buf_t *atom, *data;
2196 ngx_mp4_ctts_atom_t *ctts_atom;
2197 ngx_http_mp4_trak_t *trak;
2198
2199 /* composition offsets atom */
2200
2201 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 ctts atom");
2202
2203 atom_header = ngx_mp4_atom_header(mp4);
2204 ctts_atom = (ngx_mp4_ctts_atom_t *) atom_header;
2205 ngx_mp4_set_atom_name(ctts_atom, 'c', 't', 't', 's');
2206
2207 if (ngx_mp4_atom_data_size(ngx_mp4_ctts_atom_t) > atom_data_size) {
2208 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2209 "\"%s\" mp4 ctts atom too small", mp4->file.name.data);
2210 return NGX_ERROR;
2211 }
2212
2213 entries = ngx_mp4_get_32value(ctts_atom->entries);
2214
2215 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2216 "composition offset entries:%uD", entries);
2217
2218 trak = ngx_mp4_last_trak(mp4);
2219 trak->composition_offset_entries = entries;
2220
2221 atom_table = atom_header + sizeof(ngx_mp4_ctts_atom_t);
2222
2223 atom = &trak->ctts_atom_buf;
2224 atom->temporary = 1;
2225 atom->pos = atom_header;
2226 atom->last = atom_table;
2227
2228 if (ngx_mp4_atom_data_size(ngx_mp4_ctts_atom_t)
2229 + entries * sizeof(ngx_mp4_ctts_entry_t) > atom_data_size)
2230 {
2231 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2232 "\"%s\" mp4 ctts atom too small", mp4->file.name.data);
2233 return NGX_ERROR;
2234 }
2235
2236 atom_end = atom_table + entries * sizeof(ngx_mp4_ctts_entry_t);
2237
2238 data = &trak->ctts_data_buf;
2239 data->temporary = 1;
2240 data->pos = atom_table;
2241 data->last = atom_end;
2242
2243 trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf = atom;
2244 trak->out[NGX_HTTP_MP4_CTTS_DATA].buf = data;
2245
2246 ngx_mp4_atom_next(mp4, atom_data_size);
2247
2248 return NGX_OK;
2249 }
2250
2251
2252 static void
2253 ngx_http_mp4_update_ctts_atom(ngx_http_mp4_file_t *mp4,
2254 ngx_http_mp4_trak_t *trak)
2255 {
2256 size_t atom_size;
2257 uint32_t entries, count, start_sample;
2258 ngx_buf_t *atom, *data;
2259 ngx_mp4_ctts_atom_t *ctts_atom;
2260 ngx_mp4_ctts_entry_t *entry, *end;
2261
2262 /*
2263 * mdia.minf.stbl.ctts updating requires trak->start_sample
2264 * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
2265 * atom which may reside after mdia.minf
2266 */
2267
2268 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2269 "mp4 ctts atom update");
2270
2271 data = trak->out[NGX_HTTP_MP4_CTTS_DATA].buf;
2272
2273 if (data == NULL) {
2274 return;
2275 }
2276
2277 /* sync samples starts from 1 */
2278 start_sample = trak->start_sample + 1;
2279 entries = trak->composition_offset_entries;
2280 entry = (ngx_mp4_ctts_entry_t *) data->pos;
2281 end = (ngx_mp4_ctts_entry_t *) data->last;
2282
2283 while (entry < end) {
2284 count = ngx_mp4_get_32value(entry->count);
2285
2286 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2287 "start:%uD, count:%uD, offset:%uD",
2288 start_sample, count, ngx_mp4_get_32value(entry->offset));
2289
2290 if (start_sample <= count) {
2291 count -= (start_sample - 1);
2292 ngx_mp4_set_32value(entry->count, count);
2293 goto found;
2294 }
2295
2296 start_sample -= count;
2297 entries--;
2298 entry++;
2299 }
2300
2301 trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf = NULL;
2302 trak->out[NGX_HTTP_MP4_CTTS_DATA].buf = NULL;
2303
2304 return;
2305
2306 found:
2307
2308 data->pos = (u_char *) entry;
2309 atom_size = sizeof(ngx_mp4_ctts_atom_t) + (data->last - data->pos);
2310 trak->size += atom_size;
2311
2312 atom = trak->out[NGX_HTTP_MP4_CTTS_ATOM].buf;
2313 ctts_atom = (ngx_mp4_ctts_atom_t *) atom->pos;
2314
2315 ngx_mp4_set_32value(ctts_atom->size, atom_size);
2316 ngx_mp4_set_32value(ctts_atom->entries, entries);
2317
2318 return;
2319 }
2320
2321
2322 typedef struct {
2323 u_char size[4];
2324 u_char name[4];
2325 u_char version[1];
2326 u_char flags[3];
2327 u_char entries[4];
2328 } ngx_mp4_stsc_atom_t;
2329
2330
2331 static ngx_int_t
2332 ngx_http_mp4_read_stsc_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
2333 {
2334 u_char *atom_header, *atom_table, *atom_end;
2335 uint32_t entries;
2336 ngx_buf_t *atom, *data;
2337 ngx_mp4_stsc_atom_t *stsc_atom;
2338 ngx_http_mp4_trak_t *trak;
2339
2340 /* sample-to-chunk atom */
2341
2342 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stsc atom");
2343
2344 atom_header = ngx_mp4_atom_header(mp4);
2345 stsc_atom = (ngx_mp4_stsc_atom_t *) atom_header;
2346 ngx_mp4_set_atom_name(stsc_atom, 's', 't', 's', 'c');
2347
2348 if (ngx_mp4_atom_data_size(ngx_mp4_stsc_atom_t) > atom_data_size) {
2349 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2350 "\"%s\" mp4 stsc atom too small", mp4->file.name.data);
2351 return NGX_ERROR;
2352 }
2353
2354 entries = ngx_mp4_get_32value(stsc_atom->entries);
2355
2356 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2357 "sample-to-chunk entries:%uD", entries);
2358
2359 if (ngx_mp4_atom_data_size(ngx_mp4_stsc_atom_t)
2360 + entries * sizeof(ngx_mp4_stsc_entry_t) > atom_data_size)
2361 {
2362 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2363 "\"%s\" mp4 stsc atom too small", mp4->file.name.data);
2364 return NGX_ERROR;
2365 }
2366
2367 atom_table = atom_header + sizeof(ngx_mp4_stsc_atom_t);
2368 atom_end = atom_table + entries * sizeof(ngx_mp4_stsc_entry_t);
2369
2370 trak = ngx_mp4_last_trak(mp4);
2371 trak->sample_to_chunk_entries = entries;
2372
2373 atom = &trak->stsc_atom_buf;
2374 atom->temporary = 1;
2375 atom->pos = atom_header;
2376 atom->last = atom_table;
2377
2378 data = &trak->stsc_data_buf;
2379 data->temporary = 1;
2380 data->pos = atom_table;
2381 data->last = atom_end;
2382
2383 trak->out[NGX_HTTP_MP4_STSC_ATOM].buf = atom;
2384 trak->out[NGX_HTTP_MP4_STSC_DATA].buf = data;
2385
2386 ngx_mp4_atom_next(mp4, atom_data_size);
2387
2388 return NGX_OK;
2389 }
2390
2391
2392 static ngx_int_t
2393 ngx_http_mp4_update_stsc_atom(ngx_http_mp4_file_t *mp4,
2394 ngx_http_mp4_trak_t *trak)
2395 {
2396 size_t atom_size;
2397 uint32_t start_sample, entries, chunk, samples, id,
2398 next_chunk, n;
2399 ngx_buf_t *atom, *data, *buf;
2400 ngx_mp4_stsc_atom_t *stsc_atom;
2401 ngx_mp4_stsc_entry_t *entry, *first, *end;
2402
2403 /*
2404 * mdia.minf.stbl.stsc updating requires trak->start_sample
2405 * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
2406 * atom which may reside after mdia.minf
2407 */
2408
2409 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2410 "mp4 stsc atom update");
2411
2412 data = trak->out[NGX_HTTP_MP4_STSC_DATA].buf;
2413
2414 if (data == NULL) {
2415 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2416 "no mp4 stsc atoms were found in \"%s\"",
2417 mp4->file.name.data);
2418 return NGX_ERROR;
2419 }
2420
2421 if (trak->sample_to_chunk_entries == 0) {
2422 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2423 "zero number of entries in stsc atom in \"%s\"",
2424 mp4->file.name.data);
2425 return NGX_ERROR;
2426 }
2427
2428 start_sample = (uint32_t) trak->start_sample;
2429 entries = trak->sample_to_chunk_entries - 1;
2430
2431 entry = (ngx_mp4_stsc_entry_t *) data->pos;
2432 end = (ngx_mp4_stsc_entry_t *) data->last;
2433
2434 chunk = ngx_mp4_get_32value(entry->chunk);
2435 samples = ngx_mp4_get_32value(entry->samples);
2436 id = ngx_mp4_get_32value(entry->id);
2437 entry++;
2438
2439 while (entry < end) {
2440
2441 next_chunk = ngx_mp4_get_32value(entry->chunk);
2442
2443 ngx_log_debug5(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2444 "start_sample:%uD, chunk:%uD, chunks:%uD, "
2445 "samples:%uD, id:%uD",
2446 start_sample, chunk, next_chunk - chunk, samples, id);
2447
2448 n = (next_chunk - chunk) * samples;
2449
2450 if (start_sample <= n) {
2451 goto found;
2452 }
2453
2454 start_sample -= n;
2455
2456 chunk = next_chunk;
2457 samples = ngx_mp4_get_32value(entry->samples);
2458 id = ngx_mp4_get_32value(entry->id);
2459 entries--;
2460 entry++;
2461 }
2462
2463 next_chunk = trak->chunks;
2464
2465 ngx_log_debug4(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2466 "start_sample:%uD, chunk:%uD, chunks:%uD, samples:%uD",
2467 start_sample, chunk, next_chunk - chunk, samples);
2468
2469 n = (next_chunk - chunk) * samples;
2470
2471 if (start_sample > n) {
2472 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2473 "start time is out mp4 stsc chunks in \"%s\"",
2474 mp4->file.name.data);
2475 return NGX_ERROR;
2476 }
2477
2478 found:
2479
2480 entries++;
2481 entry--;
2482
2483 if (samples == 0) {
2484 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2485 "zero number of samples in \"%s\"",
2486 mp4->file.name.data);
2487 return NGX_ERROR;
2488 }
2489
2490 trak->start_chunk = chunk - 1;
2491
2492 trak->start_chunk += start_sample / samples;
2493 trak->chunk_samples = start_sample % samples;
2494
2495 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2496 "start chunk:%ui, samples:%uD",
2497 trak->start_chunk, trak->chunk_samples);
2498
2499 data->pos = (u_char *) entry;
2500 atom_size = sizeof(ngx_mp4_stsc_atom_t) + (data->last - data->pos);
2501
2502 ngx_mp4_set_32value(entry->chunk, 1);
2503
2504 if (trak->chunk_samples && next_chunk - trak->start_chunk == 2) {
2505
2506 /* last chunk in the entry */
2507
2508 ngx_mp4_set_32value(entry->samples, samples - trak->chunk_samples);
2509
2510 } else if (trak->chunk_samples) {
2511
2512 first = &trak->stsc_chunk_entry;
2513 ngx_mp4_set_32value(first->chunk, 1);
2514 ngx_mp4_set_32value(first->samples, samples - trak->chunk_samples);
2515 ngx_mp4_set_32value(first->id, id);
2516
2517 buf = &trak->stsc_chunk_buf;
2518 buf->temporary = 1;
2519 buf->pos = (u_char *) first;
2520 buf->last = (u_char *) first + sizeof(ngx_mp4_stsc_entry_t);
2521
2522 trak->out[NGX_HTTP_MP4_STSC_CHUNK].buf = buf;
2523
2524 ngx_mp4_set_32value(entry->chunk, 2);
2525
2526 entries++;
2527 atom_size += sizeof(ngx_mp4_stsc_entry_t);
2528 }
2529
2530 while (++entry < end) {
2531 chunk = ngx_mp4_get_32value(entry->chunk);
2532 chunk -= trak->start_chunk;
2533 ngx_mp4_set_32value(entry->chunk, chunk);
2534 }
2535
2536 trak->size += atom_size;
2537
2538 atom = trak->out[NGX_HTTP_MP4_STSC_ATOM].buf;
2539 stsc_atom = (ngx_mp4_stsc_atom_t *) atom->pos;
2540
2541 ngx_mp4_set_32value(stsc_atom->size, atom_size);
2542 ngx_mp4_set_32value(stsc_atom->entries, entries);
2543
2544 return NGX_OK;
2545 }
2546
2547
2548 typedef struct {
2549 u_char size[4];
2550 u_char name[4];
2551 u_char version[1];
2552 u_char flags[3];
2553 u_char uniform_size[4];
2554 u_char entries[4];
2555 } ngx_mp4_stsz_atom_t;
2556
2557
2558 static ngx_int_t
2559 ngx_http_mp4_read_stsz_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
2560 {
2561 u_char *atom_header, *atom_table, *atom_end;
2562 size_t atom_size;
2563 uint32_t entries, size;
2564 ngx_buf_t *atom, *data;
2565 ngx_mp4_stsz_atom_t *stsz_atom;
2566 ngx_http_mp4_trak_t *trak;
2567
2568 /* sample sizes atom */
2569
2570 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stsz atom");
2571
2572 atom_header = ngx_mp4_atom_header(mp4);
2573 stsz_atom = (ngx_mp4_stsz_atom_t *) atom_header;
2574 ngx_mp4_set_atom_name(stsz_atom, 's', 't', 's', 'z');
2575
2576 if (ngx_mp4_atom_data_size(ngx_mp4_stsz_atom_t) > atom_data_size) {
2577 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2578 "\"%s\" mp4 stsz atom too small", mp4->file.name.data);
2579 return NGX_ERROR;
2580 }
2581
2582 size = ngx_mp4_get_32value(stsz_atom->uniform_size);
2583 entries = ngx_mp4_get_32value(stsz_atom->entries);
2584
2585 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2586 "sample uniform size:%uD, entries:%uD", size, entries);
2587
2588 trak = ngx_mp4_last_trak(mp4);
2589 trak->sample_sizes_entries = entries;
2590
2591 atom_table = atom_header + sizeof(ngx_mp4_stsz_atom_t);
2592
2593 atom = &trak->stsz_atom_buf;
2594 atom->temporary = 1;
2595 atom->pos = atom_header;
2596 atom->last = atom_table;
2597
2598 trak->out[NGX_HTTP_MP4_STSZ_ATOM].buf = atom;
2599
2600 if (size == 0) {
2601 if (ngx_mp4_atom_data_size(ngx_mp4_stsz_atom_t)
2602 + entries * sizeof(uint32_t) > atom_data_size)
2603 {
2604 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2605 "\"%s\" mp4 stsz atom too small",
2606 mp4->file.name.data);
2607 return NGX_ERROR;
2608 }
2609
2610 atom_end = atom_table + entries * sizeof(uint32_t);
2611
2612 data = &trak->stsz_data_buf;
2613 data->temporary = 1;
2614 data->pos = atom_table;
2615 data->last = atom_end;
2616
2617 trak->out[NGX_HTTP_MP4_STSZ_DATA].buf = data;
2618
2619 } else {
2620 /* if size != 0 then all samples are the same size */
2621 /* TODO : chunk samples */
2622 atom_size = sizeof(ngx_mp4_atom_header_t) + (size_t) atom_data_size;
2623 ngx_mp4_set_32value(atom_header, atom_size);
2624 trak->size += atom_size;
2625 }
2626
2627 ngx_mp4_atom_next(mp4, atom_data_size);
2628
2629 return NGX_OK;
2630 }
2631
2632
2633 static ngx_int_t
2634 ngx_http_mp4_update_stsz_atom(ngx_http_mp4_file_t *mp4,
2635 ngx_http_mp4_trak_t *trak)
2636 {
2637 size_t atom_size;
2638 uint32_t *pos, *end;
2639 ngx_buf_t *atom, *data;
2640 ngx_mp4_stsz_atom_t *stsz_atom;
2641
2642 /*
2643 * mdia.minf.stbl.stsz updating requires trak->start_sample
2644 * from mdia.minf.stbl.stts which depends on value from mdia.mdhd
2645 * atom which may reside after mdia.minf
2646 */
2647
2648 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2649 "mp4 stsz atom update");
2650
2651 data = trak->out[NGX_HTTP_MP4_STSZ_DATA].buf;
2652
2653 if (data) {
2654 if (trak->start_sample > trak->sample_sizes_entries) {
2655 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2656 "start time is out mp4 stsz samples in \"%s\"",
2657 mp4->file.name.data);
2658 return NGX_ERROR;
2659 }
2660
2661 data->pos += trak->start_sample * sizeof(uint32_t);
2662 end = (uint32_t *) data->pos;
2663
2664 for (pos = end - trak->chunk_samples; pos < end; pos++) {
2665 trak->chunk_samples_size += ngx_mp4_get_32value(pos);
2666 }
2667
2668 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2669 "chunk samples sizes:%uL", trak->chunk_samples_size);
2670
2671 atom_size = sizeof(ngx_mp4_stsz_atom_t) + (data->last - data->pos);
2672 trak->size += atom_size;
2673
2674 atom = trak->out[NGX_HTTP_MP4_STSZ_ATOM].buf;
2675 stsz_atom = (ngx_mp4_stsz_atom_t *) atom->pos;
2676
2677 ngx_mp4_set_32value(stsz_atom->size, atom_size);
2678 ngx_mp4_set_32value(stsz_atom->entries,
2679 trak->sample_sizes_entries - trak->start_sample);
2680 }
2681
2682 return NGX_OK;
2683 }
2684
2685
2686 typedef struct {
2687 u_char size[4];
2688 u_char name[4];
2689 u_char version[1];
2690 u_char flags[3];
2691 u_char entries[4];
2692 } ngx_mp4_stco_atom_t;
2693
2694
2695 static ngx_int_t
2696 ngx_http_mp4_read_stco_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
2697 {
2698 u_char *atom_header, *atom_table, *atom_end;
2699 uint32_t entries;
2700 ngx_buf_t *atom, *data;
2701 ngx_mp4_stco_atom_t *stco_atom;
2702 ngx_http_mp4_trak_t *trak;
2703
2704 /* chunk offsets atom */
2705
2706 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 stco atom");
2707
2708 atom_header = ngx_mp4_atom_header(mp4);
2709 stco_atom = (ngx_mp4_stco_atom_t *) atom_header;
2710 ngx_mp4_set_atom_name(stco_atom, 's', 't', 'c', 'o');
2711
2712 if (ngx_mp4_atom_data_size(ngx_mp4_stco_atom_t) > atom_data_size) {
2713 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2714 "\"%s\" mp4 stco atom too small", mp4->file.name.data);
2715 return NGX_ERROR;
2716 }
2717
2718 entries = ngx_mp4_get_32value(stco_atom->entries);
2719
2720 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "chunks:%uD", entries);
2721
2722 if (ngx_mp4_atom_data_size(ngx_mp4_stco_atom_t)
2723 + entries * sizeof(uint32_t) > atom_data_size)
2724 {
2725 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2726 "\"%s\" mp4 stco atom too small", mp4->file.name.data);
2727 return NGX_ERROR;
2728 }
2729
2730 atom_table = atom_header + sizeof(ngx_mp4_stco_atom_t);
2731 atom_end = atom_table + entries * sizeof(uint32_t);
2732
2733 trak = ngx_mp4_last_trak(mp4);
2734 trak->chunks = entries;
2735
2736 atom = &trak->stco_atom_buf;
2737 atom->temporary = 1;
2738 atom->pos = atom_header;
2739 atom->last = atom_table;
2740
2741 data = &trak->stco_data_buf;
2742 data->temporary = 1;
2743 data->pos = atom_table;
2744 data->last = atom_end;
2745
2746 trak->out[NGX_HTTP_MP4_STCO_ATOM].buf = atom;
2747 trak->out[NGX_HTTP_MP4_STCO_DATA].buf = data;
2748
2749 ngx_mp4_atom_next(mp4, atom_data_size);
2750
2751 return NGX_OK;
2752 }
2753
2754
2755 static ngx_int_t
2756 ngx_http_mp4_update_stco_atom(ngx_http_mp4_file_t *mp4,
2757 ngx_http_mp4_trak_t *trak)
2758 {
2759 size_t atom_size;
2760 ngx_buf_t *atom, *data;
2761 ngx_mp4_stco_atom_t *stco_atom;
2762
2763 /*
2764 * mdia.minf.stbl.stco updating requires trak->start_chunk
2765 * from mdia.minf.stbl.stsc which depends on value from mdia.mdhd
2766 * atom which may reside after mdia.minf
2767 */
2768
2769 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2770 "mp4 stco atom update");
2771
2772 data = trak->out[NGX_HTTP_MP4_STCO_DATA].buf;
2773
2774 if (data == NULL) {
2775 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2776 "no mp4 stco atoms were found in \"%s\"",
2777 mp4->file.name.data);
2778 return NGX_ERROR;
2779 }
2780
2781 if (trak->start_chunk > trak->chunks) {
2782 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2783 "start time is out mp4 stco chunks in \"%s\"",
2784 mp4->file.name.data);
2785 return NGX_ERROR;
2786 }
2787
2788 data->pos += trak->start_chunk * sizeof(uint32_t);
2789 atom_size = sizeof(ngx_mp4_stco_atom_t) + (data->last - data->pos);
2790 trak->size += atom_size;
2791
2792 trak->start_offset = ngx_mp4_get_32value(data->pos);
2793 trak->start_offset += trak->chunk_samples_size;
2794 ngx_mp4_set_32value(data->pos, trak->start_offset);
2795
2796 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2797 "start chunk offset:%uD", trak->start_offset);
2798
2799 atom = trak->out[NGX_HTTP_MP4_STCO_ATOM].buf;
2800 stco_atom = (ngx_mp4_stco_atom_t *) atom->pos;
2801
2802 ngx_mp4_set_32value(stco_atom->size, atom_size);
2803 ngx_mp4_set_32value(stco_atom->entries, trak->chunks - trak->start_chunk);
2804
2805 return NGX_OK;
2806 }
2807
2808
2809 static void
2810 ngx_http_mp4_adjust_stco_atom(ngx_http_mp4_file_t *mp4,
2811 ngx_http_mp4_trak_t *trak, int32_t adjustment)
2812 {
2813 uint32_t offset, *entry, *end;
2814 ngx_buf_t *data;
2815
2816 /*
2817 * moov.trak.mdia.minf.stbl.stco adjustment requires
2818 * minimal start offset of all traks and new moov atom size
2819 */
2820
2821 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2822 "mp4 stco atom adjustment");
2823
2824 data = trak->out[NGX_HTTP_MP4_STCO_DATA].buf;
2825 entry = (uint32_t *) data->pos;
2826 end = (uint32_t *) data->last;
2827
2828 while (entry < end) {
2829 offset = ngx_mp4_get_32value(entry);
2830 offset += adjustment;
2831 ngx_mp4_set_32value(entry, offset);
2832 entry++;
2833 }
2834 }
2835
2836
2837 typedef struct {
2838 u_char size[4];
2839 u_char name[4];
2840 u_char version[1];
2841 u_char flags[3];
2842 u_char entries[4];
2843 } ngx_mp4_co64_atom_t;
2844
2845
2846 static ngx_int_t
2847 ngx_http_mp4_read_co64_atom(ngx_http_mp4_file_t *mp4, uint64_t atom_data_size)
2848 {
2849 u_char *atom_header, *atom_table, *atom_end;
2850 uint32_t entries;
2851 ngx_buf_t *atom, *data;
2852 ngx_mp4_co64_atom_t *co64_atom;
2853 ngx_http_mp4_trak_t *trak;
2854
2855 /* chunk offsets atom */
2856
2857 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "mp4 co64 atom");
2858
2859 atom_header = ngx_mp4_atom_header(mp4);
2860 co64_atom = (ngx_mp4_co64_atom_t *) atom_header;
2861 ngx_mp4_set_atom_name(co64_atom, 'c', 'o', '6', '4');
2862
2863 if (ngx_mp4_atom_data_size(ngx_mp4_co64_atom_t) > atom_data_size) {
2864 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2865 "\"%s\" mp4 co64 atom too small", mp4->file.name.data);
2866 return NGX_ERROR;
2867 }
2868
2869 entries = ngx_mp4_get_32value(co64_atom->entries);
2870
2871 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0, "chunks:%uD", entries);
2872
2873 if (ngx_mp4_atom_data_size(ngx_mp4_co64_atom_t)
2874 + entries * sizeof(uint64_t) > atom_data_size)
2875 {
2876 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2877 "\"%s\" mp4 co64 atom too small", mp4->file.name.data);
2878 return NGX_ERROR;
2879 }
2880
2881 atom_table = atom_header + sizeof(ngx_mp4_co64_atom_t);
2882 atom_end = atom_table + entries * sizeof(uint64_t);
2883
2884 trak = ngx_mp4_last_trak(mp4);
2885 trak->chunks = entries;
2886
2887 atom = &trak->co64_atom_buf;
2888 atom->temporary = 1;
2889 atom->pos = atom_header;
2890 atom->last = atom_table;
2891
2892 data = &trak->co64_data_buf;
2893 data->temporary = 1;
2894 data->pos = atom_table;
2895 data->last = atom_end;
2896
2897 trak->out[NGX_HTTP_MP4_CO64_ATOM].buf = atom;
2898 trak->out[NGX_HTTP_MP4_CO64_DATA].buf = data;
2899
2900 ngx_mp4_atom_next(mp4, atom_data_size);
2901
2902 return NGX_OK;
2903 }
2904
2905
2906 static ngx_int_t
2907 ngx_http_mp4_update_co64_atom(ngx_http_mp4_file_t *mp4,
2908 ngx_http_mp4_trak_t *trak)
2909 {
2910 size_t atom_size;
2911 ngx_buf_t *atom, *data;
2912 ngx_mp4_co64_atom_t *co64_atom;
2913
2914 /*
2915 * mdia.minf.stbl.co64 updating requires trak->start_chunk
2916 * from mdia.minf.stbl.stsc which depends on value from mdia.mdhd
2917 * atom which may reside after mdia.minf
2918 */
2919
2920 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2921 "mp4 co64 atom update");
2922
2923 data = trak->out[NGX_HTTP_MP4_CO64_DATA].buf;
2924
2925 if (data == NULL) {
2926 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2927 "no mp4 co64 atoms were found in \"%s\"",
2928 mp4->file.name.data);
2929 return NGX_ERROR;
2930 }
2931
2932 if (trak->start_chunk > trak->chunks) {
2933 ngx_log_error(NGX_LOG_ERR, mp4->file.log, 0,
2934 "start time is out mp4 co64 chunks in \"%s\"",
2935 mp4->file.name.data);
2936 return NGX_ERROR;
2937 }
2938
2939 data->pos += trak->start_chunk * sizeof(uint64_t);
2940 atom_size = sizeof(ngx_mp4_co64_atom_t) + (data->last - data->pos);
2941 trak->size += atom_size;
2942
2943 trak->start_offset = ngx_mp4_get_64value(data->pos);
2944 trak->start_offset += trak->chunk_samples_size;
2945 ngx_mp4_set_64value(data->pos, trak->start_offset);
2946
2947 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2948 "start chunk offset:%uL", trak->start_offset);
2949
2950 atom = trak->out[NGX_HTTP_MP4_CO64_ATOM].buf;
2951 co64_atom = (ngx_mp4_co64_atom_t *) atom->pos;
2952
2953 ngx_mp4_set_32value(co64_atom->size, atom_size);
2954 ngx_mp4_set_32value(co64_atom->entries, trak->chunks - trak->start_chunk);
2955
2956 return NGX_OK;
2957 }
2958
2959
2960 static void
2961 ngx_http_mp4_adjust_co64_atom(ngx_http_mp4_file_t *mp4,
2962 ngx_http_mp4_trak_t *trak, off_t adjustment)
2963 {
2964 uint64_t offset, *entry, *end;
2965 ngx_buf_t *data;
2966
2967 /*
2968 * moov.trak.mdia.minf.stbl.co64 adjustment requires
2969 * minimal start offset of all traks and new moov atom size
2970 */
2971
2972 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, mp4->file.log, 0,
2973 "mp4 co64 atom adjustment");
2974
2975 data = trak->out[NGX_HTTP_MP4_CO64_DATA].buf;
2976 entry = (uint64_t *) data->pos;
2977 end = (uint64_t *) data->last;
2978
2979 while (entry < end) {
2980 offset = ngx_mp4_get_64value(entry);
2981 offset += adjustment;
2982 ngx_mp4_set_64value(entry, offset);
2983 entry++;
2984 }
2985 }
2986
2987
2988 static char *
2989 ngx_http_mp4(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
2990 {
2991 ngx_http_core_loc_conf_t *clcf;
2992
2993 clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
2994 clcf->handler = ngx_http_mp4_handler;
2995
2996 return NGX_CONF_OK;
2997 }
2998
2999
3000 static void *
3001 ngx_http_mp4_create_conf(ngx_conf_t *cf)
3002 {
3003 ngx_http_mp4_conf_t *conf;
3004
3005 conf = ngx_palloc(cf->pool, sizeof(ngx_http_mp4_conf_t));
3006 if (conf == NULL) {
3007 return NULL;
3008 }
3009
3010 conf->buffer_size = NGX_CONF_UNSET_SIZE;
3011 conf->max_buffer_size = NGX_CONF_UNSET_SIZE;
3012
3013 return conf;
3014 }
3015
3016
3017 static char *
3018 ngx_http_mp4_merge_conf(ngx_conf_t *cf, void *parent, void *child)
3019 {
3020 ngx_http_mp4_conf_t *prev = parent;
3021 ngx_http_mp4_conf_t *conf = child;
3022
3023 ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size, 512 * 1024);
3024 ngx_conf_merge_size_value(conf->max_buffer_size, prev->max_buffer_size,
3025 10 * 1024 * 1024);
3026
3027 return NGX_CONF_OK;
3028 }
Tomato firmware and modifications.