2 * Copyright (C) 2002-2003 the xine project
4 * This file is part of xine, a free video player.
6 * xine is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * xine is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
22 * functions for real media file format
23 * adopted from joschkas real tools
28 #define BE_16(x) ((((uint8_t*)(x))[0] << 8) | ((uint8_t*)(x))[1])
29 #define BE_32(x) ((((uint8_t*)(x))[0] << 24) | \
30 (((uint8_t*)(x))[1] << 16) | \
31 (((uint8_t*)(x))[2] << 8) | \
35 * writes header data to a buffer
38 static int rmff_dump_fileheader(rmff_fileheader_t *fileheader, uint8_t *buffer, int bufsize) {
39 if (!fileheader) return 0;
40 if (bufsize < RMFF_FILEHEADER_SIZE)
43 fileheader->object_id=BE_32(&fileheader->object_id);
44 fileheader->size=BE_32(&fileheader->size);
45 fileheader->object_version=BE_16(&fileheader->object_version);
46 fileheader->file_version=BE_32(&fileheader->file_version);
47 fileheader->num_headers=BE_32(&fileheader->num_headers);
49 memcpy(buffer, fileheader, 8);
50 memcpy(&buffer[8], &fileheader->object_version, 2);
51 memcpy(&buffer[10], &fileheader->file_version, 8);
53 fileheader->size=BE_32(&fileheader->size);
54 fileheader->object_version=BE_16(&fileheader->object_version);
55 fileheader->file_version=BE_32(&fileheader->file_version);
56 fileheader->num_headers=BE_32(&fileheader->num_headers);
57 fileheader->object_id=BE_32(&fileheader->object_id);
59 return RMFF_FILEHEADER_SIZE;
62 static int rmff_dump_prop(rmff_prop_t *prop, uint8_t *buffer, int bufsize) {
66 if (bufsize < RMFF_PROPHEADER_SIZE)
69 prop->object_id=BE_32(&prop->object_id);
70 prop->size=BE_32(&prop->size);
71 prop->object_version=BE_16(&prop->object_version);
72 prop->max_bit_rate=BE_32(&prop->max_bit_rate);
73 prop->avg_bit_rate=BE_32(&prop->avg_bit_rate);
74 prop->max_packet_size=BE_32(&prop->max_packet_size);
75 prop->avg_packet_size=BE_32(&prop->avg_packet_size);
76 prop->num_packets=BE_32(&prop->num_packets);
77 prop->duration=BE_32(&prop->duration);
78 prop->preroll=BE_32(&prop->preroll);
79 prop->index_offset=BE_32(&prop->index_offset);
80 prop->data_offset=BE_32(&prop->data_offset);
81 prop->num_streams=BE_16(&prop->num_streams);
82 prop->flags=BE_16(&prop->flags);
84 memcpy(buffer, prop, 8);
85 memcpy(&buffer[8], &prop->object_version, 2);
86 memcpy(&buffer[10], &prop->max_bit_rate, 36);
87 memcpy(&buffer[46], &prop->num_streams, 2);
88 memcpy(&buffer[48], &prop->flags, 2);
90 prop->size=BE_32(&prop->size);
91 prop->object_version=BE_16(&prop->object_version);
92 prop->max_bit_rate=BE_32(&prop->max_bit_rate);
93 prop->avg_bit_rate=BE_32(&prop->avg_bit_rate);
94 prop->max_packet_size=BE_32(&prop->max_packet_size);
95 prop->avg_packet_size=BE_32(&prop->avg_packet_size);
96 prop->num_packets=BE_32(&prop->num_packets);
97 prop->duration=BE_32(&prop->duration);
98 prop->preroll=BE_32(&prop->preroll);
99 prop->index_offset=BE_32(&prop->index_offset);
100 prop->data_offset=BE_32(&prop->data_offset);
101 prop->num_streams=BE_16(&prop->num_streams);
102 prop->flags=BE_16(&prop->flags);
103 prop->object_id=BE_32(&prop->object_id);
105 return RMFF_PROPHEADER_SIZE;
108 static int rmff_dump_mdpr(rmff_mdpr_t *mdpr, uint8_t *buffer, unsigned int bufsize) {
113 if (bufsize < RMFF_MDPRHEADER_SIZE + mdpr->type_specific_len +
114 mdpr->stream_name_size + mdpr->mime_type_size)
117 mdpr->object_id=BE_32(&mdpr->object_id);
118 mdpr->size=BE_32(&mdpr->size);
119 mdpr->object_version=BE_16(&mdpr->object_version);
120 mdpr->stream_number=BE_16(&mdpr->stream_number);
121 mdpr->max_bit_rate=BE_32(&mdpr->max_bit_rate);
122 mdpr->avg_bit_rate=BE_32(&mdpr->avg_bit_rate);
123 mdpr->max_packet_size=BE_32(&mdpr->max_packet_size);
124 mdpr->avg_packet_size=BE_32(&mdpr->avg_packet_size);
125 mdpr->start_time=BE_32(&mdpr->start_time);
126 mdpr->preroll=BE_32(&mdpr->preroll);
127 mdpr->duration=BE_32(&mdpr->duration);
129 memcpy(buffer, mdpr, 8);
130 memcpy(&buffer[8], &mdpr->object_version, 2);
131 memcpy(&buffer[10], &mdpr->stream_number, 2);
132 memcpy(&buffer[12], &mdpr->max_bit_rate, 28);
133 memcpy(&buffer[40], &mdpr->stream_name_size, 1);
134 s1=mdpr->stream_name_size;
135 memcpy(&buffer[41], mdpr->stream_name, s1);
137 memcpy(&buffer[41+s1], &mdpr->mime_type_size, 1);
138 s2=mdpr->mime_type_size;
139 memcpy(&buffer[42+s1], mdpr->mime_type, s2);
141 mdpr->type_specific_len=BE_32(&mdpr->type_specific_len);
142 memcpy(&buffer[42+s1+s2], &mdpr->type_specific_len, 4);
143 mdpr->type_specific_len=BE_32(&mdpr->type_specific_len);
144 s3=mdpr->type_specific_len;
145 memcpy(&buffer[46+s1+s2], mdpr->type_specific_data, s3);
147 mdpr->size=BE_32(&mdpr->size);
148 mdpr->stream_number=BE_16(&mdpr->stream_number);
149 mdpr->max_bit_rate=BE_32(&mdpr->max_bit_rate);
150 mdpr->avg_bit_rate=BE_32(&mdpr->avg_bit_rate);
151 mdpr->max_packet_size=BE_32(&mdpr->max_packet_size);
152 mdpr->avg_packet_size=BE_32(&mdpr->avg_packet_size);
153 mdpr->start_time=BE_32(&mdpr->start_time);
154 mdpr->preroll=BE_32(&mdpr->preroll);
155 mdpr->duration=BE_32(&mdpr->duration);
156 mdpr->object_id=BE_32(&mdpr->object_id);
158 return RMFF_MDPRHEADER_SIZE + s1 + s2 + s3;
161 static int rmff_dump_cont(rmff_cont_t *cont, uint8_t *buffer, int bufsize) {
167 if (bufsize < RMFF_CONTHEADER_SIZE + cont->title_len + cont->author_len + \
168 cont->copyright_len + cont->comment_len)
171 cont->object_id=BE_32(&cont->object_id);
172 cont->size=BE_32(&cont->size);
173 cont->object_version=BE_16(&cont->object_version);
175 memcpy(buffer, cont, 8);
176 memcpy(&buffer[8], &cont->object_version, 2);
178 cont->title_len=BE_16(&cont->title_len);
179 memcpy(&buffer[10], &cont->title_len, 2);
180 cont->title_len=BE_16(&cont->title_len);
181 memcpy(&buffer[12], cont->title, cont->title_len);
182 p=12+cont->title_len;
184 cont->author_len=BE_16(&cont->author_len);
185 memcpy(&buffer[p], &cont->author_len, 2);
186 cont->author_len=BE_16(&cont->author_len);
187 memcpy(&buffer[p+2], cont->author, cont->author_len);
188 p+=2+cont->author_len;
190 cont->copyright_len=BE_16(&cont->copyright_len);
191 memcpy(&buffer[p], &cont->copyright_len, 2);
192 cont->copyright_len=BE_16(&cont->copyright_len);
193 memcpy(&buffer[p+2], cont->copyright, cont->copyright_len);
194 p+=2+cont->copyright_len;
196 cont->comment_len=BE_16(&cont->comment_len);
197 memcpy(&buffer[p], &cont->comment_len, 2);
198 cont->comment_len=BE_16(&cont->comment_len);
199 memcpy(&buffer[p+2], cont->comment, cont->comment_len);
201 cont->size=BE_32(&cont->size);
202 cont->object_version=BE_16(&cont->object_version);
203 cont->object_id=BE_32(&cont->object_id);
205 return RMFF_CONTHEADER_SIZE + cont->title_len + cont->author_len + \
206 cont->copyright_len + cont->comment_len;
209 static int rmff_dump_dataheader(rmff_data_t *data, uint8_t *buffer, int bufsize) {
213 if (bufsize < RMFF_DATAHEADER_SIZE)
217 data->object_id=BE_32(&data->object_id);
218 data->size=BE_32(&data->size);
219 data->object_version=BE_16(&data->object_version);
220 data->num_packets=BE_32(&data->num_packets);
221 data->next_data_header=BE_32(&data->next_data_header);
223 memcpy(buffer, data, 8);
224 memcpy(&buffer[8], &data->object_version, 2);
225 memcpy(&buffer[10], &data->num_packets, 8);
227 data->num_packets=BE_32(&data->num_packets);
228 data->next_data_header=BE_32(&data->next_data_header);
229 data->size=BE_32(&data->size);
230 data->object_version=BE_16(&data->object_version);
231 data->object_id=BE_32(&data->object_id);
233 return RMFF_DATAHEADER_SIZE;
236 int rmff_dump_header(rmff_header_t *h, void *buf_gen, int max) {
237 uint8_t *buffer = buf_gen;
240 rmff_mdpr_t **stream=h->streams;
242 if ((size=rmff_dump_fileheader(h->fileheader, &buffer[written], max)) < 0)
248 if ((size=rmff_dump_prop(h->prop, &buffer[written], max)) < 0)
254 if ((size=rmff_dump_cont(h->cont, &buffer[written], max)) < 0)
262 if ((size=rmff_dump_mdpr(*stream, &buffer[written], max)) < 0)
270 if ((size=rmff_dump_dataheader(h->data, &buffer[written], max)) < 0)
278 void rmff_dump_pheader(rmff_pheader_t *h, char *data) {
280 data[0]=(h->object_version>>8) & 0xff;
281 data[1]=h->object_version & 0xff;
282 data[2]=(h->length>>8) & 0xff;
283 data[3]=h->length & 0xff;
284 data[4]=(h->stream_number>>8) & 0xff;
285 data[5]=h->stream_number & 0xff;
286 data[6]=(h->timestamp>>24) & 0xff;
287 data[7]=(h->timestamp>>16) & 0xff;
288 data[8]=(h->timestamp>>8) & 0xff;
289 data[9]=h->timestamp & 0xff;
290 data[10]=h->reserved;
294 rmff_fileheader_t *rmff_new_fileheader(uint32_t num_headers) {
296 rmff_fileheader_t *fileheader = calloc( 1, sizeof(rmff_fileheader_t) );
300 fileheader->object_id=RMF_TAG;
302 fileheader->object_version=0;
303 fileheader->file_version=0;
304 fileheader->num_headers=num_headers;
309 rmff_prop_t *rmff_new_prop (
310 uint32_t max_bit_rate,
311 uint32_t avg_bit_rate,
312 uint32_t max_packet_size,
313 uint32_t avg_packet_size,
314 uint32_t num_packets,
317 uint32_t index_offset,
318 uint32_t data_offset,
319 uint16_t num_streams,
322 rmff_prop_t *prop = calloc( 1, sizeof(rmff_prop_t) );
326 prop->object_id=PROP_TAG;
328 prop->object_version=0;
329 prop->max_bit_rate=max_bit_rate;
330 prop->avg_bit_rate=avg_bit_rate;
331 prop->max_packet_size=max_packet_size;
332 prop->avg_packet_size=avg_packet_size;
333 prop->num_packets=num_packets;
334 prop->duration=duration;
335 prop->preroll=preroll;
336 prop->index_offset=index_offset;
337 prop->data_offset=data_offset;
338 prop->num_streams=num_streams;
344 rmff_mdpr_t *rmff_new_mdpr(
345 uint16_t stream_number,
346 uint32_t max_bit_rate,
347 uint32_t avg_bit_rate,
348 uint32_t max_packet_size,
349 uint32_t avg_packet_size,
353 const char *stream_name,
354 const char *mime_type,
355 uint32_t type_specific_len,
356 const char *type_specific_data ) {
358 rmff_mdpr_t *mdpr = calloc( 1, sizeof(rmff_mdpr_t) );
362 mdpr->object_id=MDPR_TAG;
363 mdpr->object_version=0;
364 mdpr->stream_number=stream_number;
365 mdpr->max_bit_rate=max_bit_rate;
366 mdpr->avg_bit_rate=avg_bit_rate;
367 mdpr->max_packet_size=max_packet_size;
368 mdpr->avg_packet_size=avg_packet_size;
369 mdpr->start_time=start_time;
370 mdpr->preroll=preroll;
371 mdpr->duration=duration;
372 mdpr->stream_name_size=0;
374 mdpr->stream_name=strdup(stream_name);
375 mdpr->stream_name_size=strlen(stream_name);
377 mdpr->mime_type_size=0;
379 mdpr->mime_type=strdup(mime_type);
380 mdpr->mime_type_size=strlen(mime_type);
382 mdpr->type_specific_len=type_specific_len;
384 mdpr->type_specific_data = malloc(type_specific_len);
385 if( !mdpr->type_specific_data ) {
386 free( mdpr->stream_name );
390 memcpy(mdpr->type_specific_data,type_specific_data,type_specific_len);
391 mdpr->mlti_data=NULL;
392 mdpr->size=mdpr->stream_name_size+mdpr->mime_type_size+mdpr->type_specific_len+46;
396 rmff_cont_t *rmff_new_cont(const char *title, const char *author, const char *copyright, const char *comment) {
398 rmff_cont_t *cont = calloc( 1, sizeof(rmff_cont_t) );
402 cont->object_id=CONT_TAG;
403 cont->object_version=0;
406 cont->copyright=NULL;
410 cont->copyright_len=0;
414 cont->title_len=strlen(title);
415 cont->title=strdup(title);
419 cont->author_len=strlen(author);
420 cont->author=strdup(author);
423 cont->copyright_len=strlen(copyright);
424 cont->copyright=strdup(copyright);
427 cont->comment_len=strlen(comment);
428 cont->comment=strdup(comment);
430 cont->size=cont->title_len+cont->author_len+cont->copyright_len+cont->comment_len+18;
434 rmff_data_t *rmff_new_dataheader(uint32_t num_packets, uint32_t next_data_header) {
435 rmff_data_t *data = calloc( 1, sizeof(rmff_data_t) );
439 data->object_id=DATA_TAG;
441 data->object_version=0;
442 data->num_packets=num_packets;
443 data->next_data_header=next_data_header;
448 void rmff_print_header(rmff_header_t *h) {
449 rmff_mdpr_t **stream;
452 printf("rmff_print_header: NULL given\n");
458 printf("file version : %d\n", h->fileheader->file_version);
459 printf("number of headers : %d\n", h->fileheader->num_headers);
463 printf("\nCONTENT:\n");
464 printf("title : %s\n", h->cont->title);
465 printf("author : %s\n", h->cont->author);
466 printf("copyright : %s\n", h->cont->copyright);
467 printf("comment : %s\n", h->cont->comment);
471 printf("\nSTREAM PROPERTIES:\n");
472 printf("bit rate (max/avg) : %i/%i\n", h->prop->max_bit_rate, h->prop->avg_bit_rate);
473 printf("packet size (max/avg) : %i/%i bytes\n", h->prop->max_packet_size, h->prop->avg_packet_size);
474 printf("packets : %i\n", h->prop->num_packets);
475 printf("duration : %i ms\n", h->prop->duration);
476 printf("pre-buffer : %i ms\n", h->prop->preroll);
477 printf("index offset : %i bytes\n", h->prop->index_offset);
478 printf("data offset : %i bytes\n", h->prop->data_offset);
479 printf("media streams : %i\n", h->prop->num_streams);
481 if (h->prop->flags & PN_SAVE_ENABLED) printf("save_enabled ");
482 if (h->prop->flags & PN_PERFECT_PLAY_ENABLED) printf("perfect_play_enabled ");
483 if (h->prop->flags & PN_LIVE_BROADCAST) printf("live_broadcast ");
491 printf("\nSTREAM %i:\n", (*stream)->stream_number);
492 printf("stream name [mime type] : %s [%s]\n", (*stream)->stream_name, (*stream)->mime_type);
493 printf("bit rate (max/avg) : %i/%i\n", (*stream)->max_bit_rate, (*stream)->avg_bit_rate);
494 printf("packet size (max/avg) : %i/%i bytes\n", (*stream)->max_packet_size, (*stream)->avg_packet_size);
495 printf("start time : %i\n", (*stream)->start_time);
496 printf("pre-buffer : %i ms\n", (*stream)->preroll);
497 printf("duration : %i ms\n", (*stream)->duration);
498 printf("type specific data:\n");
505 printf("size : %i\n", h->data->size);
506 printf("packets : %i\n", h->data->num_packets);
507 printf("next DATA : 0x%08x\n", h->data->next_data_header);
511 void rmff_fix_header(rmff_header_t *h) {
513 unsigned int num_headers=0;
514 unsigned int header_size=0;
515 rmff_mdpr_t **streams;
519 lprintf("rmff_fix_header: fatal: no header given.\n");
523 lprintf("rmff_fix_header: warning: no MDPR chunks\n");
531 header_size+=(*streams)->size;
536 if (h->prop->size != 50)
538 lprintf("rmff_fix_header: correcting prop.size from %i to %i\n", h->prop->size, 50);
541 if (h->prop->num_streams != num_streams)
543 lprintf("rmff_fix_header: correcting prop.num_streams from %i to %i\n", h->prop->num_streams, num_streams);
544 h->prop->num_streams=num_streams;
549 lprintf("rmff_fix_header: warning: no PROP chunk.\n");
553 header_size+=h->cont->size;
555 lprintf("rmff_fix_header: warning: no CONT chunk.\n");
558 lprintf("rmff_fix_header: no DATA chunk, creating one\n");
559 h->data = calloc( 1, sizeof(rmff_data_t) );
562 h->data->object_id=DATA_TAG;
563 h->data->object_version=0;
565 h->data->num_packets=0;
566 h->data->next_data_header=0;
571 if (!h->fileheader) {
572 lprintf("rmff_fix_header: no fileheader, creating one");
573 h->fileheader = calloc( 1, sizeof(rmff_fileheader_t) );
576 h->fileheader->object_id=RMF_TAG;
577 h->fileheader->size=18;
578 h->fileheader->object_version=0;
579 h->fileheader->file_version=0;
580 h->fileheader->num_headers=num_headers+1;
583 header_size+=h->fileheader->size;
586 if(h->fileheader->num_headers != num_headers) {
587 lprintf("rmff_fix_header: setting num_headers from %i to %i\n", h->fileheader->num_headers, num_headers);
588 h->fileheader->num_headers=num_headers;
591 if (h->prop->data_offset != header_size) {
592 lprintf("rmff_fix_header: setting prop.data_offset from %i to %i\n", h->prop->data_offset, header_size);
593 h->prop->data_offset=header_size;
596 /* FIXME: I doubt this is right to do this here.
597 * It should belong to the demux. */
598 if (h->prop->num_packets == 0) {
599 int p=(int)(h->prop->avg_bit_rate/8.0*(h->prop->duration/1000.0)/h->prop->avg_packet_size);
600 lprintf("rmff_fix_header: assuming prop.num_packets=%i\n", p);
601 h->prop->num_packets=p;
603 if (h->data->num_packets == 0) {
604 lprintf("rmff_fix_header: assuming data.num_packets=%i\n", h->prop->num_packets);
605 h->data->num_packets=h->prop->num_packets;
607 if (h->data->size == 18 || !h->data->size ) {
608 lprintf("rmff_fix_header: assuming data.size=%i\n", h->prop->num_packets*h->prop->avg_packet_size);
609 h->data->size+=h->prop->num_packets*h->prop->avg_packet_size;
614 int rmff_get_header_size(rmff_header_t *h) {
616 if (!h->prop) return -1;
617 return h->prop->data_offset+18;
620 void rmff_free_header(rmff_header_t *h)
624 free( h->fileheader );
628 free( h->cont->title );
629 free( h->cont->author );
630 free( h->cont->copyright );
631 free( h->cont->comment );
636 rmff_mdpr_t **s=h->streams;
639 free((*s)->stream_name);
640 free((*s)->mime_type);
641 free((*s)->type_specific_data);