Mercurial > audlegacy
comparison Plugins/Input/aac/mp4ff/mp4tagupdate.c @ 1020:d70514b3b436 trunk
[svn] - stuff
author | nenolod |
---|---|
date | Wed, 10 May 2006 14:41:23 -0700 |
parents | |
children | c59fe7000c95 |
comparison
equal
deleted
inserted
replaced
1019:5567ab3f2918 | 1020:d70514b3b436 |
---|---|
1 #include <stdlib.h> | |
2 #include <string.h> | |
3 #include "mp4ffint.h" | |
4 | |
5 #ifdef USE_TAGGING | |
6 | |
7 static uint32_t fix_byte_order_32(uint32_t src) | |
8 { | |
9 uint32_t result; | |
10 uint32_t a, b, c, d; | |
11 int8_t data[4]; | |
12 | |
13 memcpy(data,&src,sizeof(src)); | |
14 a = (uint8_t)data[0]; | |
15 b = (uint8_t)data[1]; | |
16 c = (uint8_t)data[2]; | |
17 d = (uint8_t)data[3]; | |
18 | |
19 result = (a<<24) | (b<<16) | (c<<8) | d; | |
20 return (uint32_t)result; | |
21 } | |
22 | |
23 typedef struct | |
24 { | |
25 void * data; | |
26 unsigned written; | |
27 unsigned allocated; | |
28 unsigned error; | |
29 } membuffer; | |
30 | |
31 unsigned membuffer_write(membuffer * buf,const void * ptr,unsigned bytes) | |
32 { | |
33 unsigned dest_size = buf->written + bytes; | |
34 | |
35 if (buf->error) return 0; | |
36 if (dest_size > buf->allocated) | |
37 { | |
38 do | |
39 { | |
40 buf->allocated <<= 1; | |
41 } while(dest_size > buf->allocated); | |
42 | |
43 { | |
44 void * newptr = realloc(buf->data,buf->allocated); | |
45 if (newptr==0) | |
46 { | |
47 free(buf->data); | |
48 buf->data = 0; | |
49 buf->error = 1; | |
50 return 0; | |
51 } | |
52 buf->data = newptr; | |
53 } | |
54 } | |
55 | |
56 if (ptr) memcpy((char*)buf->data + buf->written,ptr,bytes); | |
57 buf->written += bytes; | |
58 return bytes; | |
59 } | |
60 | |
61 #define membuffer_write_data membuffer_write | |
62 | |
63 unsigned membuffer_write_int32(membuffer * buf,uint32_t data) | |
64 { | |
65 uint8_t temp[4] = {(uint8_t)(data>>24),(uint8_t)(data>>16),(uint8_t)(data>>8),(uint8_t)data}; | |
66 return membuffer_write_data(buf,temp,4); | |
67 } | |
68 | |
69 unsigned membuffer_write_int24(membuffer * buf,uint32_t data) | |
70 { | |
71 uint8_t temp[3] = {(uint8_t)(data>>16),(uint8_t)(data>>8),(uint8_t)data}; | |
72 return membuffer_write_data(buf,temp,3); | |
73 } | |
74 | |
75 unsigned membuffer_write_int16(membuffer * buf,uint16_t data) | |
76 { | |
77 uint8_t temp[2] = {(uint8_t)(data>>8),(uint8_t)data}; | |
78 return membuffer_write_data(buf,temp,2); | |
79 } | |
80 | |
81 unsigned membuffer_write_atom_name(membuffer * buf,const char * data) | |
82 { | |
83 return membuffer_write_data(buf,data,4)==4 ? 1 : 0; | |
84 } | |
85 | |
86 void membuffer_write_atom(membuffer * buf,const char * name,unsigned size,const void * data) | |
87 { | |
88 membuffer_write_int32(buf,size + 8); | |
89 membuffer_write_atom_name(buf,name); | |
90 membuffer_write_data(buf,data,size); | |
91 } | |
92 | |
93 unsigned membuffer_write_string(membuffer * buf,const char * data) | |
94 { | |
95 return membuffer_write_data(buf,data,strlen(data)); | |
96 } | |
97 | |
98 unsigned membuffer_write_int8(membuffer * buf,uint8_t data) | |
99 { | |
100 return membuffer_write_data(buf,&data,1); | |
101 } | |
102 | |
103 void * membuffer_get_ptr(const membuffer * buf) | |
104 { | |
105 return buf->data; | |
106 } | |
107 | |
108 unsigned membuffer_get_size(const membuffer * buf) | |
109 { | |
110 return buf->written; | |
111 } | |
112 | |
113 unsigned membuffer_error(const membuffer * buf) | |
114 { | |
115 return buf->error; | |
116 } | |
117 | |
118 void membuffer_set_error(membuffer * buf) {buf->error = 1;} | |
119 | |
120 unsigned membuffer_transfer_from_file(membuffer * buf,mp4ff_t * src,unsigned bytes) | |
121 { | |
122 unsigned oldsize; | |
123 void * bufptr; | |
124 | |
125 oldsize = membuffer_get_size(buf); | |
126 if (membuffer_write_data(buf,0,bytes) != bytes) return 0; | |
127 | |
128 bufptr = membuffer_get_ptr(buf); | |
129 if (bufptr==0) return 0; | |
130 | |
131 if ((unsigned)mp4ff_read_data(src,(char*)bufptr + oldsize,bytes)!=bytes) | |
132 { | |
133 membuffer_set_error(buf); | |
134 return 0; | |
135 } | |
136 | |
137 return bytes; | |
138 } | |
139 | |
140 | |
141 membuffer * membuffer_create() | |
142 { | |
143 const unsigned initial_size = 256; | |
144 | |
145 membuffer * buf = (membuffer *) malloc(sizeof(membuffer)); | |
146 buf->data = malloc(initial_size); | |
147 buf->written = 0; | |
148 buf->allocated = initial_size; | |
149 buf->error = buf->data == 0 ? 1 : 0; | |
150 | |
151 return buf; | |
152 } | |
153 | |
154 void membuffer_free(membuffer * buf) | |
155 { | |
156 if (buf->data) free(buf->data); | |
157 free(buf); | |
158 } | |
159 | |
160 void * membuffer_detach(membuffer * buf) | |
161 { | |
162 void * ret; | |
163 | |
164 if (buf->error) return 0; | |
165 | |
166 ret = realloc(buf->data,buf->written); | |
167 | |
168 if (ret == 0) free(buf->data); | |
169 | |
170 buf->data = 0; | |
171 buf->error = 1; | |
172 | |
173 return ret; | |
174 } | |
175 | |
176 #if 0 | |
177 /* metadata tag structure */ | |
178 typedef struct | |
179 { | |
180 char *item; | |
181 char *value; | |
182 } mp4ff_tag_t; | |
183 | |
184 /* metadata list structure */ | |
185 typedef struct | |
186 { | |
187 mp4ff_tag_t *tags; | |
188 uint32_t count; | |
189 } mp4ff_metadata_t; | |
190 #endif | |
191 | |
192 typedef struct | |
193 { | |
194 const char * atom; | |
195 const char * name; | |
196 } stdmeta_entry; | |
197 | |
198 static stdmeta_entry stdmetas[] = | |
199 { | |
200 {"©nam","title"}, | |
201 {"©ART","artist"}, | |
202 {"©wrt","writer"}, | |
203 {"©alb","album"}, | |
204 {"©day","date"}, | |
205 {"©too","tool"}, | |
206 {"©cmt","comment"}, | |
207 // {"©gen","genre"}, | |
208 {"cpil","compilation"}, | |
209 // {"trkn","track"}, | |
210 // {"disk","disc"}, | |
211 // {"gnre","genre"}, | |
212 {"covr","cover"}, | |
213 }; | |
214 | |
215 | |
216 static const char* find_standard_meta(const char * name) //returns atom name if found, 0 if not | |
217 { | |
218 unsigned n; | |
219 for(n=0;n<sizeof(stdmetas)/sizeof(stdmetas[0]);n++) | |
220 { | |
221 if (!stricmp(name,stdmetas[n].name)) return stdmetas[n].atom; | |
222 } | |
223 return 0; | |
224 } | |
225 | |
226 static void membuffer_write_track_tag(membuffer * buf,const char * name,uint32_t index,uint32_t total) | |
227 { | |
228 membuffer_write_int32(buf,8 /*atom header*/ + 8 /*data atom header*/ + 8 /*flags + reserved*/ + 8 /*actual data*/ ); | |
229 membuffer_write_atom_name(buf,name); | |
230 membuffer_write_int32(buf,8 /*data atom header*/ + 8 /*flags + reserved*/ + 8 /*actual data*/ ); | |
231 membuffer_write_atom_name(buf,"data"); | |
232 membuffer_write_int32(buf,0);//flags | |
233 membuffer_write_int32(buf,0);//reserved | |
234 membuffer_write_int16(buf,0); | |
235 membuffer_write_int16(buf,(uint16_t)index);//track number | |
236 membuffer_write_int16(buf,(uint16_t)total);//total tracks | |
237 membuffer_write_int16(buf,0); | |
238 } | |
239 | |
240 static void membuffer_write_int16_tag(membuffer * buf,const char * name,uint16_t value) | |
241 { | |
242 membuffer_write_int32(buf,8 /*atom header*/ + 8 /*data atom header*/ + 8 /*flags + reserved*/ + 2 /*actual data*/ ); | |
243 membuffer_write_atom_name(buf,name); | |
244 membuffer_write_int32(buf,8 /*data atom header*/ + 8 /*flags + reserved*/ + 2 /*actual data*/ ); | |
245 membuffer_write_atom_name(buf,"data"); | |
246 membuffer_write_int32(buf,0);//flags | |
247 membuffer_write_int32(buf,0);//reserved | |
248 membuffer_write_int16(buf,value);//value | |
249 } | |
250 | |
251 static void membuffer_write_std_tag(membuffer * buf,const char * name,const char * value) | |
252 { | |
253 membuffer_write_int32(buf,8 /*atom header*/ + 8 /*data atom header*/ + 8 /*flags + reserved*/ + strlen(value) ); | |
254 membuffer_write_atom_name(buf,name); | |
255 membuffer_write_int32(buf,8 /*data atom header*/ + 8 /*flags + reserved*/ + strlen(value)); | |
256 membuffer_write_atom_name(buf,"data"); | |
257 membuffer_write_int32(buf,1);//flags | |
258 membuffer_write_int32(buf,0);//reserved | |
259 membuffer_write_data(buf,value,strlen(value)); | |
260 } | |
261 | |
262 static void membuffer_write_custom_tag(membuffer * buf,const char * name,const char * value) | |
263 { | |
264 membuffer_write_int32(buf,8 /*atom header*/ + 0x1C /*weirdo itunes atom*/ + 12 /*name atom header*/ + strlen(name) + 16 /*data atom header + flags*/ + strlen(value) ); | |
265 membuffer_write_atom_name(buf,"----"); | |
266 membuffer_write_int32(buf,0x1C);//weirdo itunes atom | |
267 membuffer_write_atom_name(buf,"mean"); | |
268 membuffer_write_int32(buf,0); | |
269 membuffer_write_data(buf,"com.apple.iTunes",16); | |
270 membuffer_write_int32(buf,12 + strlen(name)); | |
271 membuffer_write_atom_name(buf,"name"); | |
272 membuffer_write_int32(buf,0); | |
273 membuffer_write_data(buf,name,strlen(name)); | |
274 membuffer_write_int32(buf,8 /*data atom header*/ + 8 /*flags + reserved*/ + strlen(value)); | |
275 membuffer_write_atom_name(buf,"data"); | |
276 membuffer_write_int32(buf,1);//flags | |
277 membuffer_write_int32(buf,0);//reserved | |
278 membuffer_write_data(buf,value,strlen(value)); | |
279 | |
280 } | |
281 | |
282 static uint32_t myatoi(const char * param) | |
283 { | |
284 return param ? atoi(param) : 0; | |
285 } | |
286 | |
287 static uint32_t create_ilst(const mp4ff_metadata_t * data,void ** out_buffer,uint32_t * out_size) | |
288 { | |
289 membuffer * buf = membuffer_create(); | |
290 unsigned metaptr; | |
291 char * mask = (char*)malloc(data->count); | |
292 memset(mask,0,data->count); | |
293 | |
294 { | |
295 const char * tracknumber_ptr = 0, * totaltracks_ptr = 0; | |
296 const char * discnumber_ptr = 0, * totaldiscs_ptr = 0; | |
297 const char * genre_ptr = 0, * tempo_ptr = 0; | |
298 for(metaptr = 0; metaptr < data->count; metaptr++) | |
299 { | |
300 mp4ff_tag_t * tag = &data->tags[metaptr]; | |
301 if (!stricmp(tag->item,"tracknumber") || !stricmp(tag->item,"track")) | |
302 { | |
303 if (tracknumber_ptr==0) tracknumber_ptr = tag->value; | |
304 mask[metaptr] = 1; | |
305 } | |
306 else if (!stricmp(tag->item,"totaltracks")) | |
307 { | |
308 if (totaltracks_ptr==0) totaltracks_ptr = tag->value; | |
309 mask[metaptr] = 1; | |
310 } | |
311 else if (!stricmp(tag->item,"discnumber") || !stricmp(tag->item,"disc")) | |
312 { | |
313 if (discnumber_ptr==0) discnumber_ptr = tag->value; | |
314 mask[metaptr] = 1; | |
315 } | |
316 else if (!stricmp(tag->item,"totaldiscs")) | |
317 { | |
318 if (totaldiscs_ptr==0) totaldiscs_ptr = tag->value; | |
319 mask[metaptr] = 1; | |
320 } | |
321 else if (!stricmp(tag->item,"genre")) | |
322 { | |
323 if (genre_ptr==0) genre_ptr = tag->value; | |
324 mask[metaptr] = 1; | |
325 } | |
326 else if (!stricmp(tag->item,"tempo")) | |
327 { | |
328 if (tempo_ptr==0) tempo_ptr = tag->value; | |
329 mask[metaptr] = 1; | |
330 } | |
331 | |
332 } | |
333 | |
334 if (tracknumber_ptr) membuffer_write_track_tag(buf,"trkn",myatoi(tracknumber_ptr),myatoi(totaltracks_ptr)); | |
335 if (discnumber_ptr) membuffer_write_track_tag(buf,"disk",myatoi(discnumber_ptr),myatoi(totaldiscs_ptr)); | |
336 if (tempo_ptr) membuffer_write_int16_tag(buf,"tmpo",(uint16_t)myatoi(tempo_ptr)); | |
337 | |
338 if (genre_ptr) | |
339 { | |
340 uint32_t index = mp4ff_meta_genre_to_index(genre_ptr); | |
341 if (index==0) | |
342 membuffer_write_std_tag(buf,"©gen",genre_ptr); | |
343 else | |
344 membuffer_write_int16_tag(buf,"gnre",(uint16_t)index); | |
345 } | |
346 } | |
347 | |
348 for(metaptr = 0; metaptr < data->count; metaptr++) | |
349 { | |
350 if (!mask[metaptr]) | |
351 { | |
352 mp4ff_tag_t * tag = &data->tags[metaptr]; | |
353 const char * std_meta_atom = find_standard_meta(tag->item); | |
354 if (std_meta_atom) | |
355 { | |
356 membuffer_write_std_tag(buf,std_meta_atom,tag->value); | |
357 } | |
358 else | |
359 { | |
360 membuffer_write_custom_tag(buf,tag->item,tag->value); | |
361 } | |
362 } | |
363 } | |
364 | |
365 free(mask); | |
366 | |
367 if (membuffer_error(buf)) | |
368 { | |
369 membuffer_free(buf); | |
370 return 0; | |
371 } | |
372 | |
373 *out_size = membuffer_get_size(buf); | |
374 *out_buffer = membuffer_detach(buf); | |
375 membuffer_free(buf); | |
376 | |
377 return 1; | |
378 } | |
379 | |
380 static uint32_t find_atom(mp4ff_t * f,uint64_t base,uint32_t size,const char * name) | |
381 { | |
382 uint32_t remaining = size; | |
383 uint64_t atom_offset = base; | |
384 for(;;) | |
385 { | |
386 char atom_name[4]; | |
387 uint32_t atom_size; | |
388 | |
389 mp4ff_set_position(f,atom_offset); | |
390 | |
391 if (remaining < 8) break; | |
392 atom_size = mp4ff_read_int32(f); | |
393 if (atom_size > remaining || atom_size < 8) break; | |
394 mp4ff_read_data(f,atom_name,4); | |
395 | |
396 if (!memcmp(atom_name,name,4)) | |
397 { | |
398 mp4ff_set_position(f,atom_offset); | |
399 return 1; | |
400 } | |
401 | |
402 remaining -= atom_size; | |
403 atom_offset += atom_size; | |
404 } | |
405 return 0; | |
406 } | |
407 | |
408 static uint32_t find_atom_v2(mp4ff_t * f,uint64_t base,uint32_t size,const char * name,uint32_t extraheaders,const char * name_inside) | |
409 { | |
410 uint64_t first_base = (uint64_t)(-1); | |
411 while(find_atom(f,base,size,name))//try to find atom <name> with atom <name_inside> in it | |
412 { | |
413 uint64_t mybase = mp4ff_position(f); | |
414 uint32_t mysize = mp4ff_read_int32(f); | |
415 | |
416 if (first_base == (uint64_t)(-1)) first_base = mybase; | |
417 | |
418 if (mysize < 8 + extraheaders) break; | |
419 | |
420 if (find_atom(f,mybase+(8+extraheaders),mysize-(8+extraheaders),name_inside)) | |
421 { | |
422 mp4ff_set_position(f,mybase); | |
423 return 2; | |
424 } | |
425 base += mysize; | |
426 if (size<=mysize) {size=0;break;} | |
427 size -= mysize; | |
428 } | |
429 | |
430 if (first_base != (uint64_t)(-1))//wanted atom inside not found | |
431 { | |
432 mp4ff_set_position(f,first_base); | |
433 return 1; | |
434 } | |
435 else return 0; | |
436 } | |
437 | |
438 static uint32_t create_meta(const mp4ff_metadata_t * data,void ** out_buffer,uint32_t * out_size) | |
439 { | |
440 membuffer * buf; | |
441 uint32_t ilst_size; | |
442 void * ilst_buffer; | |
443 | |
444 if (!create_ilst(data,&ilst_buffer,&ilst_size)) return 0; | |
445 | |
446 buf = membuffer_create(); | |
447 | |
448 membuffer_write_int32(buf,0); | |
449 membuffer_write_atom(buf,"ilst",ilst_size,ilst_buffer); | |
450 free(ilst_buffer); | |
451 | |
452 *out_size = membuffer_get_size(buf); | |
453 *out_buffer = membuffer_detach(buf); | |
454 membuffer_free(buf); | |
455 return 1; | |
456 } | |
457 | |
458 static uint32_t create_udta(const mp4ff_metadata_t * data,void ** out_buffer,uint32_t * out_size) | |
459 { | |
460 membuffer * buf; | |
461 uint32_t meta_size; | |
462 void * meta_buffer; | |
463 | |
464 if (!create_meta(data,&meta_buffer,&meta_size)) return 0; | |
465 | |
466 buf = membuffer_create(); | |
467 | |
468 membuffer_write_atom(buf,"meta",meta_size,meta_buffer); | |
469 | |
470 free(meta_buffer); | |
471 | |
472 *out_size = membuffer_get_size(buf); | |
473 *out_buffer = membuffer_detach(buf); | |
474 membuffer_free(buf); | |
475 return 1; | |
476 } | |
477 | |
478 static uint32_t modify_moov(mp4ff_t * f,const mp4ff_metadata_t * data,void ** out_buffer,uint32_t * out_size) | |
479 { | |
480 uint64_t total_base = f->moov_offset + 8; | |
481 uint32_t total_size = (uint32_t)(f->moov_size - 8); | |
482 | |
483 uint64_t udta_offset,meta_offset,ilst_offset; | |
484 uint32_t udta_size, meta_size, ilst_size; | |
485 | |
486 uint32_t new_ilst_size; | |
487 void * new_ilst_buffer; | |
488 | |
489 uint8_t * p_out; | |
490 int32_t size_delta; | |
491 | |
492 | |
493 if (!find_atom_v2(f,total_base,total_size,"udta",0,"meta")) | |
494 { | |
495 membuffer * buf; | |
496 void * new_udta_buffer; | |
497 uint32_t new_udta_size; | |
498 if (!create_udta(data,&new_udta_buffer,&new_udta_size)) return 0; | |
499 | |
500 buf = membuffer_create(); | |
501 mp4ff_set_position(f,total_base); | |
502 membuffer_transfer_from_file(buf,f,total_size); | |
503 | |
504 membuffer_write_atom(buf,"udta",new_udta_size,new_udta_buffer); | |
505 | |
506 free(new_udta_buffer); | |
507 | |
508 *out_size = membuffer_get_size(buf); | |
509 *out_buffer = membuffer_detach(buf); | |
510 membuffer_free(buf); | |
511 return 1; | |
512 } | |
513 else | |
514 { | |
515 udta_offset = mp4ff_position(f); | |
516 udta_size = mp4ff_read_int32(f); | |
517 if (find_atom_v2(f,udta_offset+8,udta_size-8,"meta",4,"ilst")<2) | |
518 { | |
519 membuffer * buf; | |
520 void * new_meta_buffer; | |
521 uint32_t new_meta_size; | |
522 if (!create_meta(data,&new_meta_buffer,&new_meta_size)) return 0; | |
523 | |
524 buf = membuffer_create(); | |
525 mp4ff_set_position(f,total_base); | |
526 membuffer_transfer_from_file(buf,f,(uint32_t)(udta_offset - total_base)); | |
527 | |
528 membuffer_write_int32(buf,udta_size + 8 + new_meta_size); | |
529 membuffer_write_atom_name(buf,"udta"); | |
530 membuffer_transfer_from_file(buf,f,udta_size); | |
531 | |
532 membuffer_write_atom(buf,"meta",new_meta_size,new_meta_buffer); | |
533 free(new_meta_buffer); | |
534 | |
535 *out_size = membuffer_get_size(buf); | |
536 *out_buffer = membuffer_detach(buf); | |
537 membuffer_free(buf); | |
538 return 1; | |
539 } | |
540 meta_offset = mp4ff_position(f); | |
541 meta_size = mp4ff_read_int32(f); | |
542 if (!find_atom(f,meta_offset+12,meta_size-12,"ilst")) return 0;//shouldn't happen, find_atom_v2 above takes care of it | |
543 ilst_offset = mp4ff_position(f); | |
544 ilst_size = mp4ff_read_int32(f); | |
545 | |
546 if (!create_ilst(data,&new_ilst_buffer,&new_ilst_size)) return 0; | |
547 | |
548 size_delta = new_ilst_size - (ilst_size - 8); | |
549 | |
550 *out_size = total_size + size_delta; | |
551 *out_buffer = malloc(*out_size); | |
552 if (*out_buffer == 0) | |
553 { | |
554 free(new_ilst_buffer); | |
555 return 0; | |
556 } | |
557 | |
558 p_out = (uint8_t*)*out_buffer; | |
559 | |
560 mp4ff_set_position(f,total_base); | |
561 mp4ff_read_data(f,p_out,(uint32_t)(udta_offset - total_base )); p_out += (uint32_t)(udta_offset - total_base ); | |
562 *(uint32_t*)p_out = fix_byte_order_32(mp4ff_read_int32(f) + size_delta); p_out += 4; | |
563 mp4ff_read_data(f,p_out,4); p_out += 4; | |
564 mp4ff_read_data(f,p_out,(uint32_t)(meta_offset - udta_offset - 8)); p_out += (uint32_t)(meta_offset - udta_offset - 8); | |
565 *(uint32_t*)p_out = fix_byte_order_32(mp4ff_read_int32(f) + size_delta); p_out += 4; | |
566 mp4ff_read_data(f,p_out,4); p_out += 4; | |
567 mp4ff_read_data(f,p_out,(uint32_t)(ilst_offset - meta_offset - 8)); p_out += (uint32_t)(ilst_offset - meta_offset - 8); | |
568 *(uint32_t*)p_out = fix_byte_order_32(mp4ff_read_int32(f) + size_delta); p_out += 4; | |
569 mp4ff_read_data(f,p_out,4); p_out += 4; | |
570 | |
571 memcpy(p_out,new_ilst_buffer,new_ilst_size); | |
572 p_out += new_ilst_size; | |
573 | |
574 mp4ff_set_position(f,ilst_offset + ilst_size); | |
575 mp4ff_read_data(f,p_out,(uint32_t)(total_size - (ilst_offset - total_base) - ilst_size)); | |
576 | |
577 free(new_ilst_buffer); | |
578 } | |
579 return 1; | |
580 | |
581 } | |
582 | |
583 int32_t mp4ff_meta_update(mp4ff_callback_t *f,const mp4ff_metadata_t * data) | |
584 { | |
585 void * new_moov_data; | |
586 uint32_t new_moov_size; | |
587 | |
588 mp4ff_t *ff = malloc(sizeof(mp4ff_t)); | |
589 | |
590 memset(ff, 0, sizeof(mp4ff_t)); | |
591 ff->stream = f; | |
592 mp4ff_set_position(ff,0); | |
593 | |
594 parse_atoms(ff); | |
595 | |
596 | |
597 if (!modify_moov(ff,data,&new_moov_data,&new_moov_size)) | |
598 { | |
599 mp4ff_close(ff); | |
600 return 0; | |
601 } | |
602 | |
603 /* copy moov atom to end of the file */ | |
604 if (ff->last_atom != ATOM_MOOV) | |
605 { | |
606 char *free_data = "free"; | |
607 | |
608 /* rename old moov to free */ | |
609 mp4ff_set_position(ff, ff->moov_offset + 4); | |
610 mp4ff_write_data(ff, free_data, 4); | |
611 | |
612 mp4ff_set_position(ff, ff->file_size); | |
613 mp4ff_write_int32(ff,new_moov_size + 8); | |
614 mp4ff_write_data(ff,"moov",4); | |
615 mp4ff_write_data(ff, new_moov_data, new_moov_size); | |
616 } | |
617 else | |
618 { | |
619 mp4ff_set_position(ff, ff->moov_offset); | |
620 mp4ff_write_int32(ff,new_moov_size + 8); | |
621 mp4ff_write_data(ff,"moov",4); | |
622 mp4ff_write_data(ff, new_moov_data, new_moov_size); | |
623 } | |
624 | |
625 mp4ff_truncate(ff); | |
626 | |
627 mp4ff_close(ff); | |
628 return 1; | |
629 } | |
630 #endif |