Mercurial > hg > sonic-visualiser
comparison main/IMAFencoder.c @ 1150:5e6e1e074080 3.0-plus-imaf
Merge branches 3.0-integration and imaf_enc to 3.0-plus-imaf
author | Chris Cannam |
---|---|
date | Wed, 20 Apr 2016 12:06:28 +0100 |
parents | 767789a78984 |
children |
comparison
equal
deleted
inserted
replaced
1149:3ba5bee2ace0 | 1150:5e6e1e074080 |
---|---|
1 //***********************************************************// | |
2 // Interactive Music Audio Format (IMAF) ENCODER // | |
3 // Version 2.0 // | |
4 // // | |
5 // Eugenio Oñate Hospital // | |
6 // Jesús Corral García & Costantino Taglialatela // | |
7 // // | |
8 // Copyright (c) 2013 Centre for Digital Music (C4DM) // | |
9 // Queen Mary University of London. All rights reserved. // | |
10 //***********************************************************// | |
11 // main.c // | |
12 //***********************************************************// | |
13 | |
14 //File input/output | |
15 #include <stdio.h> | |
16 //Standard library: numeric conversion, memory allocation... | |
17 #include <stdlib.h> | |
18 //Operations with strings | |
19 #include <string.h> | |
20 //Get the creation time: clock | |
21 #include <time.h> | |
22 #include "IMAFencoder.h" | |
23 //Qt libraries | |
24 #include <QTextStream> | |
25 #include <QMessageBox> | |
26 #include <QByteArray> | |
27 | |
28 | |
29 /*Prototype*/ | |
30 void filetypebx(FileTypeBox *ftyp); | |
31 int mdatbox(MediaDataBox *mdat, int, FILE *imf, FILE *song, FILE *text, int, int, u32); | |
32 void moovheaderbox(MovieBox *moov, int, int, int, int, int, int, int); | |
33 int trackstructure(MovieBox *moov, int, int, int, int,const char *name); | |
34 int samplecontainer(MovieBox *moov, int, int, const char *name); | |
35 int sampledescription(MovieBox *moov, int); | |
36 int presetcontainer(MovieBox *moov, int, int *vol_values, int type, int fade_in); | |
37 int rulescontainer(MovieBox *moov, int SelRuleType, int SelRule_PAR1, int SelRule_PAR2, | |
38 int MixRuleType, int MixRule_PAR1, int MixRule_PAR2, int MixRule_PAR3, int MixRule_PAR4); | |
39 void writemoovbox(MovieBox moov, int numtrack,int totaltracks, FILE *imf, FILE *text, bool HasTextFile); | |
40 int readTrack(MovieBox *moov, int,const char *name); | |
41 | |
42 // Timed Text Functions | |
43 int trackstructure_text (MovieBox *moov, int numtrack, int clock, int durationTrack, int sizemdat,const char *textfile,FILE *text,int totaltracks); | |
44 int samplecontainer_text(MovieBox *moov, int numtrack, int sizemdat, const char *textfiles,int totaltracks); | |
45 int aux (FILE *text,int num,int num1,int num2,int num3,int *sal); | |
46 int getTextSize (FILE *text); | |
47 // Group and Preset functions | |
48 int groupcontainer(MovieBox *moov, int *group_tracks, int grp_vol, QString grp_name, | |
49 QString grp_description, int totaltracks); | |
50 void writepresets(MovieBox moov, int numtrack,int totaltracks, FILE *imf); // NOT YET USED | |
51 | |
52 // MetaData and JPEG Image functions | |
53 int metacontainer (MetaBox *meta); | |
54 u32 getImageSize(const char *imag); | |
55 void insertImage (MetaBox *meta, FILE **imf, u32 imagesize, const char *imagedir); | |
56 void writemetabox(MetaBox meta, FILE *imf); | |
57 | |
58 int bytereverse(int num); | |
59 int bytereverse16(int num); | |
60 int size_phrase[1000];//the total number of bytes in a phrase including modifiers | |
61 int phrases;//the number of phrases in the whole text | |
62 | |
63 | |
64 // Qt Widget for the "Exit Window" | |
65 class ExitWindow : public QWidget | |
66 { | |
67 public: | |
68 ExitWindow(); | |
69 private: | |
70 QMessageBox *file_created; | |
71 }; | |
72 | |
73 ExitWindow::ExitWindow() | |
74 { | |
75 file_created = new QMessageBox(); | |
76 file_created->setFixedSize(400,200); // doesn't seem to work | |
77 file_created->setWindowTitle("IM AF Encoder"); | |
78 file_created->setText("IM AF file successfully created!"); | |
79 file_created->show(); | |
80 } | |
81 | |
82 int mainIMAFencoder (int totaltracks, QString files_path[maxtracks],QString outimaf, | |
83 QString picturefile, QString textfile, int vol_values[maxtracks], bool HasImageFile, | |
84 bool HasTextFile, int SelRuleType, int SelRule_PAR1, int SelRule_PAR2, | |
85 int MixRuleType, int MixRule_PAR1, int MixRule_PAR2, int MixRule_PAR3, int MixRule_PAR4, | |
86 int group_tracks[maxtracks], int group_volume, QString group_name, QString group_description, | |
87 int pres_type, int fade_in) | |
88 { | |
89 //Variables | |
90 FileTypeBox ftyp; | |
91 MediaDataBox mdat; | |
92 MovieBox moov; | |
93 MetaBox meta; | |
94 | |
95 //Media Data Box - Contains the audio | |
96 FILE *song; //MP3 | |
97 u32 sizeTRAK = 0; | |
98 int numtr; | |
99 //Output File | |
100 FILE *imf; //IMA | |
101 int numtrack, sizemdat, durationTrack; | |
102 //Image | |
103 u32 imagesize; | |
104 QTextStream out (stdout); | |
105 //Timed-Text | |
106 FILE *text; | |
107 int sizetext; | |
108 const char *c_str1[8];//change this value to support more than 8 audio tracks | |
109 const char *c_str2; | |
110 | |
111 //Groups, Presets, Rules and Metadata boxes sizes | |
112 u32 sizeGRCO, sizePRCO, sizeRUCO, sizeMETA; | |
113 | |
114 /* Obtain current time as seconds elapsed since the Epoch. */ | |
115 time_t clock = time(NULL); | |
116 | |
117 | |
118 //INPUT: Image | |
119 if (HasImageFile){ | |
120 c_str2= picturefile.toStdString().c_str(); //convert QString to const char | |
121 imagesize = getImageSize(c_str2);//calculate the size of the jpeg | |
122 } else { //if there is no image, the size is 0 | |
123 imagesize = 0; | |
124 } | |
125 | |
126 //INPUT: Timed-Text | |
127 if (HasTextFile){ | |
128 c_str2= textfile.toStdString().c_str(); //convert Qstring to const char | |
129 text = fopen(c_str2, "rb"); | |
130 sizetext= getTextSize (text); //calculate the size of the text | |
131 } | |
132 else{ | |
133 sizetext = 0; | |
134 } | |
135 //Create OUTPUT file (.ima) | |
136 imf = fopen (outimaf.toStdString().c_str(),"wb"); | |
137 | |
138 //Define the File Type Box | |
139 filetypebx(&ftyp); | |
140 fwrite(&ftyp, sizeof(FileTypeBox),1, imf); | |
141 //AUDIO | |
142 //Put the tracks in Media Data Box | |
143 for (numtr=0; numtr<totaltracks; numtr++) { | |
144 c_str1[numtr]= files_path[numtr].toStdString().c_str(); //convert Qstring to const char | |
145 song = fopen(c_str1[numtr], "rb"); | |
146 | |
147 //Extract the samples from the audio file and the text | |
148 sizemdat = mdatbox(&mdat, totaltracks, imf, song, text, numtr, sizetext, imagesize);//sizemdat is the size of one audio track | |
149 | |
150 fclose(song); //Close the audio file | |
151 }//close for | |
152 | |
153 //For each track write track information | |
154 durationTrack = (sizemdat*8)/128; | |
155 | |
156 for (numtrack = 0; numtrack < totaltracks; numtrack++) { | |
157 c_str1[numtrack]= files_path[numtrack].toStdString().c_str(); //convert QString to const char | |
158 sizeTRAK = trackstructure(&moov, numtrack, clock, durationTrack,sizemdat,c_str1[numtrack])+ sizeTRAK; | |
159 } | |
160 //At this point, the variable sizeTRAK will be the sum of the size of the box ´trak´ in all the audio tracks. | |
161 //The size of the box trak of the text track will be added after. | |
162 | |
163 if (HasImageFile){ | |
164 //Meta | |
165 sizeMETA = metacontainer(&meta); | |
166 | |
167 //Read the image from the JPEG file and write it in the IMAF file | |
168 c_str2= picturefile.toStdString().c_str(); //convert Qstring to const char | |
169 insertImage(&meta, &imf, imagesize,c_str2); | |
170 } | |
171 | |
172 //Groups | |
173 sizeGRCO = groupcontainer(&moov, group_tracks, group_volume, group_name, group_description, totaltracks); //Creates the group, returns the size of the box | |
174 | |
175 //Presets | |
176 sizePRCO = presetcontainer(&moov, totaltracks, vol_values, pres_type, fade_in); // Creates the preset, returns the size of the box. | |
177 | |
178 //Rules | |
179 sizeRUCO = rulescontainer(&moov, SelRuleType, SelRule_PAR1, SelRule_PAR2, | |
180 MixRuleType, MixRule_PAR1, MixRule_PAR2, MixRule_PAR3, MixRule_PAR4); // Creates the rules, returns the size of the box. | |
181 | |
182 //Text track | |
183 if (HasTextFile){ | |
184 c_str2= textfile.toStdString().c_str(); //convert Qstring to const char | |
185 sizeTRAK = trackstructure_text (&moov, numtrack, clock, durationTrack, sizemdat, c_str2, text, totaltracks) + sizeTRAK; | |
186 } | |
187 //Movie Header - Overall declarations | |
188 moovheaderbox(&moov, clock, sizeTRAK, sizePRCO, totaltracks, durationTrack, sizeRUCO, sizeGRCO); // -> enter sizeGRCO instead of 0 | |
189 | |
190 //Writes the movie box into the file | |
191 writemoovbox(moov, numtrack, totaltracks, imf, text, HasTextFile); | |
192 | |
193 //Writes the meta box into the IMAF file | |
194 if (HasImageFile){ | |
195 writemetabox(meta,imf); | |
196 } | |
197 | |
198 //Close Files and show exit dialog window | |
199 fclose(imf); | |
200 fclose (text); | |
201 ExitWindow *window = new ExitWindow(); | |
202 } | |
203 | |
204 | |
205 | |
206 void filetypebx(FileTypeBox *ftyp){ | |
207 int swap; | |
208 | |
209 swap = bytereverse(24);// 24 is the size of the box "ftyp" | |
210 ftyp->size = swap; | |
211 swap = bytereverse('ftyp'); | |
212 ftyp->type = swap; | |
213 swap = bytereverse('im02'); // Conformance point 3 (see ISO/IEC 23000-12:2010/FDAM 1:2011(E)) | |
214 ftyp->major_brand = swap; | |
215 ftyp->minor_version = 0; | |
216 swap = bytereverse('im02'); // Conformance point 3 (see ISO/IEC 23000-12:2010/FDAM 1:2011(E)) | |
217 ftyp->compatible_brands[0] = swap; | |
218 swap = bytereverse('isom'); | |
219 ftyp->compatible_brands[1] = swap; | |
220 } | |
221 | |
222 int mdatbox(MediaDataBox *mdat, int totaltracks, FILE *imf, FILE *song, FILE *text, int numtr, int sizetext, u32 imagesize){ | |
223 | |
224 int d=0, cnt=0, j, find = 0, sizestring = 0, i = 0,cnt2=0,highlight_end_time=0; | |
225 int dat = 0, dat1 = 0, dat2 = 0, dat3 = 0,k=0; | |
226 u32 size = 0, swap, sizeMDAT = 0; | |
227 unsigned char c1=0,c2=0,numwords=0,initposition[3000],endposition[3000]; | |
228 | |
229 //Positionate the pointer at the end of the file to know the size of it | |
230 fseek(song, 0, SEEK_END); | |
231 size = ftell(song); | |
232 //Positionate the pointer at first | |
233 fseek(song, 0, SEEK_SET); | |
234 | |
235 initposition[0]=0; // this array saves the position of the first letter of a word in a phrase | |
236 phrases=0;// this variable saves the number of phrases in the whole text | |
237 | |
238 //Find the header of the first frame (the beginning), when find it d=1 and jump out the loop. | |
239 // The header is 32 bytes. We find in groups of 8 bytes | |
240 // Contemplate all possible options of headers | |
241 while (d == 0) { | |
242 find = 0; | |
243 fread(&dat, sizeof(unsigned char), 1, song); | |
244 cnt++; | |
245 | |
246 if (dat == 0xFF) { | |
247 cnt++; // cnt : stores the position of the pointer. | |
248 fread(&dat1, sizeof(unsigned char), 1, song); | |
249 cnt++; | |
250 fread(&dat2, sizeof(unsigned char), 1, song); | |
251 cnt++; | |
252 fread(&dat3, sizeof(unsigned char), 1, song); | |
253 if (dat1 == 0xFB && dat2 == 146 && dat3 == 64 ) { | |
254 find = 1; // find: if the header is found | |
255 d=1; // d: jump out the loop | |
256 } | |
257 if (dat1 == 0xFB && dat2 == 146 && dat3 == 96 ) { | |
258 d=1; | |
259 find = 1; | |
260 } | |
261 if (dat1 == 0xFB && dat2 == 144 && dat3 == 64 ) { | |
262 find = 1; | |
263 d=1; | |
264 } | |
265 if (dat1 == 0xFB && dat2 == 144 && dat3 == 96 ) { | |
266 find = 1; | |
267 d=1; | |
268 } | |
269 if (dat1 == 0xFB && dat2 == 146 && dat3 == 100 ) { | |
270 d=1; | |
271 find = 1; | |
272 } | |
273 if (dat1 == 0xFB && dat2 == 144 && dat3 == 100 ) { | |
274 find = 1; | |
275 d=1; | |
276 } | |
277 if (dat1 == 0xFA && dat2 == 146 && dat3 == 64 ) { | |
278 find = 1; | |
279 d=1; | |
280 } | |
281 if (dat1 == 0xFA && dat2 == 146 && dat3 == 96 ) { | |
282 d=1; | |
283 find = 1; | |
284 } | |
285 if (dat1 == 0xFA && dat2 == 144 && dat3 == 64 ) { | |
286 find = 1; | |
287 d=1; | |
288 } | |
289 if (dat1 == 0xFA && dat2 == 144 && dat3 == 96 ) { | |
290 find = 1; | |
291 d=1; | |
292 } | |
293 if (dat1 == 0xFA && dat2 == 146 && dat3 == 100 ) { | |
294 d=1; | |
295 find = 1; | |
296 } | |
297 if (dat1 == 0xFA && dat2 == 144 && dat3 == 100 ) { | |
298 find = 1; | |
299 d=1; | |
300 } | |
301 if (find == 0) { | |
302 fseek(song, -3, SEEK_CUR); // if 3 last bytes in the header are not correct | |
303 cnt = cnt - 3; | |
304 } | |
305 } // close if | |
306 if (cnt == size) { //if we have readen all the bytes in the audio file | |
307 d = 1; | |
308 } | |
309 }//close while | |
310 size = size - (cnt - 4); // Calculate the size of the samples. size = pos. end of file - pos. first header. | |
311 if (numtr == 0) { //if it is the first audio track the code writes the mdat size | |
312 sizeMDAT = size*totaltracks + 8 + sizetext + imagesize; // size of the whole media box -> INCLUDING IMAGE and TEXT SIZE.The text size does not include modifiers | |
313 swap = bytereverse(sizeMDAT); | |
314 fwrite(&swap, sizeof(u32), 1, imf); | |
315 swap = bytereverse('mdat'); | |
316 mdat->type = swap; | |
317 fwrite(&mdat->type, sizeof(u32), 1, imf); | |
318 } | |
319 fseek(song, cnt - 4, SEEK_SET); | |
320 for (j=0; j<size; j++) { //read all the samples of one track and writes them in the IM AF file | |
321 fread(&mdat->data, sizeof(char), 1, song); | |
322 fwrite(&mdat->data, sizeof(char), 1, imf); | |
323 } | |
324 | |
325 // copy the text in the 3gp to the ima and add the text modifiers | |
326 if (sizetext !=0){ | |
327 cnt=0;// the total number of bytes of the whole text including modifiers | |
328 fseek(text,0,SEEK_CUR); | |
329 sizestring=0;//number of bytes of a phrase (without modifiers) | |
330 initposition[0]=0;// this array saves the initial position of a word | |
331 if(numtr==totaltracks-1){ // writes the text after the samples of all the audio tracks | |
332 j=0;cnt=0; | |
333 while(j<sizetext){ //this loop reads the whole text | |
334 cnt2=0;//the total number of bytes of a phrase including the modifiers | |
335 fread(&c1,sizeof(char),1,text); | |
336 fread(&c2,sizeof(char),1,text); | |
337 fwrite(&c1,sizeof(char),1,imf);//two bytes of sizestring | |
338 fwrite(&c2,sizeof(char),1,imf); | |
339 sizestring = (c1<<8) | (c2);//sizestring is the size of one phrase contained in 3gp | |
340 j=j+2; | |
341 cnt=cnt+2; | |
342 cnt2=cnt2+2; | |
343 phrases++;//the number of phrases in the whole text | |
344 numwords=0;// the number of words in a phrase | |
345 initposition[0]=0;//this array saves the first position of a word in a phrase | |
346 endposition[0]=0;// this array saves the last position of a word in a phrase | |
347 k=0;//the index for endposition array and initposition array | |
348 for(i=0;i< sizestring;i++){ | |
349 fread(&mdat->data,sizeof(char),1,text); | |
350 fwrite(&mdat->data,sizeof(char),1,imf); | |
351 j++; | |
352 cnt=cnt+1; | |
353 cnt2=cnt2+1; | |
354 if(mdat->data==0x20){ //a blank space separates two words. 0x20 = blank space | |
355 | |
356 numwords++; | |
357 endposition[k]=i; | |
358 initposition[k+1]=i+1; | |
359 k++; | |
360 } | |
361 | |
362 | |
363 } //close for | |
364 endposition[k]=sizestring-1;//saves the last position of the last word in a phrase | |
365 numwords++; | |
366 | |
367 | |
368 mdat->data=0x00; | |
369 fwrite(&mdat->data,sizeof(char),1,imf);//hclr size | |
370 fwrite(&mdat->data,sizeof(char),1,imf);//hclr size | |
371 fwrite(&mdat->data,sizeof(char),1,imf);//hclr size | |
372 mdat->data=0x0C; | |
373 fwrite(&mdat->data,sizeof(char),1,imf); //hclr size | |
374 fwrite("h",sizeof(char),1,imf); | |
375 fwrite("c",sizeof(char),1,imf); | |
376 fwrite("l",sizeof(char),1,imf); | |
377 fwrite("r",sizeof(char),1,imf); | |
378 mdat->data=0xFF; | |
379 fwrite(&mdat->data,sizeof(char),1,imf);//highlight color rgba | |
380 mdat->data=0x62; | |
381 fwrite(&mdat->data,sizeof(char),1,imf);//highlight color rgba | |
382 mdat->data=0x04; | |
383 fwrite(&mdat->data,sizeof(char),1,imf);//highlight color rgba | |
384 mdat->data=0xFF; | |
385 fwrite(&mdat->data,sizeof(char),1,imf);//highlight color rgba | |
386 mdat->data=0x00; | |
387 fwrite(&mdat->data,sizeof(char),1,imf); //krok size | |
388 mdat->data=0x00; | |
389 fwrite(&mdat->data,sizeof(char),1,imf);//krok size | |
390 mdat->data=0x00; | |
391 fwrite(&mdat->data,sizeof(char),1,imf);//krok size | |
392 mdat->data=14+(8*numwords); | |
393 fwrite(&mdat->data,sizeof(char),1,imf); //krok size | |
394 fwrite("k",sizeof(char),1,imf); | |
395 fwrite("r",sizeof(char),1,imf); | |
396 fwrite("o",sizeof(char),1,imf); | |
397 fwrite("k",sizeof(char),1,imf); | |
398 mdat->data=0x00; | |
399 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-start-time | |
400 mdat->data=0x00; | |
401 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-start-time | |
402 mdat->data=0x00; | |
403 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-start-time | |
404 mdat->data=0x00; | |
405 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-start-time | |
406 mdat->data=0x00; | |
407 fwrite(&mdat->data,sizeof(char),1,imf);//entry-count | |
408 mdat->data=numwords; | |
409 fwrite(&mdat->data,sizeof(char),1,imf);//entry-count | |
410 | |
411 for(i=0;i<numwords;i++){ | |
412 | |
413 mdat->data=0x00; | |
414 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-end-time | |
415 mdat->data=0x00; | |
416 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-end-time | |
417 | |
418 | |
419 if(i==numwords-1){ //if it is the last word in a phrase we put this value | |
420 mdat->data=0xFF; | |
421 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-end-time | |
422 mdat->data=0xFF; | |
423 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-end-time | |
424 | |
425 } | |
426 | |
427 else{ //if it is not the last word in a phrase | |
428 | |
429 highlight_end_time = (i+1)*(11/numwords);//change the value '11' in order to increase o decrease the speed of highlight | |
430 mdat->data= highlight_end_time; | |
431 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-end-time | |
432 mdat->data=0xFF; | |
433 fwrite(&mdat->data,sizeof(char),1,imf);//highlight-end-time | |
434 | |
435 | |
436 } | |
437 | |
438 mdat->data=0x00; | |
439 fwrite(&mdat->data,sizeof(char),1,imf);//startcharoffset | |
440 mdat->data=initposition[i]; | |
441 fwrite(&mdat->data,sizeof(char),1,imf);//startcharoffset | |
442 mdat->data=0x00; | |
443 fwrite(&mdat->data,sizeof(char),1,imf);//endcharoffset | |
444 mdat->data=endposition[i]+1; | |
445 fwrite(&mdat->data,sizeof(char),1,imf);//endcharoffset | |
446 | |
447 }//close for | |
448 | |
449 cnt=cnt+26+(numwords*8);//cnt is the number of bytes of the whole text including modifiers | |
450 cnt2=cnt2+26+(numwords*8); //cnt2 is the number of bytes of a phrase including the modifiers | |
451 | |
452 size_phrase[phrases-1]=cnt2 ; | |
453 | |
454 } //close while | |
455 | |
456 sizeMDAT = size*totaltracks + 8 + cnt + imagesize; // size value must include image and text sizes | |
457 swap = bytereverse(sizeMDAT); | |
458 fseek(imf,-(sizeMDAT-imagesize),SEEK_CUR); //overwrittes sizeMDAT with the total size (Image is yet to be written in the file at this point) | |
459 fwrite(&swap, sizeof(u32), 1, imf); | |
460 fseek(imf,(sizeMDAT-imagesize)-4,SEEK_CUR); // (Image is yet to be written in the file at this point) | |
461 } // close if (numtr==totaltracks-1) | |
462 }//close if sizetext | |
463 fclose(song); | |
464 | |
465 return size; | |
466 } | |
467 | |
468 int samplecontainer(MovieBox *moov, int numtrack, int sizemdat, const char *name){ | |
469 | |
470 u32 sizeSTSD, sizeSTSZ, swap, num_samples, dat=0; | |
471 u32 sizetime, sizeSTTS; //Time to Sample Box | |
472 u32 sizeSTSC = 28; //Sample to Chunck | |
473 u32 sizeSTCO = 20; //Chunck offset | |
474 u32 sizeSTBL; //Sample Table Box // | |
475 | |
476 //Sample Description Box// | |
477 sizeSTSD = sampledescription(moov, numtrack); | |
478 | |
479 //Sample size box// | |
480 swap = bytereverse('stsz'); | |
481 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
482 SampleSizeBox.type = swap; | |
483 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
484 SampleSizeBox.version = 0; | |
485 //Read Track: Frame size and Decoder Times | |
486 num_samples = readTrack(moov, numtrack, name); | |
487 sizeSTSZ = num_samples*4 + 20; | |
488 swap = bytereverse(sizeSTSZ); | |
489 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
490 SampleSizeBox.size = swap; | |
491 | |
492 //Time To Sample Box// | |
493 sizetime = bytereverse(moov->TrackBox[numtrack].MediaBox.MediaInformationBox. | |
494 SampleTableBox.TimeToSampleBox.entry_count); | |
495 sizeSTTS = 16 + sizetime*4*2; | |
496 swap = bytereverse(sizeSTTS); | |
497 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
498 TimeToSampleBox.size = swap; | |
499 swap = bytereverse('stts'); | |
500 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
501 TimeToSampleBox.type = swap; | |
502 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
503 TimeToSampleBox.version = 0; | |
504 | |
505 //Sample To Chunk// | |
506 swap = bytereverse(sizeSTSC); | |
507 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
508 SampleToChunk.size = swap; | |
509 swap = bytereverse('stsc'); | |
510 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
511 SampleToChunk.type = swap; | |
512 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
513 SampleToChunk.version = 0; | |
514 swap = bytereverse(1); | |
515 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
516 SampleToChunk.entry_count = swap; | |
517 swap = bytereverse(1); | |
518 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
519 SampleToChunk.first_chunk = swap; | |
520 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
521 SampleToChunk.samples_per_chunk = moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleSizeBox.sample_count; | |
522 swap = bytereverse(1); | |
523 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
524 SampleToChunk.sample_description_index = swap; | |
525 | |
526 //Chunk Offset Box// | |
527 swap = bytereverse(sizeSTCO); | |
528 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
529 ChunkOffsetBox.size = swap; | |
530 swap = bytereverse('stco'); | |
531 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
532 ChunkOffsetBox.type = swap; | |
533 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
534 ChunkOffsetBox.version = 0; | |
535 swap = bytereverse(1); | |
536 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
537 ChunkOffsetBox.entry_count = swap; | |
538 dat = 32 + sizemdat*numtrack; | |
539 swap = bytereverse(dat); | |
540 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
541 ChunkOffsetBox.chunk_offset[numtrack] = swap; | |
542 | |
543 //Sample Table Box // | |
544 sizeSTBL = 8 + sizeSTSD + sizeSTSZ + sizeSTSC + sizeSTCO + sizeSTTS; | |
545 swap = bytereverse(sizeSTBL); | |
546 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.size = swap; | |
547 swap = bytereverse('stbl'); | |
548 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.type =swap; | |
549 | |
550 return sizeSTBL; | |
551 } | |
552 | |
553 int sampledescription(MovieBox *moov, int numtrack){ | |
554 | |
555 u32 swap, sizeESD = 35; | |
556 | |
557 u32 sizeMP4a; //Audio Sample Entry// | |
558 u32 sizeSTSD; //Sample description box // | |
559 | |
560 | |
561 swap = bytereverse(sizeESD); | |
562 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
563 SampleDescriptionBox.AudioSampleEntry.ESbox.size = swap; | |
564 swap = bytereverse('esds'); | |
565 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
566 SampleDescriptionBox.AudioSampleEntry.ESbox.type = swap; | |
567 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
568 SampleDescriptionBox.AudioSampleEntry.ESbox.version = 0; | |
569 | |
570 //ES Descriptor// | |
571 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
572 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.tag = 3; | |
573 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
574 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.length = 21; | |
575 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
576 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.ES_ID = 0; | |
577 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
578 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.mix = 0; | |
579 | |
580 //Decoder config descriptor// | |
581 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
582 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor. | |
583 DecoderConfigDescriptor.tag = 4; | |
584 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
585 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor. | |
586 DecoderConfigDescriptor.length = 13; | |
587 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
588 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor. | |
589 DecoderConfigDescriptor.objectProfileInd = 0x6B; | |
590 swap = bytereverse(0x150036B0); | |
591 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
592 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor. | |
593 DecoderConfigDescriptor.mix = swap; | |
594 swap = bytereverse(128); | |
595 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
596 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor. | |
597 DecoderConfigDescriptor.maxBitRate = swap; | |
598 swap = bytereverse(128); | |
599 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
600 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor. | |
601 DecoderConfigDescriptor.avgBitrate = swap; | |
602 | |
603 //SLConfig Descriptor// | |
604 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
605 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor. | |
606 SLConfigDescriptor.tag = 6; | |
607 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
608 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor. | |
609 SLConfigDescriptor.length = 1; | |
610 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
611 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor. | |
612 SLConfigDescriptor.predifined = 2; | |
613 | |
614 //Audio Sample Entry// | |
615 sizeMP4a = 36 + sizeESD; | |
616 swap = bytereverse(sizeMP4a); | |
617 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
618 SampleDescriptionBox.AudioSampleEntry.size = swap; | |
619 swap = bytereverse('mp4a'); | |
620 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
621 SampleDescriptionBox.AudioSampleEntry.type =swap; | |
622 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
623 SampleDescriptionBox.AudioSampleEntry.reserved[0] = 0; | |
624 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
625 SampleDescriptionBox.AudioSampleEntry.reserved[1] = 0; | |
626 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
627 SampleDescriptionBox.AudioSampleEntry.reserved[2] = 0; | |
628 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
629 SampleDescriptionBox.AudioSampleEntry.reserved[3] = 0; | |
630 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
631 SampleDescriptionBox.AudioSampleEntry.reserved[4] = 0; | |
632 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
633 SampleDescriptionBox.AudioSampleEntry.reserved[5] = 0; | |
634 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
635 SampleDescriptionBox.AudioSampleEntry.data_reference_index = bytereverse16(1); | |
636 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
637 SampleDescriptionBox.AudioSampleEntry.reserved2[0] = 0; | |
638 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
639 SampleDescriptionBox.AudioSampleEntry.reserved2[1] = 0; | |
640 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
641 SampleDescriptionBox.AudioSampleEntry.channelcount = 512; | |
642 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
643 SampleDescriptionBox.AudioSampleEntry.samplesize = 4096; // 16 bits | |
644 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
645 SampleDescriptionBox.AudioSampleEntry.reserved3 = 0; | |
646 swap = 44100 << 16; | |
647 swap = bytereverse(swap); | |
648 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
649 SampleDescriptionBox.AudioSampleEntry.samplerate = swap; | |
650 | |
651 //Sample description box // | |
652 sizeSTSD = 16 + sizeMP4a; | |
653 swap = bytereverse(sizeSTSD); | |
654 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
655 SampleDescriptionBox.size = swap; | |
656 swap = bytereverse('stsd'); | |
657 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
658 SampleDescriptionBox.type = swap; | |
659 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
660 SampleDescriptionBox.version = 0; | |
661 swap = bytereverse(1); | |
662 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
663 SampleDescriptionBox.entry_count = swap; | |
664 | |
665 return sizeSTSD; | |
666 } | |
667 | |
668 int readTrack (MovieBox *moov, int numtrack,const char *name){ | |
669 | |
670 int t=0,k=1, l =0; | |
671 | |
672 FILE *song; | |
673 int d=0, cnt = 0, i=0, j=0, cnt2 = 0, find = 0, swap, num_entr = 0; | |
674 int dat = 0, dat1 = 0, dat2 = 0, dat3 = 0, num_frame = 0, end =0, pos = 0; | |
675 u32 size[9000]; | |
676 | |
677 //Open the audio file with the name introduced by the user | |
678 song = fopen (name,"rb"); | |
679 if (song == NULL) { | |
680 printf("Error opening input file\n"); | |
681 system("pause"); | |
682 exit(1); | |
683 } | |
684 //Calculate the size of the track | |
685 fseek(song, 0, SEEK_END); | |
686 end = ftell(song); | |
687 fseek(song, 0, SEEK_SET); | |
688 d=0, i=0; | |
689 //Search for each frame one by one, and extratcs the information | |
690 while (d == 0) { | |
691 find = 0; | |
692 fread(&dat, sizeof(unsigned char), 1, song); | |
693 cnt++; | |
694 | |
695 if (dat == 0xFF) { | |
696 cnt++; | |
697 fread(&dat1, sizeof(unsigned char), 1, song); | |
698 cnt++; | |
699 fread(&dat2, sizeof(unsigned char), 1, song); | |
700 cnt++; | |
701 fread(&dat3, sizeof(unsigned char), 1, song); | |
702 if (dat1 == 0xFB && dat2 == 146 && dat3 == 64 ) { | |
703 pos = cnt - 4; //Pos of the beginning of the frame | |
704 size[num_frame] = pos - cnt2; //Size of one frame | |
705 cnt2 = pos; //Pos of the next frame | |
706 find = 1; | |
707 num_frame ++; //Number of frames | |
708 } | |
709 if (dat1 == 0xFB && dat2 == 146 && dat3 == 96 ) { | |
710 pos = cnt - 4; | |
711 size[num_frame] = pos - cnt2; | |
712 cnt2 = pos; | |
713 find = 1; | |
714 num_frame ++; | |
715 } | |
716 if (dat1 == 0xFB && dat2 == 144 && dat3 == 64 ) { | |
717 pos = cnt - 4; | |
718 size[num_frame] = pos - cnt2; | |
719 cnt2 = pos; | |
720 find = 1; | |
721 num_frame ++; | |
722 } | |
723 if (dat1 == 0xFB && dat2 == 144 && dat3 == 96 ) { | |
724 pos = cnt - 4; | |
725 size[num_frame] = pos - cnt2; | |
726 cnt2 = pos; | |
727 find = 1; | |
728 num_frame ++; | |
729 } | |
730 if (dat1 == 0xFB && dat2 == 146 && dat3 == 100 ) { | |
731 pos = cnt - 4; | |
732 size[num_frame] = pos - cnt2; | |
733 cnt2 = pos; | |
734 find = 1; | |
735 num_frame ++; | |
736 } | |
737 if (dat1 == 0xFB && dat2 == 144 && dat3 == 100 ) { | |
738 pos = cnt - 4; | |
739 size[num_frame] = pos - cnt2; | |
740 cnt2 = pos; | |
741 find = 1; | |
742 num_frame ++; | |
743 } | |
744 if (dat1 == 0xFA && dat2 == 146 && dat3 == 64 ) { | |
745 pos = cnt - 4; | |
746 size[num_frame] = pos - cnt2; | |
747 cnt2 = pos; | |
748 find = 1; | |
749 num_frame ++; | |
750 } | |
751 if (dat1 == 0xFA && dat2 == 146 && dat3 == 96 ) { | |
752 pos = cnt - 4; | |
753 size[num_frame] = pos - cnt2; | |
754 cnt2 = pos; | |
755 find = 1; | |
756 num_frame ++; | |
757 } | |
758 if (dat1 == 0xFA && dat2 == 144 && dat3 == 64 ) { | |
759 pos = cnt - 4; | |
760 size[num_frame] = pos - cnt2; | |
761 cnt2 = pos; | |
762 find = 1; | |
763 num_frame ++; | |
764 } | |
765 if (dat1 == 0xFA && dat2 == 144 && dat3 == 96 ) { | |
766 pos = cnt - 4; | |
767 size[num_frame] = pos - cnt2; | |
768 cnt2 = pos; | |
769 find = 1; | |
770 num_frame ++; | |
771 } | |
772 if (dat1 == 0xFA && dat2 == 146 && dat3 == 100 ) { | |
773 pos = cnt - 4; | |
774 size[num_frame] = pos - cnt2; | |
775 cnt2 = pos; | |
776 find = 1; | |
777 num_frame ++; | |
778 } | |
779 if (dat1 == 0xFA && dat2 == 144 && dat3 == 100 ) { | |
780 pos = cnt - 4; | |
781 size[num_frame] = pos - cnt2; | |
782 cnt2 = pos; | |
783 find = 1; | |
784 num_frame ++; | |
785 } | |
786 if (find == 0) { //In case it does not find the header. | |
787 //It keeps reading next data without jump any position | |
788 fseek(song, -3, SEEK_CUR); | |
789 cnt = cnt - 3; | |
790 } | |
791 } | |
792 | |
793 if (cnt == end) { | |
794 pos = cnt; | |
795 size[num_frame] = pos - cnt2; | |
796 d = 1; | |
797 } | |
798 } | |
799 | |
800 //Save Samples size// | |
801 swap = bytereverse(num_frame); | |
802 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
803 SampleSizeBox.sample_count = swap; | |
804 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
805 SampleSizeBox.sample_size = 0; | |
806 | |
807 for (i=0; i< num_frame; i++) { | |
808 swap = bytereverse(size[i+1]); | |
809 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
810 SampleSizeBox.entry_size[i] = swap; | |
811 } | |
812 | |
813 //Save Decoding Times// | |
814 //Writes manually the duration of each frame. | |
815 //Follows the following structure: | |
816 // 7 frames of 26 ms | |
817 // 1 frame of 27 ms | |
818 // ... | |
819 // And each 13 rows it writes | |
820 // 8 frames of 26 ms | |
821 // 1 frame of 27 ms | |
822 //It is done for adjusting the different durations of each frame. | |
823 // as they vary between 26.125 ms and 26.075 ms | |
824 | |
825 swap = bytereverse(1); | |
826 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
827 TimeToSampleBox.sample_count[0] = swap; | |
828 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
829 TimeToSampleBox.sample_delta[0] =0; | |
830 // int t=0,k=1, l =0; | |
831 num_entr = 1; | |
832 j = 0; | |
833 for (i = 1; i< num_frame; i++) { | |
834 if (j == 8 && l == 0) { | |
835 swap = bytereverse(7); | |
836 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
837 TimeToSampleBox.sample_count[num_entr] = swap; | |
838 swap = bytereverse(26); | |
839 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
840 TimeToSampleBox.sample_delta[num_entr] =swap; | |
841 num_entr ++; | |
842 | |
843 swap = bytereverse(1); | |
844 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
845 TimeToSampleBox.sample_count[num_entr] = swap; | |
846 swap = bytereverse(27); | |
847 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
848 TimeToSampleBox.sample_delta[num_entr] =swap; | |
849 num_entr++; | |
850 j=0; | |
851 dat = i; | |
852 if (k == 6 && t == 0) { | |
853 l = 1; | |
854 t = 1; | |
855 k = 1; | |
856 } | |
857 if (k == 6 && t ==1) { | |
858 l = 1; | |
859 k = 1; | |
860 } | |
861 k++; | |
862 } | |
863 | |
864 if (j == 9 && l == 1) { | |
865 | |
866 swap = bytereverse(8); | |
867 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
868 TimeToSampleBox.sample_count[num_entr] = swap; | |
869 swap = bytereverse(26); | |
870 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
871 TimeToSampleBox.sample_delta[num_entr] =swap; | |
872 num_entr ++; | |
873 | |
874 swap = bytereverse(1); | |
875 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
876 TimeToSampleBox.sample_count[num_entr] = swap; | |
877 swap = bytereverse(27); | |
878 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
879 TimeToSampleBox.sample_delta[num_entr] =swap; | |
880 num_entr++; | |
881 j=0; | |
882 dat = i; | |
883 l = 0; | |
884 } | |
885 j++; | |
886 } | |
887 | |
888 dat = num_frame - dat; | |
889 | |
890 swap = bytereverse(dat); | |
891 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
892 TimeToSampleBox.sample_count[num_entr] = swap; | |
893 swap = bytereverse(26); | |
894 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
895 TimeToSampleBox.sample_delta[num_entr] =swap; | |
896 num_entr++; | |
897 swap = bytereverse(num_entr); | |
898 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
899 TimeToSampleBox.entry_count = swap; | |
900 | |
901 fclose(song); | |
902 return num_frame; | |
903 | |
904 } | |
905 | |
906 int trackstructure (MovieBox *moov, int numtrack, int clock, | |
907 int durationTrack, int sizemdat,const char *name){ | |
908 int swap; | |
909 | |
910 int sizeSTBL; //Sample Table Box | |
911 u32 sizeURL; //Data Entry Url Box | |
912 u32 sizeDREF; //Data Reference | |
913 u32 sizeSMHD; //Sound Header Box | |
914 u32 sizeDINF; //Data information Box | |
915 u32 sizeMINF; //Media Information Box// | |
916 u32 sizeHDLR; //Handler Box// | |
917 u32 sizeMDHD; //Media Header Box// | |
918 u32 sizeMDIA; //Media Box// | |
919 u32 sizeTKHD; //Track Header// | |
920 u32 sizeTRAK; //Track container | |
921 | |
922 //Sample Table Box | |
923 sizeSTBL = 0; | |
924 sizeSTBL = samplecontainer(moov, numtrack,sizemdat, name); | |
925 | |
926 //Data Entry Url Box | |
927 sizeURL = 12; | |
928 swap = bytereverse(sizeURL); | |
929 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
930 DataReferenceBox.DataEntryUrlBox.size = swap; | |
931 swap = bytereverse('url '); | |
932 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
933 DataReferenceBox.DataEntryUrlBox.type = swap; | |
934 swap = bytereverse(1); | |
935 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
936 DataReferenceBox.DataEntryUrlBox.flags = swap; // =1 Track in same file as movie atom. | |
937 | |
938 //Data Reference | |
939 sizeDREF = sizeURL+ 16; | |
940 swap = bytereverse(sizeDREF); | |
941 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
942 DataReferenceBox.size = swap; | |
943 swap = bytereverse('dref'); | |
944 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
945 DataReferenceBox.type = swap; | |
946 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
947 DataReferenceBox.flags = 0; | |
948 swap = bytereverse(1); | |
949 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
950 DataReferenceBox.entry_count = swap; | |
951 | |
952 //Data information Box// | |
953 sizeDINF = sizeDREF + 8; | |
954 swap = bytereverse(sizeDINF); | |
955 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.size = swap; | |
956 swap = bytereverse('dinf'); | |
957 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.type = swap; | |
958 | |
959 //Sound Header Box // | |
960 sizeSMHD = 16; | |
961 swap = bytereverse(sizeSMHD); | |
962 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.size = swap; | |
963 swap = bytereverse('smhd'); | |
964 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.type = swap; | |
965 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.version = 0; | |
966 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.balance = 0; | |
967 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.reserved = 0; | |
968 | |
969 //Media Information Box// | |
970 sizeMINF = sizeDINF + sizeSMHD + sizeSTBL + 8; | |
971 swap = bytereverse(sizeMINF); | |
972 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.size = swap; | |
973 swap = bytereverse('minf'); | |
974 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.type = swap; | |
975 | |
976 //Handler Box// | |
977 sizeHDLR = 37; | |
978 swap = bytereverse(sizeHDLR); | |
979 moov->TrackBox[numtrack].MediaBox.HandlerBox.size = swap; | |
980 swap = bytereverse('hdlr'); | |
981 moov->TrackBox[numtrack].MediaBox.HandlerBox.type = swap; | |
982 moov->TrackBox[numtrack].MediaBox.HandlerBox.version = 0; | |
983 moov->TrackBox[numtrack].MediaBox.HandlerBox.pre_defined = 0; | |
984 swap = bytereverse('soun'); | |
985 moov->TrackBox[numtrack].MediaBox.HandlerBox.handler_type = swap; | |
986 moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[0] = 0; | |
987 moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[1] = 0; | |
988 moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[2] = 0; | |
989 //swap = bytereverse('soun'); | |
990 //moov->TrackBox[numtrack].MediaBox.HandlerBox.data = swap; | |
991 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[0] = 's'; | |
992 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[1] = 'o'; | |
993 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[2] = 'u'; | |
994 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[3] = 'n'; | |
995 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[4] = '\0'; | |
996 | |
997 //Media Header Box// | |
998 sizeMDHD = 32; | |
999 swap = bytereverse(sizeMDHD); | |
1000 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.size = swap; | |
1001 swap = bytereverse('mdhd'); | |
1002 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.type = swap; | |
1003 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.version = 0; | |
1004 swap = bytereverse(clock); | |
1005 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.creation_time = swap; | |
1006 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.modification_time = swap; | |
1007 swap = bytereverse(1000); | |
1008 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.timescale = swap; | |
1009 swap = bytereverse(durationTrack); | |
1010 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.duration = swap; | |
1011 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.language = 0xC455; | |
1012 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.pre_defined = 0; | |
1013 | |
1014 //Media Box// | |
1015 sizeMDIA = sizeMDHD + sizeHDLR + sizeMINF + 8; | |
1016 swap = bytereverse(sizeMDIA); | |
1017 moov->TrackBox[numtrack].MediaBox.size = swap; | |
1018 swap = bytereverse('mdia'); | |
1019 moov->TrackBox[numtrack].MediaBox.type = swap; | |
1020 | |
1021 //Track Header// | |
1022 sizeTKHD = 92; | |
1023 swap = bytereverse (sizeTKHD); | |
1024 moov->TrackBox[numtrack].TrackHeaderBox.size = swap; | |
1025 swap = bytereverse ('tkhd'); | |
1026 moov->TrackBox[numtrack].TrackHeaderBox.type = swap ; | |
1027 swap = bytereverse (0x00000006); | |
1028 moov->TrackBox[numtrack].TrackHeaderBox.version = swap; | |
1029 swap = bytereverse (clock); | |
1030 moov->TrackBox[numtrack].TrackHeaderBox.creation_time = swap; | |
1031 moov->TrackBox[numtrack].TrackHeaderBox.modification_time = swap; | |
1032 swap = bytereverse (numtrack+1); | |
1033 moov->TrackBox[numtrack].TrackHeaderBox.track_ID = swap; //From 0x00000001 - 0x7FFFFFFF (dec 2147483647) | |
1034 moov->TrackBox[numtrack].TrackHeaderBox.reserved = 0; | |
1035 swap = bytereverse (durationTrack); | |
1036 moov->TrackBox[numtrack].TrackHeaderBox.duration = swap; | |
1037 moov->TrackBox[numtrack].TrackHeaderBox.reserved2[0] = 0; | |
1038 moov->TrackBox[numtrack].TrackHeaderBox.reserved2[1] = 0; | |
1039 moov->TrackBox[numtrack].TrackHeaderBox.layer = 0; | |
1040 moov->TrackBox[numtrack].TrackHeaderBox.alternate_group = 0; | |
1041 moov->TrackBox[numtrack].TrackHeaderBox.volume = 0x1; | |
1042 moov->TrackBox[numtrack].TrackHeaderBox.reserved3 = 0; | |
1043 swap = bytereverse (0x00010000); | |
1044 moov->TrackBox[numtrack].TrackHeaderBox.matrix[0] = swap; | |
1045 moov->TrackBox[numtrack].TrackHeaderBox.matrix[1] = 0; | |
1046 moov->TrackBox[numtrack].TrackHeaderBox.matrix[2] = 0; | |
1047 moov->TrackBox[numtrack].TrackHeaderBox.matrix[3] = 0; | |
1048 moov->TrackBox[numtrack].TrackHeaderBox.matrix[4] = swap; | |
1049 moov->TrackBox[numtrack].TrackHeaderBox.matrix[5] = 0; | |
1050 moov->TrackBox[numtrack].TrackHeaderBox.matrix[6] = 0; | |
1051 moov->TrackBox[numtrack].TrackHeaderBox.matrix[7] = 0; | |
1052 swap = bytereverse(0x40000000); | |
1053 moov->TrackBox[numtrack].TrackHeaderBox.matrix[8] = swap; | |
1054 moov->TrackBox[numtrack].TrackHeaderBox.width = 0; //just for video | |
1055 moov->TrackBox[numtrack].TrackHeaderBox.height = 0; //just for video | |
1056 | |
1057 //Track container | |
1058 sizeTRAK = sizeTKHD + sizeMDIA + 8; | |
1059 swap = bytereverse (sizeTRAK); // Size of one track | |
1060 moov->TrackBox[numtrack].size = swap; | |
1061 swap = bytereverse ('trak'); | |
1062 moov->TrackBox[numtrack].type = swap; | |
1063 return sizeTRAK; | |
1064 | |
1065 } | |
1066 | |
1067 int groupcontainer(MovieBox *moov, int *group_tracks, int grp_vol, QString grp_name, | |
1068 QString grp_description, int totaltracks) { | |
1069 | |
1070 int i, j, k, numgroups, sizeCont; | |
1071 int numel = 0; | |
1072 int sizeBox = 0; | |
1073 int tempsize = 0; | |
1074 int active, activenum, addsize; | |
1075 | |
1076 // ADDED FOR SV | |
1077 for (j=0; j<totaltracks; j++){ | |
1078 if (group_tracks[j]==1){ | |
1079 numel++; | |
1080 } | |
1081 } | |
1082 | |
1083 if (numel==0){ | |
1084 numgroups = 0; | |
1085 }else{ | |
1086 numgroups = 1; | |
1087 } | |
1088 // | |
1089 | |
1090 moov->GroupContainerBox.num_groups = bytereverse16(numgroups); | |
1091 | |
1092 for (i=0; i<numgroups; i++){ | |
1093 addsize = 0; | |
1094 tempsize = 0; | |
1095 moov->GroupContainerBox.GroupBox[i].group_ID = bytereverse(2147483649+i+1); // group_ID shall be represented from 0x80000000 to 0xFFFFFFFF | |
1096 strcpy(moov->GroupContainerBox.GroupBox[i].group_name, grp_name.toStdString().c_str()); | |
1097 strcpy(moov->GroupContainerBox.GroupBox[i].group_description, grp_description.toStdString().c_str()); | |
1098 | |
1099 // numel = 0; // uncomment for more than one group and remove initial "for" with numel | |
1100 k = 0; | |
1101 for (j=0; j<totaltracks; j++){ | |
1102 if (group_tracks[j]==1){ | |
1103 moov->GroupContainerBox.GroupBox[i].groupElemId[k].element_ID = bytereverse(j+1); | |
1104 // numel++; // uncomment for more than one group and remove initial "for" with numel | |
1105 addsize += 4; | |
1106 k++; | |
1107 } | |
1108 } | |
1109 moov->GroupContainerBox.GroupBox[i].num_elements = bytereverse16(numel); | |
1110 | |
1111 // printf("Choose the activation mode: "); | |
1112 // printf("Activation mode\n"); | |
1113 // printf(" - Switch on the MINIMUN number of elements (0, if no Min/Max rule) [0]\n"); | |
1114 // printf(" - Switch on the MAXIMUM number of elements (All tracks, if no Min/Max rule) [1]\n"); | |
1115 // printf(" - Switch on the defined number of elements (ONLY IF there is Min/Max rule) [2]\n"); | |
1116 // scanf("%d",&active); | |
1117 // fflush(stdin); | |
1118 | |
1119 active = 1; // ADDED FOR SV, All tracks enabled | |
1120 | |
1121 moov->GroupContainerBox.GroupBox[i].group_activation_mode = active; | |
1122 activenum = 0; | |
1123 moov->GroupContainerBox.GroupBox[i].group_activation_elements_number = activenum; | |
1124 if (active==2){ | |
1125 printf("Activation elements number: "); | |
1126 scanf("%d",&activenum); | |
1127 moov->GroupContainerBox.GroupBox[i].group_activation_elements_number = bytereverse16(activenum); | |
1128 addsize += 2; | |
1129 } | |
1130 | |
1131 moov->GroupContainerBox.GroupBox[i].group_reference_volume = bytereverse16(grp_vol*256/100); // define 8.8 fixed point | |
1132 | |
1133 tempsize = 75 + addsize; // ---> before was 66 + addsize; | |
1134 moov->GroupContainerBox.GroupBox[i].size = bytereverse(tempsize); | |
1135 moov->GroupContainerBox.GroupBox[i].type = bytereverse('grup'); | |
1136 moov->GroupContainerBox.GroupBox[i].version = bytereverse(0x02); // flags = Display enable, Edit disable | |
1137 | |
1138 sizeBox += tempsize; | |
1139 | |
1140 } // close for (numgroups) | |
1141 | |
1142 sizeCont = sizeBox + 10; | |
1143 | |
1144 moov->GroupContainerBox.size = bytereverse(sizeCont); | |
1145 moov->GroupContainerBox.type = bytereverse('grco'); | |
1146 | |
1147 return sizeCont; | |
1148 } | |
1149 | |
1150 int presetcontainer(MovieBox *moov, int totaltracks, int *vol_values, int prestype, int fade_in){ | |
1151 | |
1152 int temp, i, j, k, m, t, vol; | |
1153 int numpres, eq; | |
1154 //char name[50]; | |
1155 u32 sizePRST = 0; | |
1156 u32 sizePRCO = 0; | |
1157 u32 sizeEQ; | |
1158 u32 addsize = 0; | |
1159 int updates = 0; | |
1160 | |
1161 numpres = 1; // ADDED FOR SV | |
1162 | |
1163 //Preset Box// | |
1164 for (i=0; i<numpres; i++) { | |
1165 // printf("\nPRESET LIST:\n"); | |
1166 // printf(" - Static track volume [0]\n"); | |
1167 // printf(" - Static object volume [1]\n"); | |
1168 // printf(" - Dynamic track volume [2]\n"); | |
1169 // printf(" - Dynamic object volume [3]\n"); | |
1170 // printf(" - Dynamic track approximated volume [4]\n"); | |
1171 // printf(" - Dynamic object approximated volume [5]\n"); | |
1172 // printf(" - Static track volume with Equalization [6]\n"); // count preset_type from 8 | |
1173 // printf(" - Static object volume with Equalization [7]\n"); | |
1174 // printf(" - Dynamic track volume with Equalization [8]\n"); | |
1175 // printf(" - Dynamic object volume with Equalization [9]\n"); | |
1176 // printf(" - Dynamic track approximated with Equalization [10]\n"); | |
1177 // printf(" - Dynamic object approximated with Equalization [11]\n"); | |
1178 // printf("\nPlease make your choice: "); | |
1179 // scanf("%d", &prestype); | |
1180 // fflush(stdin); | |
1181 | |
1182 //PresetBOX | |
1183 // Box size specified in respective case | |
1184 moov->PresetContainerBox.PresetBox[i].type = bytereverse('prst'); | |
1185 moov->PresetContainerBox.PresetBox[i].flags = bytereverse(0x02); // Display Enable Edit Disable | |
1186 moov->PresetContainerBox.PresetBox[i].preset_ID = i+1; | |
1187 moov->PresetContainerBox.PresetBox[i].num_preset_elements = totaltracks; // All the tracks are involved in the preset | |
1188 for (j=0; j<totaltracks; j++) { | |
1189 moov->PresetContainerBox.PresetBox[i].presElemId[j].preset_element_ID = bytereverse(j+1); | |
1190 } | |
1191 moov->PresetContainerBox.PresetBox[i].preset_global_volume = 100; | |
1192 | |
1193 // prestype = 0; // ADDED FOR SV | |
1194 | |
1195 switch (prestype) { | |
1196 case 0: moov->PresetContainerBox.PresetBox[i].preset_type = 0; | |
1197 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Static track volume preset"); | |
1198 | |
1199 for (j=0; j<totaltracks; j++) { | |
1200 vol = vol_values[j]*2; | |
1201 moov->PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].preset_volume_element = vol/2; //*0.02 | |
1202 } | |
1203 | |
1204 addsize = totaltracks; | |
1205 break; | |
1206 case 1: moov->PresetContainerBox.PresetBox[i].preset_type = 1; | |
1207 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Static object volume preset"); | |
1208 | |
1209 for (j=0; j<totaltracks; j++) { | |
1210 moov->PresetContainerBox.PresetBox[i].StaticObjectVolume.InputCH[j].num_input_channel = num_ch; | |
1211 } | |
1212 moov->PresetContainerBox.PresetBox[i].StaticObjectVolume.output_channel_type = 1; // STEREO (2 output channels) | |
1213 for (j=0; j<totaltracks; j++){ | |
1214 for (k=0; k<num_ch; k++){ | |
1215 for (m=0; m<num_ch; m++){ | |
1216 moov->PresetContainerBox.PresetBox[i].StaticObjectVolume.presElVol[j]. | |
1217 Input[k].Output[m].preset_volume_element = (100-(20*m))/2; // INPUT BY USER | |
1218 } | |
1219 } | |
1220 } | |
1221 | |
1222 addsize = totaltracks + 1+ totaltracks*num_ch*num_ch; | |
1223 break; | |
1224 case 2: moov->PresetContainerBox.PresetBox[i].preset_type = 2; | |
1225 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Dynamic track volume preset"); | |
1226 | |
1227 updates = 2; // volume changes | |
1228 moov->PresetContainerBox.PresetBox[i].DynamicTrackVolume.num_updates = bytereverse16(updates); | |
1229 for (j=0; j<updates; j++){ // INPUT BY USER | |
1230 moov->PresetContainerBox.PresetBox[i].DynamicTrackVolume. | |
1231 DynamicChange[j].updated_sample_number = bytereverse16(100+(j*100)); // *0.026 = time in seconds | |
1232 for (k=0; k<totaltracks; k++){ | |
1233 moov->PresetContainerBox.PresetBox[i].DynamicTrackVolume. | |
1234 DynamicChange[j].presVolumElem[k].preset_volume_element = (50*j)/2; // INPUT BY USER | |
1235 } | |
1236 } | |
1237 | |
1238 addsize = 2 + updates*(2 + totaltracks); | |
1239 break; | |
1240 case 3: moov->PresetContainerBox.PresetBox[i].preset_type = 3; | |
1241 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Dynamic object volume preset"); | |
1242 | |
1243 updates = 2; // volume changes | |
1244 moov->PresetContainerBox.PresetBox[i].DynamicObjectVolume.num_updates = bytereverse16(updates); // INPUT BY USER (maybe...) | |
1245 for (j=0; j<totaltracks; j++) { | |
1246 moov->PresetContainerBox.PresetBox[i].DynamicObjectVolume.InputCH[j].num_input_channel = 2; | |
1247 } | |
1248 moov->PresetContainerBox.PresetBox[i].DynamicObjectVolume.output_channel_type = 1; // STEREO (2 output channels) | |
1249 for (j=0; j<updates; j++){ // INPUT BY USER | |
1250 moov->PresetContainerBox.PresetBox[i].DynamicObjectVolume. | |
1251 DynamicChange[j].updated_sample_number = bytereverse16(0+(j*500)); // *0.026 = time in seconds | |
1252 for (k=0; k<totaltracks; k++){ | |
1253 for (m=0; m<num_ch; m++){ | |
1254 for (t=0; t<num_ch; t++){ | |
1255 moov->PresetContainerBox.PresetBox[i].DynamicObjectVolume.DynamicChange[j]. | |
1256 presElVol[k].Input[m].Output[t].preset_volume_element = (25*(j+1)); // INPUT BY USER | |
1257 } | |
1258 } | |
1259 } | |
1260 } | |
1261 | |
1262 addsize = 2 + totaltracks + 1 + updates*(2 + totaltracks*num_ch*num_ch); | |
1263 break; | |
1264 case 4: moov->PresetContainerBox.PresetBox[i].preset_type = 4; | |
1265 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Dynamic track approximated volume"); | |
1266 | |
1267 updates = 2; // volume changes | |
1268 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.num_updates = bytereverse16(updates); | |
1269 for (j=0; j<updates; j++){ | |
1270 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1271 DynamicChange[j].start_sample_number = bytereverse16(100); // *0.026 = time in seconds - INPUT BY USER | |
1272 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1273 DynamicChange[j].duration_update = bytereverse16(500); // *0.026 = time in seconds -INPUT BY USER | |
1274 for (k=0; k<totaltracks; k++){ | |
1275 if (fade_in){ | |
1276 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[j]. | |
1277 presElVol[k].end_preset_volume_element = (50*j); // Fade IN | |
1278 } else { | |
1279 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[j]. | |
1280 presElVol[k].end_preset_volume_element = (100-(100*j))/2; // Fade OUT | |
1281 } | |
1282 } | |
1283 } | |
1284 | |
1285 /* // some code for test | |
1286 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[2].start_sample_number = bytereverse16(1100); | |
1287 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[2].duration_update = bytereverse16(250); | |
1288 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[2].presElVol[0].end_preset_volume_element = 50; | |
1289 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[2].presElVol[1].end_preset_volume_element = 50; | |
1290 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[3].start_sample_number = bytereverse16(1100); | |
1291 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[3].duration_update = bytereverse16(250); | |
1292 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[3].presElVol[0].end_preset_volume_element = 1; | |
1293 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[3].presElVol[1].end_preset_volume_element = 1; | |
1294 */ | |
1295 | |
1296 addsize = 2 + updates*(2 + 2 + totaltracks); | |
1297 break; | |
1298 case 5: moov->PresetContainerBox.PresetBox[i].preset_type = 5; // NOT YET IMPLEMENTED INTO THE PLAYER! | |
1299 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Dynamic object approximated volume"); | |
1300 | |
1301 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1302 | |
1303 updates = 2; // volume changes | |
1304 moov->PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume.num_updates = bytereverse16(updates); | |
1305 for (j=0; j<totaltracks; j++) { | |
1306 moov->PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume.InputCH[j].num_input_channel = 2; | |
1307 } | |
1308 moov->PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume.output_channel_type = 1; // STEREO (2 output channels) | |
1309 for (j=0; j<updates; j++){ | |
1310 moov->PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume. | |
1311 DynamicChange[j].start_sample_number = bytereverse16(100); // *0.026 = time in seconds - INPUT BY USER | |
1312 moov->PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume. | |
1313 DynamicChange[j].duration_update = bytereverse16(250); // *0.026 = time in seconds - INPUT BY USER | |
1314 for (k=0; k<totaltracks; k++){ | |
1315 for (m=0; m<num_ch; m++){ | |
1316 for (t=0; t<num_ch; t++){ | |
1317 moov->PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume.DynamicChange[j]. | |
1318 presElVol[k].Input[m].Output[t].preset_volume_element = (100*j)/2; // INPUT BY USER | |
1319 } | |
1320 } | |
1321 } | |
1322 } | |
1323 | |
1324 addsize = 2 + totaltracks + 1 + updates*( 2 + 2 + totaltracks*num_ch*num_ch); | |
1325 break; | |
1326 case 6: moov->PresetContainerBox.PresetBox[i].preset_type = 8; | |
1327 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Static track volume with Equalization"); | |
1328 | |
1329 eq = 0; addsize = 0; | |
1330 for (j=0; j<totaltracks; j++) { | |
1331 //printf("Enter volume for %s : ",namet[j].title); | |
1332 scanf("%d",&vol); | |
1333 fflush(stdin); | |
1334 moov->PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].preset_volume_element = vol/2; //*0.02 | |
1335 | |
1336 // Equalization | |
1337 printf("EQ Filter on this element? [1] Yes - [0] No : "); | |
1338 scanf("%d",&eq); | |
1339 fflush(stdin); | |
1340 | |
1341 if (eq == 1){ | |
1342 moov->PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.num_eq_filters = 1; | |
1343 for (k=0; k<moov->PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.num_eq_filters; k++){ | |
1344 moov->PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.Filter[k].filter_type = 4; // HPF | |
1345 moov->PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.Filter[k]. | |
1346 filter_reference_frequency = bytereverse16(5000); // 10kHz | |
1347 moov->PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.Filter[k].filter_gain = -10; | |
1348 moov->PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.Filter[k].filter_bandwidth = 4; | |
1349 addsize += 5; | |
1350 } //close for | |
1351 }else{ | |
1352 moov->PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.num_eq_filters = 0; | |
1353 } //close if/else | |
1354 } //close for | |
1355 | |
1356 addsize += totaltracks + totaltracks; //add preset_volume and num_eq_filters size | |
1357 break; | |
1358 case 7: moov->PresetContainerBox.PresetBox[i].preset_type = 9; // NOT YET IMPLEMENTED INTO THE PLAYER! | |
1359 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Static object volume with Equalization"); | |
1360 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1361 break; | |
1362 case 8: moov->PresetContainerBox.PresetBox[i].preset_type = 10; // NOT YET IMPLEMENTED INTO THE PLAYER! | |
1363 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Dynamic track volume with Equalization"); | |
1364 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1365 break; | |
1366 case 9: moov->PresetContainerBox.PresetBox[i].preset_type = 11; // NOT YET IMPLEMENTED INTO THE PLAYER! | |
1367 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Dynamic object volume with Equalization"); | |
1368 break; | |
1369 case 10: moov->PresetContainerBox.PresetBox[i].preset_type = 12; // NOT YET IMPLEMENTED INTO THE PLAYER! | |
1370 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Dynamic track approximated with Equalization"); | |
1371 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1372 | |
1373 eq = 0; addsize = 0; | |
1374 updates = 2; // volume changes | |
1375 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.num_updates = bytereverse16(updates); | |
1376 for (j=0; j<updates; j++){ | |
1377 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1378 DynamicChange[j].start_sample_number = bytereverse16(100); // *0.026 = time in seconds - INPUT BY USER | |
1379 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1380 DynamicChange[j].duration_update = bytereverse16(500); // *0.026 = time in seconds -INPUT BY USER | |
1381 for (k=0; k<totaltracks; k++){ | |
1382 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[j]. | |
1383 presElVol[k].end_preset_volume_element = (50*j); // Fade IN, change in (100-(100*j))/2 for Fade OUT -INPUT BY USER | |
1384 | |
1385 // Equalization | |
1386 //printf("EQ Filter on %s ? [1] Yes - [0] No : ",namet[k].title); | |
1387 scanf("%d",&eq); | |
1388 fflush(stdin); | |
1389 | |
1390 if (eq == 1){ | |
1391 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1392 DynamicChange[j].presElVol[k].EQ.num_eq_filters = 1; | |
1393 for (t=0; t<moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1394 DynamicChange[j].presElVol[k].EQ.num_eq_filters; t++){ | |
1395 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1396 DynamicChange[j].presElVol[k].EQ.Filter[t].filter_type = 4; // HPF | |
1397 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1398 DynamicChange[j].presElVol[k].EQ.Filter[t].filter_reference_frequency = bytereverse16(5000); // 10kHz | |
1399 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1400 DynamicChange[j].presElVol[k].EQ.Filter[t].end_filter_gain = -10; | |
1401 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1402 DynamicChange[j].presElVol[k].EQ.Filter[t].filter_bandwidth = 4; | |
1403 addsize += 5; | |
1404 } //close for | |
1405 }else{ | |
1406 moov->PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1407 DynamicChange[j].presElVol[k].EQ.num_eq_filters = 0; | |
1408 } //close if/else | |
1409 } //close for (k) | |
1410 } //close for (j) | |
1411 | |
1412 addsize += 2 + updates*(2 + 2 + totaltracks*(1+1)); | |
1413 break; | |
1414 case 11: moov->PresetContainerBox.PresetBox[i].preset_type = 13; // NOT YET IMPLEMENTED INTO THE PLAYER! | |
1415 strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, "Dynamic object approximated with Equalization"); | |
1416 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1417 break; | |
1418 default: printf("ERROR in PRESET CONTAINER"); | |
1419 system("pause"); | |
1420 exit(1); | |
1421 break; | |
1422 | |
1423 } //close switch | |
1424 | |
1425 temp = 16 + 50 + 4*totaltracks + addsize; // size PresetBox[i] | |
1426 moov->PresetContainerBox.PresetBox[i].size = bytereverse(temp); | |
1427 | |
1428 sizePRST += temp; // size of all Preset Boxes | |
1429 | |
1430 } //close for | |
1431 | |
1432 //Preset Container// | |
1433 sizePRCO += sizePRST + 10; | |
1434 moov->PresetContainerBox.size = bytereverse(sizePRCO); | |
1435 moov->PresetContainerBox.type = bytereverse('prco'); | |
1436 moov->PresetContainerBox.default_preset_ID = 1; // Indicates initial preset activated. | |
1437 moov->PresetContainerBox.num_preset = numpres; | |
1438 | |
1439 return sizePRCO; | |
1440 | |
1441 } //close function | |
1442 | |
1443 int rulescontainer(MovieBox *moov, int SelRuleType, int SelRule_PAR1, int SelRule_PAR2, | |
1444 int MixRuleType, int MixRule_PAR1, int MixRule_PAR2, | |
1445 int MixRule_PAR3, int MixRule_PAR4) { | |
1446 | |
1447 int swap; | |
1448 u32 add_size = 0; //for SelectionRulesBox | |
1449 u32 sizeRUSC, sizeRUCO, sizeRUMX; | |
1450 | |
1451 | |
1452 //Selection Rules | |
1453 moov->RulesContainer.num_selection_rules = bytereverse16(1); | |
1454 moov->RulesContainer.SelectionRules.selection_rule_ID = bytereverse16(1); | |
1455 | |
1456 switch (SelRuleType) { | |
1457 | |
1458 case 0: moov->RulesContainer.SelectionRules.selection_rule_type = 0; | |
1459 moov->RulesContainer.SelectionRules.element_ID = bytereverse(2147483649+1); // Must be the same ID of the group | |
1460 moov->RulesContainer.SelectionRules.min_num_elements = bytereverse16(SelRule_PAR1); | |
1461 moov->RulesContainer.SelectionRules.max_num_elements = bytereverse16(SelRule_PAR2); | |
1462 strcpy(moov->RulesContainer.SelectionRules.rule_description,"Min/Max Rule"); | |
1463 add_size = 4; | |
1464 break; | |
1465 case 1: moov->RulesContainer.SelectionRules.selection_rule_type = 1; | |
1466 moov->RulesContainer.SelectionRules.element_ID = bytereverse(SelRule_PAR1); | |
1467 moov->RulesContainer.SelectionRules.key_element_ID =bytereverse(SelRule_PAR2); | |
1468 strcpy(moov->RulesContainer.SelectionRules.rule_description,"Exclusion Rule"); | |
1469 add_size = 4; | |
1470 break; | |
1471 case 2: moov->RulesContainer.SelectionRules.selection_rule_type = 2; | |
1472 moov->RulesContainer.SelectionRules.element_ID = bytereverse(SelRule_PAR1); | |
1473 strcpy(moov->RulesContainer.SelectionRules.rule_description,"Not mute Rule"); | |
1474 add_size = 0; | |
1475 break; | |
1476 case 3: moov->RulesContainer.SelectionRules.selection_rule_type = 3; | |
1477 moov->RulesContainer.SelectionRules.element_ID = bytereverse(SelRule_PAR1); | |
1478 moov->RulesContainer.SelectionRules.key_element_ID =bytereverse(SelRule_PAR2); | |
1479 strcpy(moov->RulesContainer.SelectionRules.rule_description,"Implication Rule"); | |
1480 add_size = 4; | |
1481 break; | |
1482 default: printf("ERROR in RULES CONTAINER/Selection Rules"); | |
1483 system("pause"); | |
1484 break; | |
1485 } | |
1486 | |
1487 sizeRUSC = 19 + 20 + add_size; | |
1488 moov->RulesContainer.SelectionRules.size = bytereverse(sizeRUSC); | |
1489 moov->RulesContainer.SelectionRules.type = bytereverse('rusc'); | |
1490 moov->RulesContainer.SelectionRules.version = 0; | |
1491 | |
1492 //Mixing Rule | |
1493 moov->RulesContainer.num_mixing_rules = bytereverse16(1); | |
1494 moov->RulesContainer.MixingRules.mixing_rule_ID = bytereverse16(1); | |
1495 | |
1496 switch (MixRuleType) { | |
1497 | |
1498 case 0: moov->RulesContainer.MixingRules.mixing_type = 0; | |
1499 moov->RulesContainer.MixingRules.element_ID = bytereverse(MixRule_PAR1); | |
1500 moov->RulesContainer.MixingRules.key_elem_ID = bytereverse(MixRule_PAR2); | |
1501 strcpy(moov->RulesContainer.MixingRules.mix_description, "Equivalence rule"); | |
1502 break; | |
1503 case 1: moov->RulesContainer.MixingRules.mixing_type = 1; | |
1504 moov->RulesContainer.MixingRules.element_ID = bytereverse(MixRule_PAR2); | |
1505 moov->RulesContainer.MixingRules.key_elem_ID = bytereverse(MixRule_PAR1); | |
1506 strcpy(moov->RulesContainer.MixingRules.mix_description, "Upper rule"); | |
1507 break; | |
1508 case 2: moov->RulesContainer.MixingRules.mixing_type = 2; | |
1509 moov->RulesContainer.MixingRules.element_ID = bytereverse(MixRule_PAR2); | |
1510 moov->RulesContainer.MixingRules.key_elem_ID = bytereverse(MixRule_PAR1); | |
1511 strcpy(moov->RulesContainer.MixingRules.mix_description, "Lower rule"); | |
1512 break; | |
1513 case 3: moov->RulesContainer.MixingRules.mixing_type = 3; | |
1514 moov->RulesContainer.MixingRules.element_ID = bytereverse(MixRule_PAR1); | |
1515 moov->RulesContainer.MixingRules.min_volume = bytereverse16(1 + MixRule_PAR3*2.5); // 8.8 fixed point | |
1516 moov->RulesContainer.MixingRules.max_volume = bytereverse16(1 + MixRule_PAR4*2.5); // 8.8 fixed point | |
1517 strcpy(moov->RulesContainer.MixingRules.mix_description, "Limit rule"); | |
1518 break; | |
1519 default: printf("ERROR in RULES CONTAINER/Mixing Rules"); | |
1520 system("pause"); | |
1521 exit(1); | |
1522 break; | |
1523 } | |
1524 | |
1525 sizeRUMX = 23 + 17; | |
1526 moov->RulesContainer.MixingRules.size = bytereverse(sizeRUMX); | |
1527 moov->RulesContainer.MixingRules.type = bytereverse('rumx'); | |
1528 moov->RulesContainer.MixingRules.version = 0; | |
1529 | |
1530 //Rule container | |
1531 sizeRUCO = 12 + sizeRUSC + sizeRUMX; | |
1532 swap = bytereverse(sizeRUCO); | |
1533 moov->RulesContainer.size = swap; | |
1534 swap = bytereverse('ruco'); | |
1535 moov->RulesContainer.type = swap; | |
1536 | |
1537 return sizeRUCO; | |
1538 | |
1539 } // close function | |
1540 | |
1541 void moovheaderbox (MovieBox *moov, int clock, int sizeTRAK, int sizePRCO, int totaltracks, | |
1542 int durationTrack, int sizeRUCO, int sizeGRCO) { | |
1543 int swap; | |
1544 u32 sizeMOOV; //MovieBox | |
1545 | |
1546 //MovieHeader | |
1547 u32 sizeMVHD = 108; | |
1548 swap = bytereverse (sizeMVHD); | |
1549 moov->MovieHeaderBox.size = swap; | |
1550 swap = bytereverse ('mvhd'); | |
1551 moov->MovieHeaderBox.type = swap; | |
1552 moov->MovieHeaderBox.version = 0; | |
1553 swap = bytereverse (clock); | |
1554 moov->MovieHeaderBox.creation_time = swap; | |
1555 moov->MovieHeaderBox.modification_time = swap; | |
1556 swap = bytereverse (1000); | |
1557 moov->MovieHeaderBox.timescale = swap; | |
1558 swap = bytereverse (durationTrack); | |
1559 moov->MovieHeaderBox.duration = swap; | |
1560 swap = bytereverse (0x00010000); | |
1561 moov->MovieHeaderBox.rate = swap; | |
1562 swap = bytereverse (1); | |
1563 moov->MovieHeaderBox.volume = 1; | |
1564 moov->MovieHeaderBox.reserved=0; | |
1565 moov->MovieHeaderBox.reserved2[0] = 0; | |
1566 moov->MovieHeaderBox.reserved2[1] = 0; | |
1567 swap = bytereverse (0x00010000); | |
1568 moov->MovieHeaderBox.matrix[0] = swap; | |
1569 moov->MovieHeaderBox.matrix[1] = 0; | |
1570 moov->MovieHeaderBox.matrix[2] = 0; | |
1571 moov->MovieHeaderBox.matrix[3] = 0; | |
1572 moov->MovieHeaderBox.matrix[4] = swap; | |
1573 moov->MovieHeaderBox.matrix[5] = 0; | |
1574 moov->MovieHeaderBox.matrix[6] = 0; | |
1575 moov->MovieHeaderBox.matrix[7] = 0; | |
1576 swap = bytereverse (0x40000000); | |
1577 moov->MovieHeaderBox.matrix[8] = 0x40000000; | |
1578 moov->MovieHeaderBox.pre_defined[0] = 0; | |
1579 moov->MovieHeaderBox.pre_defined[1] = 0; | |
1580 moov->MovieHeaderBox.pre_defined[2] = 0; | |
1581 moov->MovieHeaderBox.pre_defined[3] = 0; | |
1582 moov->MovieHeaderBox.pre_defined[4] = 0; | |
1583 moov->MovieHeaderBox.pre_defined[5] = 0; | |
1584 swap = bytereverse (totaltracks + 1); | |
1585 moov->MovieHeaderBox.next_track_ID = swap; | |
1586 | |
1587 //MovieBox | |
1588 sizeMOOV = sizeMVHD + sizeTRAK + sizePRCO + sizeRUCO + sizeGRCO + 8; | |
1589 swap = bytereverse (sizeMOOV); //Size movie: Taking into account number tracks | |
1590 moov->size = swap; | |
1591 swap = bytereverse ('moov'); | |
1592 moov->type = swap; | |
1593 } | |
1594 | |
1595 | |
1596 void writemoovbox(MovieBox moov, int numtrack,int totaltracks, FILE *imf, FILE *text, bool HasTextFile) | |
1597 { | |
1598 int i, j, k, m, t, swap, pos, temp, type; | |
1599 int cnt = 0, cnt2 = 0, d = 0, dat = 0, dat1 = 0, dat2 = 0, dat3 = 0, size = 0; | |
1600 u16 numgroups, numel; | |
1601 | |
1602 | |
1603 //Write movie box// | |
1604 fwrite(&moov.size, sizeof(u32), 1, imf); | |
1605 fwrite(&moov.type, sizeof(u32), 1, imf); | |
1606 //Movie header// | |
1607 fwrite(&moov.MovieHeaderBox, sizeof(moov.MovieHeaderBox), 1, imf); | |
1608 //Track container// | |
1609 for (numtrack = 0; numtrack < totaltracks; numtrack++) { | |
1610 fwrite(&moov.TrackBox[numtrack].size, sizeof(u32), 1, imf); | |
1611 fwrite(&moov.TrackBox[numtrack].type, sizeof(u32), 1, imf); | |
1612 //Trck header// | |
1613 fwrite(&moov.TrackBox[numtrack].TrackHeaderBox, sizeof(moov.TrackBox[numtrack].TrackHeaderBox), 1, imf); | |
1614 //Media Box// | |
1615 fwrite(&moov.TrackBox[numtrack].MediaBox.size, sizeof(u32), 1, imf); | |
1616 fwrite(&moov.TrackBox[numtrack].MediaBox.type, sizeof(u32), 1, imf); | |
1617 //Media Header// | |
1618 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaHeaderBox, | |
1619 sizeof(moov.TrackBox[numtrack].MediaBox.MediaHeaderBox), 1, imf); | |
1620 //Handler Box// | |
1621 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.size, sizeof(u32), 1, imf); | |
1622 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.type, sizeof(u32), 1, imf); | |
1623 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.version, sizeof(u32), 1, imf); | |
1624 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.pre_defined, sizeof(u32), 1, imf); | |
1625 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.handler_type, sizeof(u32), 1, imf); | |
1626 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.reserved[0], sizeof(u32), 1, imf); | |
1627 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.reserved[1], sizeof(u32), 1, imf); | |
1628 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.reserved[2], sizeof(u32), 1, imf); | |
1629 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[0], sizeof(unsigned char), 1, imf); | |
1630 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[1], sizeof(unsigned char), 1, imf); | |
1631 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[2], sizeof(unsigned char), 1, imf); | |
1632 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[3], sizeof(unsigned char), 1, imf); | |
1633 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[4], sizeof(unsigned char), 1, imf); | |
1634 //Media inforamtion box// | |
1635 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.size, sizeof(u32), 1, imf); | |
1636 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.type, sizeof(u32), 1, imf); | |
1637 //Sound media header// | |
1638 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox, | |
1639 sizeof(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox), 1, imf); | |
1640 //Data reference// | |
1641 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox, | |
1642 sizeof(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox), 1, imf); | |
1643 //Sample table box// | |
1644 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.size, sizeof(u32), 1, imf); | |
1645 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.type, sizeof(u32), 1, imf); | |
1646 | |
1647 //Time to sample box// | |
1648 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1649 TimeToSampleBox.size, sizeof(u32), 1, imf); | |
1650 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1651 TimeToSampleBox.type, sizeof(u32), 1, imf); | |
1652 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1653 TimeToSampleBox.version, sizeof(u32), 1, imf); | |
1654 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1655 TimeToSampleBox.entry_count, sizeof(u32), 1, imf); | |
1656 | |
1657 swap = bytereverse(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1658 TimeToSampleBox.entry_count); | |
1659 pos = swap; | |
1660 | |
1661 for (i=0; i<pos; i++) { | |
1662 | |
1663 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1664 TimeToSampleBox.sample_count[i], sizeof(u32), 1, imf); | |
1665 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1666 TimeToSampleBox.sample_delta[i], sizeof(u32), 1, imf); | |
1667 } | |
1668 | |
1669 //Sample description box// | |
1670 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1671 SampleDescriptionBox.size, sizeof(u32), 1, imf); | |
1672 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1673 SampleDescriptionBox.type, sizeof(u32), 1, imf); | |
1674 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1675 SampleDescriptionBox.version, sizeof(u32), 1, imf); | |
1676 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1677 SampleDescriptionBox.entry_count, sizeof(u32), 1, imf); | |
1678 //Audio Sample entry// | |
1679 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1680 SampleDescriptionBox.AudioSampleEntry.size, sizeof(u32), 1, imf); | |
1681 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1682 SampleDescriptionBox.AudioSampleEntry.type, sizeof(u32), 1, imf); | |
1683 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1684 SampleDescriptionBox.AudioSampleEntry.reserved[0], sizeof(unsigned char), 6, imf); | |
1685 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1686 SampleDescriptionBox.AudioSampleEntry.data_reference_index, sizeof(u16), 1, imf); | |
1687 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1688 SampleDescriptionBox.AudioSampleEntry.reserved2[0], sizeof(u32), 2, imf); | |
1689 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1690 SampleDescriptionBox.AudioSampleEntry.channelcount, sizeof(u16), 1, imf); | |
1691 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1692 SampleDescriptionBox.AudioSampleEntry.samplesize, sizeof(u16), 1, imf); | |
1693 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1694 SampleDescriptionBox.AudioSampleEntry.reserved3, sizeof(u32), 1, imf); | |
1695 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1696 SampleDescriptionBox.AudioSampleEntry.samplerate, sizeof(u32), 1, imf); | |
1697 //ESDBox// | |
1698 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1699 SampleDescriptionBox.AudioSampleEntry.ESbox.size, sizeof(u32), 1, imf); | |
1700 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1701 SampleDescriptionBox.AudioSampleEntry.ESbox.type, sizeof(u32), 1, imf); | |
1702 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1703 SampleDescriptionBox.AudioSampleEntry.ESbox.version, sizeof(u32), 1, imf); | |
1704 //ES Descriptor// | |
1705 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1706 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.tag | |
1707 , sizeof(unsigned char), 1, imf); | |
1708 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1709 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.length | |
1710 , sizeof(unsigned char), 1, imf); | |
1711 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1712 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.ES_ID | |
1713 , sizeof(u16), 1, imf); | |
1714 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1715 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.mix | |
1716 , sizeof(unsigned char), 1, imf); | |
1717 //Decoder Config// | |
1718 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1719 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1720 tag, sizeof(unsigned char), 1, imf); | |
1721 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1722 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1723 length, sizeof(unsigned char), 1, imf); | |
1724 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1725 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1726 objectProfileInd, sizeof(unsigned char), 1, imf); | |
1727 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1728 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1729 mix, sizeof(u32), 1, imf); | |
1730 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1731 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1732 maxBitRate, sizeof(u32), 1, imf); | |
1733 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1734 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1735 avgBitrate, sizeof(u32), 1, imf); | |
1736 /* //DecoderSpecificInfo// | |
1737 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1738 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1739 DecoderSpecificInfo.tag, sizeof(unsigned char), 1, imf); | |
1740 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1741 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1742 DecoderSpecificInfo.length, sizeof(unsigned char), 1, imf); | |
1743 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1744 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1745 DecoderSpecificInfo.decSpecificInfoData[0], sizeof(unsigned char), 1, imf); | |
1746 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1747 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor. | |
1748 DecoderSpecificInfo.decSpecificInfoData[1], sizeof(unsigned char), 1, imf); | |
1749 */ //SLConfig// | |
1750 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1751 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.SLConfigDescriptor. | |
1752 tag, sizeof(unsigned char), 1, imf); | |
1753 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1754 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.SLConfigDescriptor. | |
1755 length, sizeof(unsigned char), 1, imf); | |
1756 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1757 SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.SLConfigDescriptor. | |
1758 predifined, sizeof(unsigned char), 1, imf); | |
1759 | |
1760 | |
1761 //Sample Size box// | |
1762 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1763 SampleSizeBox.size, sizeof(u32), 1, imf); | |
1764 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1765 SampleSizeBox.type, sizeof(u32), 1, imf); | |
1766 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1767 SampleSizeBox.version, sizeof(u32), 1, imf); | |
1768 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1769 SampleSizeBox.sample_size, sizeof(u32), 1, imf); | |
1770 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1771 SampleSizeBox.sample_count, sizeof(u32), 1, imf); | |
1772 swap = bytereverse(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1773 SampleSizeBox.sample_count); | |
1774 for(i=0; i<swap; i++){ | |
1775 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1776 SampleSizeBox.entry_size[i], sizeof(u32), 1, imf); | |
1777 } | |
1778 | |
1779 //Sample to chunk box// | |
1780 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1781 SampleToChunk.size, sizeof(u32), 1, imf); | |
1782 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1783 SampleToChunk.type, sizeof(u32), 1, imf); | |
1784 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1785 SampleToChunk.version, sizeof(u32), 1, imf); | |
1786 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1787 SampleToChunk.entry_count, sizeof(u32), 1, imf); | |
1788 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1789 SampleToChunk.first_chunk, sizeof(u32), 1, imf); | |
1790 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1791 SampleToChunk.samples_per_chunk, sizeof(u32), 1, imf); | |
1792 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1793 SampleToChunk.sample_description_index, sizeof(u32), 1, imf); | |
1794 | |
1795 //Chunk offset// | |
1796 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1797 ChunkOffsetBox.size, sizeof(u32), 1, imf); | |
1798 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1799 ChunkOffsetBox.type, sizeof(u32), 1, imf); | |
1800 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1801 ChunkOffsetBox.version, sizeof(u32), 1, imf); | |
1802 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1803 ChunkOffsetBox.entry_count, sizeof(u32), 1, imf); | |
1804 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
1805 ChunkOffsetBox.chunk_offset[numtrack], sizeof(u32), 1, imf); | |
1806 } | |
1807 | |
1808 //Group Container | |
1809 fwrite(&moov.GroupContainerBox.size, sizeof(u32), 1, imf); | |
1810 fwrite(&moov.GroupContainerBox.type, sizeof(u32), 1, imf); | |
1811 fwrite(&moov.GroupContainerBox.num_groups, sizeof(u16), 1, imf); | |
1812 //Group Box | |
1813 numgroups = bytereverse16(moov.GroupContainerBox.num_groups); | |
1814 for(i=0; i<numgroups; i++){ | |
1815 fwrite(&moov.GroupContainerBox.GroupBox[i].size, sizeof(u32), 1, imf); | |
1816 fwrite(&moov.GroupContainerBox.GroupBox[i].type, sizeof(u32), 1, imf); | |
1817 fwrite(&moov.GroupContainerBox.GroupBox[i].version, sizeof(u32), 1, imf); | |
1818 fwrite(&moov.GroupContainerBox.GroupBox[i].group_ID, sizeof(u32), 1, imf); | |
1819 fwrite(&moov.GroupContainerBox.GroupBox[i].num_elements, sizeof(u16), 1, imf); | |
1820 numel = bytereverse16(moov.GroupContainerBox.GroupBox[i].num_elements); | |
1821 for(j=0; j<numel; j++){ | |
1822 fwrite(&moov.GroupContainerBox.GroupBox[i].groupElemId[j].element_ID, sizeof(u32), 1, imf); | |
1823 } | |
1824 fwrite(&moov.GroupContainerBox.GroupBox[i].group_activation_mode, sizeof(unsigned char), 1, imf); | |
1825 if(moov.GroupContainerBox.GroupBox[i].group_activation_mode==2){ | |
1826 fwrite(&moov.GroupContainerBox.GroupBox[i].group_activation_elements_number, sizeof(u16), 1, imf); | |
1827 } | |
1828 fwrite(&moov.GroupContainerBox.GroupBox[i].group_reference_volume, sizeof(u16), 1, imf); | |
1829 for (j=0; j<22; j++) { | |
1830 fwrite(&moov.GroupContainerBox.GroupBox[i].group_name[j], sizeof(char), 1, imf); | |
1831 } | |
1832 for (j=0; j<32; j++) { | |
1833 fwrite(&moov.GroupContainerBox.GroupBox[i].group_description[j], sizeof(char), 1, imf); | |
1834 } | |
1835 | |
1836 } | |
1837 | |
1838 //PresetContainerBox | |
1839 fwrite(&moov.PresetContainerBox.size, sizeof(u32), 1, imf); | |
1840 fwrite(&moov.PresetContainerBox.type, sizeof(u32), 1, imf); | |
1841 fwrite(&moov.PresetContainerBox.num_preset, sizeof(unsigned char), 1, imf); | |
1842 fwrite(&moov.PresetContainerBox.default_preset_ID, sizeof(unsigned char), 1, imf); | |
1843 | |
1844 //Preset Box | |
1845 for (i=0; i<moov.PresetContainerBox.num_preset; i++) { | |
1846 fwrite(&moov.PresetContainerBox.PresetBox[i].size, sizeof(u32), 1, imf); | |
1847 fwrite(&moov.PresetContainerBox.PresetBox[i].type, sizeof(u32), 1, imf); | |
1848 fwrite(&moov.PresetContainerBox.PresetBox[i].flags, sizeof(u32), 1, imf); | |
1849 fwrite(&moov.PresetContainerBox.PresetBox[i].preset_ID, sizeof(unsigned char), 1, imf); | |
1850 fwrite(&moov.PresetContainerBox.PresetBox[i].num_preset_elements, sizeof(unsigned char), 1, imf); | |
1851 for (j=0; j< moov.PresetContainerBox.PresetBox[i].num_preset_elements; j++) { | |
1852 fwrite(&moov.PresetContainerBox.PresetBox[i].presElemId[j]. | |
1853 preset_element_ID, sizeof(u32), 1, imf); | |
1854 } | |
1855 fwrite(&moov.PresetContainerBox.PresetBox[i].preset_type , sizeof(unsigned char), 1, imf); | |
1856 fwrite(&moov.PresetContainerBox.PresetBox[i].preset_global_volume, sizeof(unsigned char), 1, imf); | |
1857 | |
1858 type = moov.PresetContainerBox.PresetBox[i].preset_type; | |
1859 | |
1860 switch(type){ | |
1861 | |
1862 case 0: for (j=0; j< moov.PresetContainerBox.PresetBox[i].num_preset_elements; j++) { | |
1863 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j]. | |
1864 preset_volume_element,sizeof(unsigned char), 1, imf); | |
1865 } | |
1866 break; | |
1867 case 1: for (j=0; j<num_ch; j++){ | |
1868 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticObjectVolume.InputCH[j]. | |
1869 num_input_channel,sizeof(unsigned char), 1, imf); | |
1870 } | |
1871 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticObjectVolume.output_channel_type, sizeof(unsigned char), 1, imf); | |
1872 for (j=0; j<totaltracks; j++){ | |
1873 for (k=0; k<num_ch; k++){ | |
1874 for (m=0; m<num_ch; m++){ | |
1875 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticObjectVolume.presElVol[j]. | |
1876 Input[k].Output[m].preset_volume_element, sizeof(unsigned char), 1, imf); | |
1877 } | |
1878 } | |
1879 } | |
1880 break; | |
1881 case 2: fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackVolume.num_updates, sizeof(u16), 1, imf); | |
1882 temp = bytereverse16(moov.PresetContainerBox.PresetBox[i].DynamicTrackVolume.num_updates); | |
1883 for (j=0; j<temp; j++){ | |
1884 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackVolume. | |
1885 DynamicChange[j].updated_sample_number, sizeof(u16), 1, imf); | |
1886 for (k=0; k<totaltracks; k++){ | |
1887 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackVolume.DynamicChange[j]. | |
1888 presVolumElem[k].preset_volume_element, sizeof(unsigned char), 1, imf); | |
1889 } | |
1890 } | |
1891 break; | |
1892 case 3: fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectVolume.num_updates, sizeof(u16), 1, imf); | |
1893 for (j=0; j<totaltracks; j++) { | |
1894 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectVolume.InputCH[j].num_input_channel, sizeof(u8), 1, imf); | |
1895 } | |
1896 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectVolume.output_channel_type, sizeof(u8), 1, imf); | |
1897 temp = bytereverse16(moov.PresetContainerBox.PresetBox[i].DynamicObjectVolume.num_updates); | |
1898 for (j=0; j<temp; j++){ | |
1899 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectVolume. | |
1900 DynamicChange[j].updated_sample_number, sizeof(u16), 1, imf); | |
1901 for (k=0; k<totaltracks; k++){ | |
1902 for (m=0; m<num_ch; m++){ | |
1903 for (t=0; t<num_ch; t++){ | |
1904 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectVolume.DynamicChange[j]. | |
1905 presElVol[k].Input[m].Output[t].preset_volume_element, sizeof(u8), 1, imf); | |
1906 } | |
1907 } | |
1908 } | |
1909 } | |
1910 break; | |
1911 case 4: fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.num_updates, sizeof(u16), 1, imf); | |
1912 temp = bytereverse16(moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.num_updates); | |
1913 for (j=0; j<temp; j++){ | |
1914 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1915 DynamicChange[j].start_sample_number, sizeof(u16), 1, imf); | |
1916 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1917 DynamicChange[j].duration_update, sizeof(u16), 1, imf); | |
1918 for (k=0; k<totaltracks; k++){ | |
1919 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[j]. | |
1920 presElVol[k].end_preset_volume_element, sizeof(unsigned char), 1, imf); | |
1921 } | |
1922 } | |
1923 break; | |
1924 case 5: // NOT YET IMPLEMENTED INTO THE PLAYER! | |
1925 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1926 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume.num_updates, sizeof(u16), 1, imf); | |
1927 for (j=0; j<totaltracks; j++) { | |
1928 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume.InputCH[j].num_input_channel, sizeof(u8), 1, imf); | |
1929 } | |
1930 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume.output_channel_type, sizeof(u8), 1, imf); | |
1931 temp = bytereverse16(moov.PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume.num_updates); | |
1932 for (j=0; j<temp; j++){ | |
1933 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume. | |
1934 DynamicChange[j].start_sample_number, sizeof(u16), 1, imf); | |
1935 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume. | |
1936 DynamicChange[j].duration_update, sizeof(u16), 1, imf); | |
1937 for (k=0; k<totaltracks; k++){ | |
1938 for (m=0; m<num_ch; m++){ | |
1939 for (t=0; t<num_ch; t++){ | |
1940 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicObjectApproxVolume.DynamicChange[j]. | |
1941 presElVol[k].Input[m].Output[t].preset_volume_element, sizeof(u8), 1, imf); | |
1942 } | |
1943 } | |
1944 } | |
1945 } | |
1946 break; | |
1947 case 6: printf("\nERROR WRITING PRESET CONTAINER IN OUTPUT FILE - Not valid case (6)\n"); | |
1948 system("pause"); | |
1949 exit(1); | |
1950 break; | |
1951 case 7: printf("\nERROR WRITING PRESET CONTAINER IN OUTPUT FILE - Not valid case (7)\n"); | |
1952 system("pause"); | |
1953 exit(1); | |
1954 break; | |
1955 case 8: for (j=0; j< moov.PresetContainerBox.PresetBox[i].num_preset_elements; j++) { | |
1956 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j]. | |
1957 preset_volume_element,sizeof(unsigned char), 1, imf); | |
1958 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.num_eq_filters, sizeof(u8), 1, imf); | |
1959 //EQ | |
1960 if (moov.PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.num_eq_filters != 0) { | |
1961 for (k=0; k<moov.PresetContainerBox.PresetBox[i].StaticTrackVolume.presVolumElem[j].EQ.num_eq_filters; k++){ | |
1962 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticTrackVolume. | |
1963 presVolumElem[j].EQ.Filter[k].filter_type, sizeof(u8), 1, imf); | |
1964 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticTrackVolume. | |
1965 presVolumElem[j].EQ.Filter[k].filter_reference_frequency, sizeof(u16), 1, imf); | |
1966 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticTrackVolume. | |
1967 presVolumElem[j].EQ.Filter[k].filter_gain, sizeof(u8), 1, imf); | |
1968 fwrite(&moov.PresetContainerBox.PresetBox[i].StaticTrackVolume. | |
1969 presVolumElem[j].EQ.Filter[k].filter_bandwidth, sizeof(u8), 1, imf); | |
1970 } //close for | |
1971 } //close if | |
1972 } | |
1973 break; | |
1974 case 9: // NOT YET IMPLEMENTED INTO THE PLAYER! | |
1975 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1976 break; | |
1977 case 10:// NOT YET IMPLEMENTED INTO THE PLAYER! | |
1978 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1979 break; | |
1980 case 11:// NOT YET IMPLEMENTED INTO THE PLAYER! | |
1981 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1982 break; | |
1983 case 12:// NOT YET IMPLEMENTED INTO THE PLAYER! | |
1984 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
1985 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.num_updates, sizeof(u16), 1, imf); | |
1986 temp = bytereverse16(moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.num_updates); | |
1987 for (j=0; j<temp; j++){ | |
1988 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1989 DynamicChange[j].start_sample_number, sizeof(u16), 1, imf); | |
1990 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1991 DynamicChange[j].duration_update, sizeof(u16), 1, imf); | |
1992 for (k=0; k<totaltracks; k++){ | |
1993 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume.DynamicChange[j]. | |
1994 presElVol[k].end_preset_volume_element, sizeof(u8), 1, imf); | |
1995 //EQ | |
1996 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1997 DynamicChange[j].presElVol[k].EQ.num_eq_filters, sizeof(u8), 1, imf); | |
1998 if(moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
1999 DynamicChange[j].presElVol[k].EQ.num_eq_filters != 0){ | |
2000 for (t=0; t<moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
2001 DynamicChange[j].presElVol[k].EQ.num_eq_filters; t++){ | |
2002 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
2003 DynamicChange[j].presElVol[k].EQ.Filter[t].filter_type, sizeof(u8), 1, imf); | |
2004 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
2005 DynamicChange[j].presElVol[k].EQ.Filter[t].filter_reference_frequency, sizeof(u16), 1, imf); | |
2006 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
2007 DynamicChange[j].presElVol[k].EQ.Filter[t].end_filter_gain, sizeof(u8), 1, imf); | |
2008 fwrite(&moov.PresetContainerBox.PresetBox[i].DynamicTrackApproxVolume. | |
2009 DynamicChange[j].presElVol[k].EQ.Filter[t].filter_bandwidth, sizeof(u8), 1, imf); | |
2010 } // close for (t) | |
2011 }//close if | |
2012 | |
2013 }// close for (k) | |
2014 } //close for (j) | |
2015 break; | |
2016 case 13:// NOT YET IMPLEMENTED INTO THE PLAYER! | |
2017 printf("\n\nTHIS PRESET IS NOT YET IMPLEMENTED INTO THE PLAYER!!! PLAYER MAY CRASH WITH THIS FILE!!!\n\n"); | |
2018 break; | |
2019 default: printf("\nERROR WRITING PRESET CONTAINER IN OUTPUT FILE - Not valid case (default)\n"); | |
2020 system("pause"); | |
2021 exit(1); | |
2022 break; | |
2023 | |
2024 } // close switch | |
2025 | |
2026 for (j=0; j<50; j++) { | |
2027 fwrite(&moov.PresetContainerBox.PresetBox[i].preset_name[j], sizeof(char), 1, imf); | |
2028 } | |
2029 | |
2030 } // close for | |
2031 | |
2032 | |
2033 //Rules Container// | |
2034 fwrite(&moov.RulesContainer.size, sizeof(u32), 1, imf); | |
2035 fwrite(&moov.RulesContainer.type, sizeof(u32), 1, imf); | |
2036 fwrite(&moov.RulesContainer.num_selection_rules, sizeof(u16), 1, imf); | |
2037 fwrite(&moov.RulesContainer.num_mixing_rules, sizeof(u16), 1, imf); | |
2038 //Selection Rules// | |
2039 fwrite(&moov.RulesContainer.SelectionRules.size, sizeof(u32), 1, imf); | |
2040 fwrite(&moov.RulesContainer.SelectionRules.type, sizeof(u32), 1, imf); | |
2041 fwrite(&moov.RulesContainer.SelectionRules.version, sizeof(u32), 1, imf); | |
2042 fwrite(&moov.RulesContainer.SelectionRules.selection_rule_ID, sizeof(u16), 1, imf); | |
2043 fwrite(&moov.RulesContainer.SelectionRules.selection_rule_type, sizeof(unsigned char), 1, imf); | |
2044 fwrite(&moov.RulesContainer.SelectionRules.element_ID, sizeof(u32), 1, imf); | |
2045 | |
2046 swap = moov.RulesContainer.SelectionRules.selection_rule_type; | |
2047 if ( swap==0 ) { | |
2048 fwrite(&moov.RulesContainer.SelectionRules.min_num_elements, sizeof(u16), 1, imf); | |
2049 fwrite(&moov.RulesContainer.SelectionRules.max_num_elements, sizeof(u16), 1, imf); | |
2050 } | |
2051 if ( swap==1 || swap ==3 ){ | |
2052 fwrite(&moov.RulesContainer.SelectionRules.key_element_ID, sizeof(u32), 1, imf); | |
2053 } | |
2054 | |
2055 for(i=0; i<20; i++){ | |
2056 fwrite(&moov.RulesContainer.SelectionRules.rule_description[i], sizeof(char), 1, imf); | |
2057 } | |
2058 | |
2059 //Mixing Rules// | |
2060 fwrite(&moov.RulesContainer.MixingRules.size, sizeof(u32), 1, imf); | |
2061 fwrite(&moov.RulesContainer.MixingRules.type, sizeof(u32), 1, imf); | |
2062 fwrite(&moov.RulesContainer.MixingRules.version, sizeof(u32), 1, imf); | |
2063 fwrite(&moov.RulesContainer.MixingRules.mixing_rule_ID, sizeof(u16), 1, imf); | |
2064 fwrite(&moov.RulesContainer.MixingRules.mixing_type,sizeof(unsigned char), 1, imf); | |
2065 fwrite(&moov.RulesContainer.MixingRules.element_ID, sizeof(u32), 1, imf); | |
2066 | |
2067 swap = moov.RulesContainer.MixingRules.mixing_type; | |
2068 if( swap==3 ){ | |
2069 fwrite(&moov.RulesContainer.MixingRules.min_volume, sizeof(u16), 1, imf); | |
2070 fwrite(&moov.RulesContainer.MixingRules.max_volume, sizeof(u16), 1, imf); | |
2071 } else { | |
2072 fwrite(&moov.RulesContainer.MixingRules.key_elem_ID, sizeof(u32), 1, imf); | |
2073 } | |
2074 for(i=0; i<17; i++){ | |
2075 fwrite(&moov.RulesContainer.MixingRules.mix_description[i], | |
2076 sizeof(char), 1, imf); | |
2077 } | |
2078 | |
2079 //TIMED TEXT | |
2080 | |
2081 if (HasTextFile){ | |
2082 fwrite(&moov.TrackBox[numtrack].size, sizeof(u32), 1, imf); | |
2083 fwrite(&moov.TrackBox[numtrack].type, sizeof(u32), 1, imf); | |
2084 //Track header// | |
2085 fwrite(&moov.TrackBox[numtrack].TrackHeaderBox, | |
2086 sizeof(moov.TrackBox[numtrack].TrackHeaderBox), 1, imf); | |
2087 //Media Box// | |
2088 fwrite(&moov.TrackBox[numtrack].MediaBox.size, sizeof(u32), 1, imf); | |
2089 fwrite(&moov.TrackBox[numtrack].MediaBox.type, sizeof(u32), 1, imf); | |
2090 //Media Header// | |
2091 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaHeaderBox, | |
2092 sizeof(moov.TrackBox[numtrack].MediaBox.MediaHeaderBox), 1, imf); | |
2093 //Handler Box// | |
2094 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.size, sizeof(u32), 1, imf); | |
2095 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.type, sizeof(u32), 1, imf); | |
2096 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.version, sizeof(u32), 1, imf); | |
2097 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.pre_defined, sizeof(u32), 1, imf); | |
2098 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.handler_type, sizeof(u32), 1, imf); | |
2099 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.reserved[0], sizeof(u32), 1, imf); | |
2100 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.reserved[1], sizeof(u32), 1, imf); | |
2101 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.reserved[2], sizeof(u32), 1, imf); | |
2102 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[0], sizeof(unsigned char), 1, imf); | |
2103 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[1], sizeof(unsigned char), 1, imf); | |
2104 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[2], sizeof(unsigned char), 1, imf); | |
2105 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[3], sizeof(unsigned char), 1, imf); | |
2106 fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[4], sizeof(unsigned char), 1, imf); | |
2107 //Media information box// | |
2108 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.size, sizeof(u32), 1, imf); | |
2109 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.type, sizeof(u32), 1, imf); | |
2110 //Null media header// | |
2111 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.NullMediaHeaderBox.size, | |
2112 sizeof(u32), 1, imf); | |
2113 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.NullMediaHeaderBox.type, | |
2114 sizeof(u32), 1, imf); | |
2115 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.NullMediaHeaderBox.flags, | |
2116 sizeof(u32), 1, imf); | |
2117 //Data Information | |
2118 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.size,sizeof(u32),1,imf); | |
2119 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.type,sizeof(u32),1,imf); | |
2120 //Data Reference | |
2121 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataReferenceBox.size,sizeof(u32),1,imf); | |
2122 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataReferenceBox.type,sizeof(u32),1,imf); | |
2123 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataReferenceBox.flags,sizeof(u32),1,imf); | |
2124 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataReferenceBox.entry_count,sizeof(u32),1,imf); | |
2125 //Data Entry URL | |
2126 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataReferenceBox.DataEntryUrlBox.size,sizeof(u32),1,imf); | |
2127 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataReferenceBox.DataEntryUrlBox.type,sizeof(u32),1,imf); | |
2128 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataReferenceBox.DataEntryUrlBox.flags,sizeof(u32),1,imf); | |
2129 //Sample table box// | |
2130 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2131 size, sizeof(u32), 1, imf); | |
2132 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2133 type, sizeof(u32), 1, imf); | |
2134 //Time to sample box// | |
2135 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2136 TimeToSampleBox.size, sizeof(u32), 1, imf); | |
2137 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2138 TimeToSampleBox.type, sizeof(u32), 1, imf); | |
2139 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2140 TimeToSampleBox.version, sizeof(u32), 1, imf); | |
2141 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2142 TimeToSampleBox.entry_count, sizeof(u32), 1, imf); | |
2143 swap = bytereverse(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2144 TimeToSampleBox.entry_count); | |
2145 pos = swap; | |
2146 | |
2147 for (i=0; i<pos; i++) { | |
2148 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2149 TimeToSampleBox.sample_count[i], sizeof(u32), 1, imf); | |
2150 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2151 TimeToSampleBox.sample_delta[i], sizeof(u32), 1, imf); | |
2152 } | |
2153 | |
2154 //Sample description box// | |
2155 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2156 SampleDescriptionBox.size, sizeof(u32), 1, imf); | |
2157 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2158 SampleDescriptionBox.type, sizeof(u32), 1, imf); | |
2159 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2160 SampleDescriptionBox.version, sizeof(u32), 1, imf); | |
2161 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2162 SampleDescriptionBox.entry_count, sizeof(u32), 1, imf); | |
2163 //tx3g | |
2164 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2165 SampleTableBox.SampleDescriptionBox.TextSampleEntry.size,sizeof(u32),1,imf); | |
2166 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2167 SampleTableBox.SampleDescriptionBox.TextSampleEntry.type,sizeof(u32),1,imf); | |
2168 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2169 SampleTableBox.SampleDescriptionBox.TextSampleEntry.a,sizeof(u32),1,imf); | |
2170 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2171 SampleTableBox.SampleDescriptionBox.TextSampleEntry.b,sizeof(u32),1,imf); | |
2172 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2173 SampleTableBox.SampleDescriptionBox.TextSampleEntry.displayFlags,sizeof(u32),1,imf); | |
2174 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2175 SampleTableBox.SampleDescriptionBox.TextSampleEntry.horizontaljustification,sizeof(u8),1,imf); | |
2176 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2177 SampleTableBox.SampleDescriptionBox.TextSampleEntry.verticaljustification,sizeof(u8),1,imf); | |
2178 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2179 SampleTableBox.SampleDescriptionBox.TextSampleEntry.backgroundcolorrgba[0],sizeof(u8),1,imf); | |
2180 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2181 SampleTableBox.SampleDescriptionBox.TextSampleEntry.backgroundcolorrgba[1],sizeof(u8),1,imf); | |
2182 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2183 SampleTableBox.SampleDescriptionBox.TextSampleEntry.backgroundcolorrgba[2],sizeof(u8),1,imf); | |
2184 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2185 SampleTableBox.SampleDescriptionBox.TextSampleEntry.backgroundcolorrgba[3],sizeof(u8),1,imf); | |
2186 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2187 SampleTableBox.SampleDescriptionBox.TextSampleEntry.top,sizeof(u16),1,imf); | |
2188 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2189 SampleTableBox.SampleDescriptionBox.TextSampleEntry.left,sizeof(u16),1,imf); | |
2190 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2191 SampleTableBox.SampleDescriptionBox.TextSampleEntry.bottom,sizeof(u16),1,imf); | |
2192 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2193 SampleTableBox.SampleDescriptionBox.TextSampleEntry.right,sizeof(u16),1,imf); | |
2194 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2195 SampleTableBox.SampleDescriptionBox.TextSampleEntry.startChar,sizeof(u16),1,imf); | |
2196 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2197 SampleTableBox.SampleDescriptionBox.TextSampleEntry.endChar,sizeof(u16),1,imf); | |
2198 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2199 SampleTableBox.SampleDescriptionBox.TextSampleEntry.fontID,sizeof(u16),1,imf); | |
2200 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2201 SampleTableBox.SampleDescriptionBox.TextSampleEntry.facestyleflags,sizeof(u8),1,imf); | |
2202 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2203 SampleTableBox.SampleDescriptionBox.TextSampleEntry.fontsize,sizeof(u8),1,imf); | |
2204 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2205 SampleTableBox.SampleDescriptionBox.TextSampleEntry.textcolorrgba[0],sizeof(u8),1,imf); | |
2206 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2207 SampleTableBox.SampleDescriptionBox.TextSampleEntry.textcolorrgba[1],sizeof(u8),1,imf); | |
2208 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2209 SampleTableBox.SampleDescriptionBox.TextSampleEntry.textcolorrgba[2],sizeof(u8),1,imf); | |
2210 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2211 SampleTableBox.SampleDescriptionBox.TextSampleEntry.textcolorrgba[3],sizeof(u8),1,imf); | |
2212 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2213 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.size,sizeof(u32),1,imf); | |
2214 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2215 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.type,sizeof(u32),1,imf); | |
2216 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2217 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.entrycount,sizeof(u16),1,imf); | |
2218 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2219 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.fontID,sizeof(u16),1,imf); | |
2220 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2221 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.fontnamelenght,sizeof(u8),1,imf); | |
2222 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2223 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[0],sizeof(u8),1,imf); | |
2224 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2225 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[1],sizeof(u8),1,imf); | |
2226 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2227 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[2],sizeof(u8),1,imf); | |
2228 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2229 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[3],sizeof(u8),1,imf); | |
2230 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox. | |
2231 SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[4],sizeof(u8),1,imf); | |
2232 //Sample Size box// | |
2233 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2234 SampleSizeBox.size, sizeof(u32), 1, imf); | |
2235 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2236 SampleSizeBox.type, sizeof(u32), 1, imf); | |
2237 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2238 SampleSizeBox.version, sizeof(u32), 1, imf); | |
2239 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2240 SampleSizeBox.sample_size, sizeof(u32), 1, imf); | |
2241 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2242 SampleSizeBox.sample_count, sizeof(u32), 1, imf); | |
2243 swap = bytereverse(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2244 SampleSizeBox.sample_count); | |
2245 | |
2246 for(i=0; i<swap; i++){ | |
2247 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2248 SampleSizeBox.entry_size[i], sizeof(u32), 1, imf); | |
2249 } | |
2250 | |
2251 //Sample to chunk box// | |
2252 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2253 SampleToChunk.size, sizeof(u32), 1, imf); | |
2254 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2255 SampleToChunk.type, sizeof(u32), 1, imf); | |
2256 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2257 SampleToChunk.version, sizeof(u32), 1, imf); | |
2258 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2259 SampleToChunk.entry_count, sizeof(u32), 1, imf); | |
2260 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2261 SampleToChunk.first_chunk, sizeof(u32), 1, imf); | |
2262 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2263 SampleToChunk.samples_per_chunk, sizeof(u32), 1, imf); | |
2264 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2265 SampleToChunk.sample_description_index, sizeof(u32), 1, imf); | |
2266 | |
2267 //Chunk offset// | |
2268 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2269 ChunkOffsetBox.size, sizeof(u32), 1, imf); | |
2270 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2271 ChunkOffsetBox.type, sizeof(u32), 1, imf); | |
2272 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2273 ChunkOffsetBox.version, sizeof(u32), 1, imf); | |
2274 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2275 ChunkOffsetBox.entry_count, sizeof(u32), 1, imf); | |
2276 swap=0x00; | |
2277 fwrite(&swap,sizeof(u32),1,imf); | |
2278 for (i=0;i<bytereverse(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2279 ChunkOffsetBox.entry_count);i++){ | |
2280 | |
2281 fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2282 ChunkOffsetBox.chunk_offset[i], sizeof(u32), 1, imf); | |
2283 } | |
2284 } // end if HasTextFile | |
2285 //Song Image// | |
2286 /* Go to function "writemeta" */ | |
2287 | |
2288 } | |
2289 | |
2290 | |
2291 void writepresets(MovieBox moov, int numtrack,int totaltracks, FILE *imf) { | |
2292 | |
2293 //int i, j, k, m, t, temp, type; | |
2294 | |
2295 // this function is executed in "writemoovbox"; | |
2296 // to be implemented as standalone | |
2297 } | |
2298 | |
2299 // Fill the MetaBox | |
2300 | |
2301 int metacontainer(MetaBox *meta) { | |
2302 //int swap; | |
2303 | |
2304 u32 sizeMETA; | |
2305 u32 sizeHDLR = 36; | |
2306 u32 sizeDINF; | |
2307 u32 sizeDREF = 0; //16 | |
2308 u32 sizeURL = 0; //12 | |
2309 u32 sizeILOC = 36 - 2; | |
2310 u32 sizeIINF; | |
2311 u32 sizeINFE = 44; | |
2312 u32 sizeXML = 12 + 2000; | |
2313 char name[6] = "image"; | |
2314 char type_content[18] = "application/other"; | |
2315 char encoding[4] = "jpg"; | |
2316 | |
2317 //METADATA | |
2318 char xml[2000] = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?><Mpeg7 xmlns=\"urn:mpeg:mpeg7:schema:2001\"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:mpeg7=\"urn:mpeg:mpeg7:schema:2001\"xmlns:xml=\"http://www.w3.org/XML/1998/namespace\"xsi:schemaLocation=\"urn:mpeg:mpeg7:schema:2001 Mpeg7-2001.xsd\"><Description xsi:type=\"CreationDescriptionType\"><CreationInformation><Creation><Title type=\"songTitle\">IMAF Song</Title><Title type=\"albumTitle\">Encoder</Title><Abstract><FreeTextAnnotation>QMUL</FreeTextAnnotation></Abstract><Creator><Role href=\"urn:mpeg:mpeg7:RoleCS:2001:PERFORMER\"/><Agent xsi:type=\"PersonType\"><Name><FamilyName></FamilyName><GivenName>Frank Sinatra</GivenName></Name></Agent></Creator><CreationCoordinates><Date><TimePoint>2013</TimePoint></Date></CreationCoordinates><CopyrightString></CopyrightString></Creation><Classification><Genre href=\"urn:id3:cs:ID3genreCS:v1:12\"><Name>Electro</Name></Genre></Classification></CreationInformation></Description><Description xsi:type=\"SemanticDescriptionType\"> <Semantics> <SemanticBase xsi:type=\"SemanticStateType\"><AttributeValuePair><Attribute><TermUse href=\"urn:mpeg:maf:cs:musicplayer:CollectionElementsCS:2007:assetNum\"/></Attribute><IntegerValue>07</IntegerValue></AttributeValuePair><AttributeValuePair><Attribute><TermUse href=\"urn:mpeg:maf:cs:musicplayer:CollectionElementsCS:2013:assetTot\"/></Attribute><IntegerValue>11</IntegerValue></AttributeValuePair></SemanticBase></Semantics></Description><Description xsi:type=\"SemanticDescriptionType\"><MediaInformation><MediaIdentification><EntityIdentifier></EntityIdentifier></MediaIdentification></MediaInformation></Description></Mpeg7>"; | |
2319 | |
2320 sizeDINF = 8;// + sizeDREF + sizeURL; | |
2321 sizeIINF = 14 + sizeINFE; | |
2322 sizeMETA = 12 + sizeHDLR + sizeDINF + sizeILOC + sizeIINF + sizeXML; | |
2323 | |
2324 meta->size = bytereverse(sizeMETA); | |
2325 meta->type = bytereverse('meta'); | |
2326 meta->version = 0; | |
2327 //HandlerBox | |
2328 meta->theHandler.size = bytereverse(sizeHDLR); | |
2329 meta->theHandler.type = bytereverse('hdlr'); | |
2330 meta->theHandler.version = 0; | |
2331 meta->theHandler.pre_defined = 0; | |
2332 meta->theHandler.handler_type = bytereverse('meta'); | |
2333 meta->theHandler.reserved[0] = 0; | |
2334 meta->theHandler.reserved[1] = 0; | |
2335 meta->theHandler.reserved[2] = 0; | |
2336 meta->theHandler.name[0] = bytereverse('m'); | |
2337 meta->theHandler.name[1] = bytereverse('p'); | |
2338 meta->theHandler.name[2] = bytereverse('7'); | |
2339 meta->theHandler.name[3] = bytereverse('t'); | |
2340 //DataInformationBox | |
2341 meta->file_locations.size = bytereverse(sizeDINF); | |
2342 meta->file_locations.type = bytereverse('dinf'); | |
2343 /* | |
2344 //DataReferenceBox | |
2345 meta->file_locations.DataReferenceBox.size = bytereverse(sizeDREF); | |
2346 meta->file_locations.DataReferenceBox.type = bytereverse('dref'); | |
2347 meta->file_locations.DataReferenceBox.flags = bytereverse(0); // CHECK THIS VALUE | |
2348 meta->file_locations.DataReferenceBox.entry_count = bytereverse(1); | |
2349 //DataEntryUrlBox | |
2350 meta->file_locations.DataReferenceBox.DataEntryUrlBox.size = bytereverse(sizeURL); | |
2351 meta->file_locations.DataReferenceBox.DataEntryUrlBox.type = bytereverse('url '); // 'url ' with blank space | |
2352 meta->file_locations.DataReferenceBox.DataEntryUrlBox.flags = bytereverse(0); // CHECK THIS VALUE | |
2353 */ | |
2354 //item_location | |
2355 meta->item_locations.size = bytereverse(sizeILOC); | |
2356 meta->item_locations.type = bytereverse('iloc'); | |
2357 meta->item_locations.version = 0; | |
2358 meta->item_locations.offset_size = 68; // 0100|0100 offset_size = 4 + lenght_size = 4 | |
2359 //meta->item_locations.lenght_size = 4; //already included | |
2360 meta->item_locations.base_offset_size = 64; // 0100|0000 base_offset_size = 4 + reserved = 0 | |
2361 //meta->item_locations.reserved = 0; //already included | |
2362 meta->item_locations.item_count = bytereverse16(1); | |
2363 meta->item_locations.item_ID = bytereverse16(1); | |
2364 meta->item_locations.data_reference_index = 0; | |
2365 //meta->item_locations.base_offset = bytereverse(); // corresponding to iloc_offset in insertImage function | |
2366 meta->item_locations.extent_count = bytereverse16(1); | |
2367 //meta->item_locations.extent_offset = bytereverse(); // corresponding to iloc_offset in insertImage function | |
2368 //meta->item_locations.extent_length = bytereverse(); // corresponding to imagesize in insertImage function | |
2369 | |
2370 //ItemInfoBox | |
2371 meta->item_infos.size = bytereverse(sizeIINF); | |
2372 meta->item_infos.type = bytereverse('iinf'); | |
2373 meta->item_infos.version = 0; | |
2374 meta->item_infos.entry_count = bytereverse16(1); | |
2375 | |
2376 //info_entry | |
2377 meta->item_infos.info_entry.size = bytereverse(sizeINFE); | |
2378 meta->item_infos.info_entry.type = bytereverse('infe'); | |
2379 meta->item_infos.info_entry.version = 0; | |
2380 meta->item_infos.info_entry.item_ID = bytereverse16(1); | |
2381 meta->item_infos.info_entry.item_protection_index = 0; | |
2382 strcpy(meta->item_infos.info_entry.item_name, name); | |
2383 strcpy(meta->item_infos.info_entry.content_type, type_content); | |
2384 strcpy(meta->item_infos.info_entry.content_encoding, encoding); | |
2385 | |
2386 //XMLBox (MetaData) | |
2387 meta->XMLBox.size = bytereverse(sizeXML); | |
2388 meta->XMLBox.type = bytereverse('xml '); | |
2389 meta->XMLBox.version = 0; | |
2390 strcpy(meta->XMLBox.string, xml); | |
2391 | |
2392 return sizeMETA; | |
2393 } | |
2394 | |
2395 //Read the image's size | |
2396 u32 getImageSize(const char *imagedir){ | |
2397 u32 size; | |
2398 FILE *img; | |
2399 | |
2400 img = fopen(imagedir,"rb"); | |
2401 | |
2402 //Calculate size of the picture | |
2403 fseek(img,0,SEEK_END); | |
2404 size = ftell(img); | |
2405 fclose(img); | |
2406 | |
2407 return size; | |
2408 } | |
2409 //Read the text´s size | |
2410 int getTextSize (FILE *text){ | |
2411 | |
2412 int d=0,sizetext=0,dat=0,dat1=0,dat2=0,dat3=0; | |
2413 | |
2414 //TEXT-FILE | |
2415 //Find mdat in text file in order to know the size of the text file | |
2416 d=0; | |
2417 while(d==0){ | |
2418 | |
2419 fread (&dat,sizeof(unsigned char),1,text); //read a byte and saves it in dat | |
2420 fread (&dat1,sizeof(unsigned char),1,text); | |
2421 fread (&dat2,sizeof(unsigned char),1,text); | |
2422 fread (&dat3,sizeof(unsigned char),1,text); | |
2423 fseek(text,-3,SEEK_CUR); | |
2424 | |
2425 if(dat == 0x6D && dat1 == 0x64 && dat2 == 0x61 && dat3 == 0x74){ // 6D646174 = mdat | |
2426 d=1; | |
2427 } | |
2428 | |
2429 } //close while | |
2430 | |
2431 fseek (text,-5,SEEK_CUR);//positionate the pointer at the first byte of size | |
2432 fread (&dat,sizeof(unsigned char),1,text); //first byte of size | |
2433 fread (&dat1,sizeof(unsigned char),1,text);//second byte of size | |
2434 fread (&dat2,sizeof(unsigned char),1,text);//third byte of size | |
2435 fread (&dat3,sizeof(unsigned char),1,text);//fourth byte of size | |
2436 | |
2437 sizetext = (dat<<24) | (dat1<<16) | (dat2<<8) | (dat3); | |
2438 sizetext = sizetext-8-16; //4 bytes of size and 4 bytes of type and 16 bytes of padding | |
2439 | |
2440 fseek (text,20,SEEK_CUR);//Advance 20 bytes, because the pointer must advance 20 bytes to read the size of the first string.This is because of the way that Quicktime creates the 3gp | |
2441 | |
2442 return sizetext; | |
2443 | |
2444 | |
2445 } | |
2446 | |
2447 //Read the JPEG file | |
2448 | |
2449 void insertImage (MetaBox *meta, FILE **imf, u32 imagesize, const char *imagedir) { | |
2450 | |
2451 FILE *img; | |
2452 u64 iloc_offset = 0; | |
2453 unsigned char *imgbuffer; | |
2454 | |
2455 img = fopen(imagedir,"rb"); | |
2456 | |
2457 // Binary reading | |
2458 fseek(img,0,SEEK_SET); | |
2459 imgbuffer= (unsigned char*)malloc(sizeof(unsigned char)*imagesize); | |
2460 fread(imgbuffer, 1, imagesize, img); | |
2461 fclose(img); | |
2462 | |
2463 // Find position in the IMAF file and write the image | |
2464 iloc_offset = ftell(*imf); | |
2465 fwrite(imgbuffer,1,imagesize, *imf); | |
2466 | |
2467 // Set image size and offset values | |
2468 meta->item_locations.base_offset = bytereverse(iloc_offset); | |
2469 meta->item_locations.extent_length = bytereverse(imagesize); | |
2470 meta->item_locations.extent_offset = bytereverse(iloc_offset); | |
2471 | |
2472 } | |
2473 | |
2474 | |
2475 void writemetabox(MetaBox meta, FILE *imf) { | |
2476 | |
2477 int i=0; | |
2478 | |
2479 //MetaBox | |
2480 fwrite(&meta.size, sizeof(u32), 1, imf); | |
2481 fwrite(&meta.type, sizeof(u32), 1, imf); | |
2482 fwrite(&meta.version, sizeof(u32), 1, imf); | |
2483 //Handler | |
2484 fwrite(&meta.theHandler.size, sizeof(u32), 1, imf); | |
2485 fwrite(&meta.theHandler.type, sizeof(u32), 1, imf); | |
2486 fwrite(&meta.theHandler.version, sizeof(u32), 1, imf); | |
2487 fwrite(&meta.theHandler.pre_defined, sizeof(u32), 1, imf); | |
2488 fwrite(&meta.theHandler.handler_type, sizeof(u32), 1, imf); | |
2489 fwrite(&meta.theHandler.reserved[0], sizeof(u32), 1, imf); | |
2490 fwrite(&meta.theHandler.reserved[1], sizeof(u32), 1, imf); | |
2491 fwrite(&meta.theHandler.reserved[2], sizeof(u32), 1, imf); | |
2492 fwrite(&meta.theHandler.name[0], sizeof(unsigned char), 1, imf); | |
2493 fwrite(&meta.theHandler.name[1], sizeof(unsigned char), 1, imf); | |
2494 fwrite(&meta.theHandler.name[2], sizeof(unsigned char), 1, imf); | |
2495 fwrite(&meta.theHandler.name[3], sizeof(unsigned char), 1, imf); | |
2496 //Data Information Box | |
2497 fwrite(&meta.file_locations.size, sizeof(u32), 1, imf); | |
2498 fwrite(&meta.file_locations.type, sizeof(u32), 1, imf); | |
2499 /* | |
2500 //Data Reference | |
2501 fwrite(&meta.file_locations.DataReferenceBox.size, sizeof(u32), 1, imf); | |
2502 fwrite(&meta.file_locations.DataReferenceBox.type, sizeof(u32), 1, imf); | |
2503 fwrite(&meta.file_locations.DataReferenceBox.flags, sizeof(u32), 1, imf); | |
2504 fwrite(&meta.file_locations.DataReferenceBox.entry_count, sizeof(u32), 1, imf); | |
2505 | |
2506 fwrite(&meta.file_locations.DataReferenceBox.DataEntryUrlBox.size, sizeof(u32), 1, imf); | |
2507 fwrite(&meta.file_locations.DataReferenceBox.DataEntryUrlBox.type, sizeof(u32), 1, imf); | |
2508 fwrite(&meta.file_locations.DataReferenceBox.DataEntryUrlBox.flags, sizeof(u32), 1, imf); | |
2509 */ | |
2510 //Item Location Box | |
2511 fwrite(&meta.item_locations.size, sizeof(u32), 1, imf); | |
2512 fwrite(&meta.item_locations.type, sizeof(u32), 1, imf); | |
2513 fwrite(&meta.item_locations.version, sizeof(u32), 1, imf); | |
2514 fwrite(&meta.item_locations.offset_size, sizeof(unsigned char), 1, imf); | |
2515 //fwrite(&meta.item_locations.lenght_size, sizeof(unsigned char), 1, imf); | |
2516 fwrite(&meta.item_locations.base_offset_size, sizeof(unsigned char), 1, imf); | |
2517 //fwrite(&meta.item_locations.reserved, sizeof(unsigned char), 1, imf); | |
2518 fwrite(&meta.item_locations.item_count, sizeof(u16), 1, imf); | |
2519 fwrite(&meta.item_locations.item_ID, sizeof(u16), 1, imf); | |
2520 fwrite(&meta.item_locations.data_reference_index, sizeof(u16), 1, imf); | |
2521 fwrite(&meta.item_locations.base_offset, sizeof(u32), 1, imf); | |
2522 fwrite(&meta.item_locations.extent_count, sizeof(u16), 1, imf); | |
2523 fwrite(&meta.item_locations.extent_offset, sizeof(u32), 1, imf); | |
2524 fwrite(&meta.item_locations.extent_length, sizeof(u32), 1, imf); | |
2525 //Item Info | |
2526 fwrite(&meta.item_infos.size, sizeof(u32), 1, imf); | |
2527 fwrite(&meta.item_infos.type, sizeof(u32), 1, imf); | |
2528 fwrite(&meta.item_infos.version, sizeof(u32), 1, imf); | |
2529 fwrite(&meta.item_infos.entry_count, sizeof(u16), 1, imf); | |
2530 //Info Entry | |
2531 fwrite(&meta.item_infos.info_entry.size, sizeof(u32), 1, imf); | |
2532 fwrite(&meta.item_infos.info_entry.type, sizeof(u32), 1, imf); | |
2533 fwrite(&meta.item_infos.info_entry.version, sizeof(u32), 1, imf); | |
2534 fwrite(&meta.item_infos.info_entry.item_ID, sizeof(u16), 1, imf); | |
2535 fwrite(&meta.item_infos.info_entry.item_protection_index, sizeof(u16), 1, imf); | |
2536 for (i=0; i<6; i++){ | |
2537 fwrite(&meta.item_infos.info_entry.item_name[i], sizeof(char), 1, imf); | |
2538 } | |
2539 for (i=0; i<18; i++){ | |
2540 fwrite(&meta.item_infos.info_entry.content_type[i], sizeof(char), 1, imf); | |
2541 } | |
2542 for (i=0; i<4; i++){ | |
2543 fwrite(&meta.item_infos.info_entry.content_encoding[i], sizeof(char), 1, imf); | |
2544 } | |
2545 //XML for metadata | |
2546 fwrite(&meta.XMLBox.size, sizeof(u32), 1, imf); | |
2547 fwrite(&meta.XMLBox.type, sizeof(u32), 1, imf); | |
2548 fwrite(&meta.XMLBox.version, sizeof(u32), 1, imf); | |
2549 for(i=0; i<2000; i++){ | |
2550 fwrite(&meta.XMLBox.string[i], sizeof(char), 1, imf); | |
2551 } | |
2552 | |
2553 } | |
2554 | |
2555 //TIMED-TEXT's funcionts | |
2556 int trackstructure_text (MovieBox *moov, int numtrack, int clock, | |
2557 int durationTrack, int sizemdat, const char *textfile,FILE *text,int totaltracks ) { // creates the text trak structure | |
2558 int swap; | |
2559 u32 sizeURL; | |
2560 u32 sizeDREF; | |
2561 u32 sizeDINF; | |
2562 u32 sizeSMHD; | |
2563 u32 sizeMINF; | |
2564 u32 sizeHDLR; | |
2565 u32 sizeMDHD; | |
2566 u32 sizeMDIA; | |
2567 u32 sizeTKHD; | |
2568 u32 sizeTRAK; | |
2569 | |
2570 | |
2571 //Sample Table Box | |
2572 int sizeSTBL = 0; | |
2573 | |
2574 sizeSTBL = samplecontainer_text(moov, numtrack,sizemdat, textfile,totaltracks); | |
2575 | |
2576 //Data Entry Url Box | |
2577 sizeURL = 12; | |
2578 swap = bytereverse(sizeURL); | |
2579 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
2580 DataReferenceBox.DataEntryUrlBox.size = swap; | |
2581 swap = bytereverse('url '); | |
2582 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
2583 DataReferenceBox.DataEntryUrlBox.type = swap; | |
2584 swap = bytereverse(1); | |
2585 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
2586 DataReferenceBox.DataEntryUrlBox.flags = swap; // =1 Track in same file as movie atom. | |
2587 | |
2588 //Data Reference | |
2589 sizeDREF = sizeURL+ 16; | |
2590 swap = bytereverse(sizeDREF); | |
2591 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
2592 DataReferenceBox.size = swap; | |
2593 swap = bytereverse('dref'); | |
2594 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
2595 DataReferenceBox.type = swap; | |
2596 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
2597 DataReferenceBox.flags = 0; | |
2598 swap = bytereverse(1); | |
2599 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox. | |
2600 DataReferenceBox.entry_count = swap; | |
2601 | |
2602 //Data information Box// | |
2603 sizeDINF = sizeDREF + 8; | |
2604 swap = bytereverse(sizeDINF); | |
2605 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.size = swap; | |
2606 swap = bytereverse('dinf'); | |
2607 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.type = swap; | |
2608 | |
2609 | |
2610 //Null Media Header Box | |
2611 swap = bytereverse(12); | |
2612 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.NullMediaHeaderBox.size = swap ; | |
2613 swap = bytereverse ('nmhd'); | |
2614 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.NullMediaHeaderBox.type = swap; | |
2615 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.NullMediaHeaderBox.flags = 0; | |
2616 | |
2617 //Media Information Box// | |
2618 sizeMINF = sizeDINF + sizeSTBL + 8 + 12; | |
2619 swap = bytereverse(sizeMINF); | |
2620 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.size = swap; | |
2621 swap = bytereverse('minf'); | |
2622 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.type = swap; | |
2623 | |
2624 //Handler Box// | |
2625 sizeHDLR = 37; | |
2626 swap = bytereverse(sizeHDLR); | |
2627 moov->TrackBox[numtrack].MediaBox.HandlerBox.size = swap; | |
2628 swap = bytereverse('hdlr'); | |
2629 moov->TrackBox[numtrack].MediaBox.HandlerBox.type = swap; | |
2630 moov->TrackBox[numtrack].MediaBox.HandlerBox.version = 0; | |
2631 moov->TrackBox[numtrack].MediaBox.HandlerBox.pre_defined = 0; | |
2632 swap = bytereverse('text'); | |
2633 moov->TrackBox[numtrack].MediaBox.HandlerBox.handler_type = swap; | |
2634 moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[0] = 0; | |
2635 moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[1] = 0; | |
2636 moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[2] = 0; | |
2637 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[0] = 't'; | |
2638 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[1] = 'e'; | |
2639 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[2] = 'x'; | |
2640 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[3] = 't'; | |
2641 moov->TrackBox[numtrack].MediaBox.HandlerBox.data[4] = '\0'; | |
2642 | |
2643 //Media Header Box// | |
2644 sizeMDHD = 32; | |
2645 swap = bytereverse(sizeMDHD); | |
2646 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.size = swap; | |
2647 swap = bytereverse('mdhd'); | |
2648 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.type = swap; | |
2649 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.version = 0; | |
2650 swap = bytereverse(clock); | |
2651 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.creation_time = swap; | |
2652 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.modification_time = swap; | |
2653 swap = bytereverse(1000); | |
2654 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.timescale = swap; | |
2655 swap = bytereverse(durationTrack); | |
2656 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.duration = swap; | |
2657 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.language = 0xC455; | |
2658 moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.pre_defined = 0; | |
2659 | |
2660 //Media Box// | |
2661 sizeMDIA = sizeMDHD + sizeHDLR + sizeMINF + 8; | |
2662 swap = bytereverse(sizeMDIA); | |
2663 moov->TrackBox[numtrack].MediaBox.size = swap; | |
2664 swap = bytereverse('mdia'); | |
2665 moov->TrackBox[numtrack].MediaBox.type = swap; | |
2666 | |
2667 //Track Header// | |
2668 sizeTKHD = 92; | |
2669 swap = bytereverse (sizeTKHD); | |
2670 moov->TrackBox[numtrack].TrackHeaderBox.size = swap; | |
2671 swap = bytereverse ('tkhd'); | |
2672 moov->TrackBox[numtrack].TrackHeaderBox.type = swap ; | |
2673 swap = bytereverse (0x00000007); | |
2674 moov->TrackBox[numtrack].TrackHeaderBox.version = swap; | |
2675 swap = bytereverse (clock); | |
2676 moov->TrackBox[numtrack].TrackHeaderBox.creation_time = swap; | |
2677 moov->TrackBox[numtrack].TrackHeaderBox.modification_time = swap; | |
2678 moov->TrackBox[numtrack].TrackHeaderBox.track_ID = bytereverse(12345678); | |
2679 moov->TrackBox[numtrack].TrackHeaderBox.reserved = 0; | |
2680 swap = bytereverse (durationTrack); | |
2681 moov->TrackBox[numtrack].TrackHeaderBox.duration = swap; | |
2682 moov->TrackBox[numtrack].TrackHeaderBox.reserved2[0] = 0; | |
2683 moov->TrackBox[numtrack].TrackHeaderBox.reserved2[1] = 0; | |
2684 moov->TrackBox[numtrack].TrackHeaderBox.layer = 0; | |
2685 moov->TrackBox[numtrack].TrackHeaderBox.alternate_group = 0; | |
2686 moov->TrackBox[numtrack].TrackHeaderBox.volume = 0; | |
2687 moov->TrackBox[numtrack].TrackHeaderBox.reserved3 = 0; | |
2688 swap = bytereverse (0x00010000); | |
2689 moov->TrackBox[numtrack].TrackHeaderBox.matrix[0] = swap; | |
2690 moov->TrackBox[numtrack].TrackHeaderBox.matrix[1] = 0; | |
2691 moov->TrackBox[numtrack].TrackHeaderBox.matrix[2] = 0; | |
2692 moov->TrackBox[numtrack].TrackHeaderBox.matrix[3] = 0; | |
2693 moov->TrackBox[numtrack].TrackHeaderBox.matrix[4] = swap; | |
2694 moov->TrackBox[numtrack].TrackHeaderBox.matrix[5] = 0; | |
2695 moov->TrackBox[numtrack].TrackHeaderBox.matrix[6] = 0; | |
2696 moov->TrackBox[numtrack].TrackHeaderBox.matrix[7] = 0; | |
2697 swap = bytereverse(0x40000000); | |
2698 moov->TrackBox[numtrack].TrackHeaderBox.matrix[8] = swap; | |
2699 moov->TrackBox[numtrack].TrackHeaderBox.width =0; | |
2700 moov->TrackBox[numtrack].TrackHeaderBox.height = 0; | |
2701 | |
2702 //Track container | |
2703 sizeTRAK = sizeTKHD + sizeMDIA + 8; | |
2704 swap = bytereverse (sizeTRAK); // Size of one track | |
2705 moov->TrackBox[numtrack].size = swap; | |
2706 swap = bytereverse ('trak'); | |
2707 moov->TrackBox[numtrack].type = swap; | |
2708 | |
2709 return sizeTRAK; | |
2710 } | |
2711 | |
2712 | |
2713 int aux (FILE *text,int num,int num1,int num2,int num3,int *sal) { | |
2714 int dat=0,dat1=0,dat2=0,dat3=0,size=0,d=0,cnt=0,i=0; | |
2715 fseek(text,0,SEEK_SET); | |
2716 d=0; | |
2717 while(d==0){ | |
2718 | |
2719 fread (&dat,sizeof(unsigned char),1,text); | |
2720 cnt++; | |
2721 fread (&dat1,sizeof(unsigned char),1,text); | |
2722 cnt++; | |
2723 fread (&dat2,sizeof(unsigned char),1,text); | |
2724 cnt++; | |
2725 fread (&dat3,sizeof(unsigned char),1,text); | |
2726 cnt++; | |
2727 fseek(text, -3 ,SEEK_CUR); | |
2728 if(dat == num && dat1 == num1 && dat2 == num2 && dat3 == num3){ | |
2729 | |
2730 d=1; | |
2731 } | |
2732 | |
2733 else{ | |
2734 | |
2735 cnt=cnt-3; | |
2736 } | |
2737 | |
2738 } //end while | |
2739 | |
2740 | |
2741 fseek (text,0,SEEK_SET);//positionate the pointer at first | |
2742 | |
2743 cnt=cnt-7;//size is located 7 bytes before type | |
2744 for (d=1;d<=cnt;d++){ | |
2745 | |
2746 fread (&dat,sizeof(unsigned char),1,text); | |
2747 | |
2748 } | |
2749 fread (&dat1,sizeof(unsigned char),1,text); | |
2750 fread (&dat2,sizeof(unsigned char),1,text); | |
2751 fread (&dat3,sizeof(unsigned char),1,text); | |
2752 | |
2753 size = (dat<<24) | (dat1<<16) | (dat2<<8) | (dat3); | |
2754 | |
2755 for (i=1;i<=8;i++) { //advance sample_size | |
2756 fread (&dat,sizeof(unsigned char),1,text); | |
2757 } | |
2758 fread(&dat,1,1,text); | |
2759 fread(&dat1,1,1,text); | |
2760 fread(&dat2,1,1,text); | |
2761 fread(&dat3,1,1,text); | |
2762 | |
2763 *sal = (dat<<24) | (dat1<<16) | (dat2<<8) | (dat3); | |
2764 | |
2765 | |
2766 return size; | |
2767 | |
2768 } | |
2769 | |
2770 int samplecontainer_text(MovieBox *moov, int numtrack, int sizemdat,const char *textfiles,int totaltracks) { | |
2771 | |
2772 u32 sizeSTSD, sizeSTSZ, swap,i=0; | |
2773 u32 sizeSTTS; | |
2774 u32 sizeSTSC = 0; | |
2775 u32 sizeSTCO = 0; | |
2776 u32 sizeSTBL=0; | |
2777 int dat=0,dat1=0,dat2=0,dat3=0,sal=0, samplecount=0; | |
2778 | |
2779 //Sample Description Box// | |
2780 FILE *text; | |
2781 | |
2782 text=fopen ( textfiles,"rb"); | |
2783 fseek(text,0,SEEK_CUR); | |
2784 | |
2785 //stsd | |
2786 | |
2787 sizeSTSD =16+64; | |
2788 swap = bytereverse(sizeSTSD); | |
2789 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2790 SampleDescriptionBox.size = swap; | |
2791 swap = bytereverse('stsd'); | |
2792 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2793 SampleDescriptionBox.type = swap; | |
2794 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2795 SampleDescriptionBox.version = 0; | |
2796 swap = bytereverse(1); | |
2797 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2798 SampleDescriptionBox.entry_count = swap; | |
2799 | |
2800 | |
2801 //tx3g | |
2802 swap = bytereverse(64); | |
2803 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.size=swap; | |
2804 swap = bytereverse('tx3g'); | |
2805 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.type=swap; | |
2806 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.a=0; | |
2807 swap=bytereverse(1); | |
2808 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.b=swap; | |
2809 swap = bytereverse(0x00000800);//continuous karaoke | |
2810 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.displayFlags = swap; | |
2811 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.horizontaljustification=0x01; | |
2812 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.verticaljustification=0x01; | |
2813 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.backgroundcolorrgba[0]= 0x00; | |
2814 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.backgroundcolorrgba[1]= 0x00; | |
2815 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.backgroundcolorrgba[2]= 0x00; | |
2816 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.backgroundcolorrgba[3]= 0xFF; | |
2817 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.top=0; | |
2818 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.left=0; | |
2819 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.bottom=0x6400; | |
2820 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.right=0x2C01; | |
2821 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.startChar=0; | |
2822 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.endChar=0; | |
2823 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.fontID=0x0100; | |
2824 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.facestyleflags=0x01; | |
2825 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.fontsize=0x0A; | |
2826 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.textcolorrgba[0]=0xFF; | |
2827 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.textcolorrgba[1]=0xFF; | |
2828 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.textcolorrgba[2]=0xFF; | |
2829 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.textcolorrgba[3]=0xFF; | |
2830 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.size =0x12000000; | |
2831 swap =bytereverse('ftab'); | |
2832 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.type =swap; | |
2833 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.entrycount=0x0100; | |
2834 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.fontID =0x0200; | |
2835 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.fontnamelenght =0x05; | |
2836 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[0] =0x53; | |
2837 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[1] =0x65; | |
2838 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[2] =0x72; | |
2839 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[3] =0x69; | |
2840 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleDescriptionBox.TextSampleEntry.FontTableBox.font[4] =0x66; | |
2841 | |
2842 //stsz | |
2843 | |
2844 sizeSTSZ=aux(text,0x73,0x74,0x73,0x7A,&sal)+4; // the function aux looks for the box stsz in 3gp file and returns the size | |
2845 swap = bytereverse('stsz'); | |
2846 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2847 SampleSizeBox.type = swap; | |
2848 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2849 SampleSizeBox.version = 0; | |
2850 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleSizeBox.sample_size=0; | |
2851 | |
2852 fseek(text,0,SEEK_CUR); | |
2853 | |
2854 fread(&dat,1,1,text); //read sample_count | |
2855 fread(&dat1,1,1,text); | |
2856 fread(&dat2,1,1,text); | |
2857 fread(&dat3,1,1,text); | |
2858 | |
2859 samplecount = (dat<<24) | (dat1<<16) | (dat2<<8) | (dat3); | |
2860 | |
2861 swap= bytereverse(samplecount); | |
2862 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleSizeBox.sample_count=swap; | |
2863 | |
2864 for (i=1;i<=samplecount;i++){ | |
2865 | |
2866 swap = bytereverse(size_phrase[i-1]); | |
2867 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleSizeBox.entry_size[i-1]=swap; | |
2868 } | |
2869 | |
2870 sizeSTSZ= 20 + bytereverse(moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleSizeBox.sample_count)*4; | |
2871 swap = bytereverse(sizeSTSZ); | |
2872 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2873 SampleSizeBox.size = swap; | |
2874 | |
2875 | |
2876 //Time To Sample Box// | |
2877 | |
2878 fseek (text,0,SEEK_SET);//positionate the pointer at first | |
2879 sizeSTTS=aux(text,0x73,0x74,0x74,0x73,&sal); | |
2880 | |
2881 swap = bytereverse(sizeSTTS); | |
2882 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2883 TimeToSampleBox.size = swap; | |
2884 swap = bytereverse('stts'); | |
2885 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2886 TimeToSampleBox.type = swap; | |
2887 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2888 TimeToSampleBox.version = 0; | |
2889 swap = bytereverse(sal); | |
2890 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.TimeToSampleBox.entry_count=swap; | |
2891 fseek(text,0,SEEK_CUR); | |
2892 for(i=1;i<=sal;i++){ | |
2893 | |
2894 fread(&dat,1,1,text);//read count | |
2895 fread(&dat1,1,1,text); | |
2896 fread(&dat2,1,1,text); | |
2897 fread(&dat3,1,1,text); | |
2898 | |
2899 dat = (dat<<24) | (dat1<<16) | (dat2<<8) | (dat3); | |
2900 | |
2901 | |
2902 swap = bytereverse(dat); | |
2903 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.TimeToSampleBox.sample_count[i-1]=swap; | |
2904 fread(&dat,1,1,text);//read delta | |
2905 | |
2906 fread(&dat1,1,1,text); | |
2907 | |
2908 fread(&dat2,1,1,text); | |
2909 | |
2910 fread(&dat3,1,1,text); | |
2911 | |
2912 | |
2913 dat = (dat<<24) | (dat1<<16) | (dat2<<8) | (dat3); | |
2914 | |
2915 swap = bytereverse(dat/0.6);// the input text file has time_scale = 600 but the audio has time scale=1000 | |
2916 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.TimeToSampleBox.sample_delta[i-1]=swap; | |
2917 } | |
2918 | |
2919 //Sample To Chunk// | |
2920 | |
2921 dat=0; | |
2922 fseek (text,0,SEEK_SET);//positionate the pointer at first | |
2923 sizeSTSC = aux(text,0x73,0x74,0x73,0x63,&sal); | |
2924 dat=sal; | |
2925 swap = bytereverse(sizeSTSC); | |
2926 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2927 SampleToChunk.size = swap; | |
2928 swap = bytereverse('stsc'); | |
2929 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2930 SampleToChunk.type = swap; | |
2931 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2932 SampleToChunk.version = 0; | |
2933 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2934 SampleToChunk.entry_count = bytereverse(1); | |
2935 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleToChunk.first_chunk=bytereverse(1); | |
2936 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleToChunk.samples_per_chunk=moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleSizeBox.sample_count; | |
2937 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleToChunk.sample_description_index = bytereverse(1); | |
2938 | |
2939 //Chunk Offset Box// | |
2940 sizeSTCO=24; | |
2941 swap = bytereverse(sizeSTCO); | |
2942 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2943 ChunkOffsetBox.size = swap; | |
2944 swap = bytereverse('co64'); | |
2945 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2946 ChunkOffsetBox.type = swap; | |
2947 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2948 ChunkOffsetBox.version = 0; | |
2949 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2950 ChunkOffsetBox.entry_count = bytereverse(1); | |
2951 dat=32+sizemdat*totaltracks; | |
2952 swap=bytereverse(dat); | |
2953 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox. | |
2954 ChunkOffsetBox.chunk_offset [0]= swap; | |
2955 | |
2956 //Sample Table Box // | |
2957 sizeSTBL = 8 + sizeSTSD + sizeSTSZ + sizeSTSC + sizeSTCO + sizeSTTS; | |
2958 swap = bytereverse(sizeSTBL); | |
2959 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.size = swap; | |
2960 swap = bytereverse('stbl'); | |
2961 moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.type =swap; | |
2962 return sizeSTBL; | |
2963 } | |
2964 | |
2965 //AUX Functions for endianness | |
2966 | |
2967 int bytereverse(int num) { | |
2968 int swapped; | |
2969 swapped = ((num>>24)&0xff) | // move byte 3 to byte 0 | |
2970 ((num<<8)&0xff0000) | // move byte 1 to byte 2 | |
2971 ((num>>8)&0xff00) | // move byte 2 to byte 1 | |
2972 ((num<<24)&0xff000000); // byte 0 to byte 3 | |
2973 return swapped; | |
2974 } | |
2975 int bytereverse16(int num) { | |
2976 int swapped; | |
2977 swapped = ( ((num<<8)&0xff00) | // move byte 1 to byte 2 | |
2978 ((num>>8)&0x00ff) ); // byte 2 to byte 1 | |
2979 return swapped; | |
2980 } |