Annotation of embedaddon/nginx/src/http/modules/ngx_http_mp4_module.c, revision 1.1.1.1
1.1 misho 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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_http_mp4_module.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http / modules