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
20 * $Id: rmff.c,v 1.7 2003/12/05 15:54:58 f1rmb Exp $
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 void rmff_dump_fileheader(rmff_fileheader_t *fileheader, char *buffer) {
40 if (!fileheader) return;
41 fileheader->object_id=BE_32(&fileheader->object_id);
42 fileheader->size=BE_32(&fileheader->size);
43 fileheader->object_version=BE_16(&fileheader->object_version);
44 fileheader->file_version=BE_32(&fileheader->file_version);
45 fileheader->num_headers=BE_32(&fileheader->num_headers);
47 memcpy(buffer, fileheader, 8);
48 memcpy(&buffer[8], &fileheader->object_version, 2);
49 memcpy(&buffer[10], &fileheader->file_version, 8);
51 fileheader->size=BE_32(&fileheader->size);
52 fileheader->object_version=BE_16(&fileheader->object_version);
53 fileheader->file_version=BE_32(&fileheader->file_version);
54 fileheader->num_headers=BE_32(&fileheader->num_headers);
55 fileheader->object_id=BE_32(&fileheader->object_id);
58 static void rmff_dump_prop(rmff_prop_t *prop, char *buffer) {
61 prop->object_id=BE_32(&prop->object_id);
62 prop->size=BE_32(&prop->size);
63 prop->object_version=BE_16(&prop->object_version);
64 prop->max_bit_rate=BE_32(&prop->max_bit_rate);
65 prop->avg_bit_rate=BE_32(&prop->avg_bit_rate);
66 prop->max_packet_size=BE_32(&prop->max_packet_size);
67 prop->avg_packet_size=BE_32(&prop->avg_packet_size);
68 prop->num_packets=BE_32(&prop->num_packets);
69 prop->duration=BE_32(&prop->duration);
70 prop->preroll=BE_32(&prop->preroll);
71 prop->index_offset=BE_32(&prop->index_offset);
72 prop->data_offset=BE_32(&prop->data_offset);
73 prop->num_streams=BE_16(&prop->num_streams);
74 prop->flags=BE_16(&prop->flags);
76 memcpy(buffer, prop, 8);
77 memcpy(&buffer[8], &prop->object_version, 2);
78 memcpy(&buffer[10], &prop->max_bit_rate, 36);
79 memcpy(&buffer[46], &prop->num_streams, 2);
80 memcpy(&buffer[48], &prop->flags, 2);
82 prop->size=BE_32(&prop->size);
83 prop->object_version=BE_16(&prop->object_version);
84 prop->max_bit_rate=BE_32(&prop->max_bit_rate);
85 prop->avg_bit_rate=BE_32(&prop->avg_bit_rate);
86 prop->max_packet_size=BE_32(&prop->max_packet_size);
87 prop->avg_packet_size=BE_32(&prop->avg_packet_size);
88 prop->num_packets=BE_32(&prop->num_packets);
89 prop->duration=BE_32(&prop->duration);
90 prop->preroll=BE_32(&prop->preroll);
91 prop->index_offset=BE_32(&prop->index_offset);
92 prop->data_offset=BE_32(&prop->data_offset);
93 prop->num_streams=BE_16(&prop->num_streams);
94 prop->flags=BE_16(&prop->flags);
95 prop->object_id=BE_32(&prop->object_id);
98 static void rmff_dump_mdpr(rmff_mdpr_t *mdpr, char *buffer) {
103 mdpr->object_id=BE_32(&mdpr->object_id);
104 mdpr->size=BE_32(&mdpr->size);
105 mdpr->object_version=BE_16(&mdpr->object_version);
106 mdpr->stream_number=BE_16(&mdpr->stream_number);
107 mdpr->max_bit_rate=BE_32(&mdpr->max_bit_rate);
108 mdpr->avg_bit_rate=BE_32(&mdpr->avg_bit_rate);
109 mdpr->max_packet_size=BE_32(&mdpr->max_packet_size);
110 mdpr->avg_packet_size=BE_32(&mdpr->avg_packet_size);
111 mdpr->start_time=BE_32(&mdpr->start_time);
112 mdpr->preroll=BE_32(&mdpr->preroll);
113 mdpr->duration=BE_32(&mdpr->duration);
115 memcpy(buffer, mdpr, 8);
116 memcpy(&buffer[8], &mdpr->object_version, 2);
117 memcpy(&buffer[10], &mdpr->stream_number, 2);
118 memcpy(&buffer[12], &mdpr->max_bit_rate, 28);
119 memcpy(&buffer[40], &mdpr->stream_name_size, 1);
120 s1=mdpr->stream_name_size;
121 memcpy(&buffer[41], mdpr->stream_name, s1);
123 memcpy(&buffer[41+s1], &mdpr->mime_type_size, 1);
124 s2=mdpr->mime_type_size;
125 memcpy(&buffer[42+s1], mdpr->mime_type, s2);
127 mdpr->type_specific_len=BE_32(&mdpr->type_specific_len);
128 memcpy(&buffer[42+s1+s2], &mdpr->type_specific_len, 4);
129 mdpr->type_specific_len=BE_32(&mdpr->type_specific_len);
130 s3=mdpr->type_specific_len;
131 memcpy(&buffer[46+s1+s2], mdpr->type_specific_data, s3);
133 mdpr->size=BE_32(&mdpr->size);
134 mdpr->stream_number=BE_16(&mdpr->stream_number);
135 mdpr->max_bit_rate=BE_32(&mdpr->max_bit_rate);
136 mdpr->avg_bit_rate=BE_32(&mdpr->avg_bit_rate);
137 mdpr->max_packet_size=BE_32(&mdpr->max_packet_size);
138 mdpr->avg_packet_size=BE_32(&mdpr->avg_packet_size);
139 mdpr->start_time=BE_32(&mdpr->start_time);
140 mdpr->preroll=BE_32(&mdpr->preroll);
141 mdpr->duration=BE_32(&mdpr->duration);
142 mdpr->object_id=BE_32(&mdpr->object_id);
146 static void rmff_dump_cont(rmff_cont_t *cont, char *buffer) {
151 cont->object_id=BE_32(&cont->object_id);
152 cont->size=BE_32(&cont->size);
153 cont->object_version=BE_16(&cont->object_version);
155 memcpy(buffer, cont, 8);
156 memcpy(&buffer[8], &cont->object_version, 2);
158 cont->title_len=BE_16(&cont->title_len);
159 memcpy(&buffer[10], &cont->title_len, 2);
160 cont->title_len=BE_16(&cont->title_len);
161 memcpy(&buffer[12], cont->title, cont->title_len);
162 p=12+cont->title_len;
164 cont->author_len=BE_16(&cont->author_len);
165 memcpy(&buffer[p], &cont->author_len, 2);
166 cont->author_len=BE_16(&cont->author_len);
167 memcpy(&buffer[p+2], cont->author, cont->author_len);
168 p+=2+cont->author_len;
170 cont->copyright_len=BE_16(&cont->copyright_len);
171 memcpy(&buffer[p], &cont->copyright_len, 2);
172 cont->copyright_len=BE_16(&cont->copyright_len);
173 memcpy(&buffer[p+2], cont->copyright, cont->copyright_len);
174 p+=2+cont->copyright_len;
176 cont->comment_len=BE_16(&cont->comment_len);
177 memcpy(&buffer[p], &cont->comment_len, 2);
178 cont->comment_len=BE_16(&cont->comment_len);
179 memcpy(&buffer[p+2], cont->comment, cont->comment_len);
181 cont->size=BE_32(&cont->size);
182 cont->object_version=BE_16(&cont->object_version);
183 cont->object_id=BE_32(&cont->object_id);
186 static void rmff_dump_dataheader(rmff_data_t *data, char *buffer) {
190 data->object_id=BE_32(&data->object_id);
191 data->size=BE_32(&data->size);
192 data->object_version=BE_16(&data->object_version);
193 data->num_packets=BE_32(&data->num_packets);
194 data->next_data_header=BE_32(&data->next_data_header);
196 memcpy(buffer, data, 8);
197 memcpy(&buffer[8], &data->object_version, 2);
198 memcpy(&buffer[10], &data->num_packets, 8);
200 data->num_packets=BE_32(&data->num_packets);
201 data->next_data_header=BE_32(&data->next_data_header);
202 data->size=BE_32(&data->size);
203 data->object_version=BE_16(&data->object_version);
204 data->object_id=BE_32(&data->object_id);
207 int rmff_dump_header(rmff_header_t *h, char *buffer, int max) {
210 rmff_mdpr_t **stream=h->streams;
212 rmff_dump_fileheader(h->fileheader, &buffer[written]);
213 written+=h->fileheader->size;
214 rmff_dump_prop(h->prop, &buffer[written]);
215 written+=h->prop->size;
216 rmff_dump_cont(h->cont, &buffer[written]);
217 written+=h->cont->size;
222 rmff_dump_mdpr(*stream, &buffer[written]);
223 written+=(*stream)->size;
228 rmff_dump_dataheader(h->data, &buffer[written]);
234 void rmff_dump_pheader(rmff_pheader_t *h, char *data) {
236 data[0]=(h->object_version>>8) & 0xff;
237 data[1]=h->object_version & 0xff;
238 data[2]=(h->length>>8) & 0xff;
239 data[3]=h->length & 0xff;
240 data[4]=(h->stream_number>>8) & 0xff;
241 data[5]=h->stream_number & 0xff;
242 data[6]=(h->timestamp>>24) & 0xff;
243 data[7]=(h->timestamp>>16) & 0xff;
244 data[8]=(h->timestamp>>8) & 0xff;
245 data[9]=h->timestamp & 0xff;
246 data[10]=h->reserved;
250 rmff_fileheader_t *rmff_new_fileheader(uint32_t num_headers) {
252 rmff_fileheader_t *fileheader = malloc(sizeof(rmff_fileheader_t));
253 if( !fileheader ) return NULL;
255 memset(fileheader, 0, sizeof(rmff_fileheader_t));
256 fileheader->object_id=RMF_TAG;
258 fileheader->object_version=0;
259 fileheader->file_version=0;
260 fileheader->num_headers=num_headers;
265 rmff_prop_t *rmff_new_prop (
266 uint32_t max_bit_rate,
267 uint32_t avg_bit_rate,
268 uint32_t max_packet_size,
269 uint32_t avg_packet_size,
270 uint32_t num_packets,
273 uint32_t index_offset,
274 uint32_t data_offset,
275 uint16_t num_streams,
278 rmff_prop_t *prop = malloc(sizeof(rmff_prop_t));
279 if( !prop ) return NULL;
281 memset(prop, 0, sizeof(rmff_prop_t));
282 prop->object_id=PROP_TAG;
284 prop->object_version=0;
285 prop->max_bit_rate=max_bit_rate;
286 prop->avg_bit_rate=avg_bit_rate;
287 prop->max_packet_size=max_packet_size;
288 prop->avg_packet_size=avg_packet_size;
289 prop->num_packets=num_packets;
290 prop->duration=duration;
291 prop->preroll=preroll;
292 prop->index_offset=index_offset;
293 prop->data_offset=data_offset;
294 prop->num_streams=num_streams;
300 rmff_mdpr_t *rmff_new_mdpr(
301 uint16_t stream_number,
302 uint32_t max_bit_rate,
303 uint32_t avg_bit_rate,
304 uint32_t max_packet_size,
305 uint32_t avg_packet_size,
309 const char *stream_name,
310 const char *mime_type,
311 uint32_t type_specific_len,
312 const char *type_specific_data ) {
314 rmff_mdpr_t *mdpr = malloc(sizeof(rmff_mdpr_t));
315 if( !mdpr ) return NULL;
317 memset(mdpr, 0, sizeof(rmff_mdpr_t));
318 mdpr->object_id=MDPR_TAG;
319 mdpr->object_version=0;
320 mdpr->stream_number=stream_number;
321 mdpr->max_bit_rate=max_bit_rate;
322 mdpr->avg_bit_rate=avg_bit_rate;
323 mdpr->max_packet_size=max_packet_size;
324 mdpr->avg_packet_size=avg_packet_size;
325 mdpr->start_time=start_time;
326 mdpr->preroll=preroll;
327 mdpr->duration=duration;
328 mdpr->stream_name_size=0;
330 mdpr->stream_name=strdup(stream_name);
331 mdpr->stream_name_size=strlen(stream_name);
333 mdpr->mime_type_size=0;
335 mdpr->mime_type=strdup(mime_type);
336 mdpr->mime_type_size=strlen(mime_type);
338 mdpr->type_specific_len=type_specific_len;
340 mdpr->type_specific_data = malloc(sizeof(char)*type_specific_len);
341 if( !mdpr->type_specific_data ) {
342 if( mdpr->stream_name ) free( mdpr->stream_name );
346 memcpy(mdpr->type_specific_data,type_specific_data,type_specific_len);
347 mdpr->mlti_data=NULL;
348 mdpr->size=mdpr->stream_name_size+mdpr->mime_type_size+mdpr->type_specific_len+46;
352 rmff_cont_t *rmff_new_cont(const char *title, const char *author, const char *copyright, const char *comment) {
354 rmff_cont_t *cont = malloc(sizeof(rmff_cont_t));
355 if( !cont ) return NULL;
357 memset(cont, 0, sizeof(rmff_cont_t));
358 cont->object_id=CONT_TAG;
359 cont->object_version=0;
362 cont->copyright=NULL;
366 cont->copyright_len=0;
370 cont->title_len=strlen(title);
371 cont->title=strdup(title);
375 cont->author_len=strlen(author);
376 cont->author=strdup(author);
379 cont->copyright_len=strlen(copyright);
380 cont->copyright=strdup(copyright);
383 cont->comment_len=strlen(comment);
384 cont->comment=strdup(comment);
386 cont->size=cont->title_len+cont->author_len+cont->copyright_len+cont->comment_len+18;
390 rmff_data_t *rmff_new_dataheader(uint32_t num_packets, uint32_t next_data_header) {
391 rmff_data_t *data = malloc(sizeof(rmff_data_t));
392 if( !data ) return NULL;
394 memset(data, 0, sizeof(rmff_data_t));
395 data->object_id=DATA_TAG;
397 data->object_version=0;
398 data->num_packets=num_packets;
399 data->next_data_header=next_data_header;
404 void rmff_print_header(rmff_header_t *h) {
405 rmff_mdpr_t **stream;
408 printf("rmff_print_header: NULL given\n");
413 printf("file version : %d\n", h->fileheader->file_version);
414 printf("number of headers : %d\n", h->fileheader->num_headers);
417 printf("\nCONTENT:\n");
418 printf("title : %s\n", h->cont->title);
419 printf("author : %s\n", h->cont->author);
420 printf("copyright : %s\n", h->cont->copyright);
421 printf("comment : %s\n", h->cont->comment);
424 printf("\nSTREAM PROPERTIES:\n");
425 printf("bit rate (max/avg) : %i/%i\n", h->prop->max_bit_rate, h->prop->avg_bit_rate);
426 printf("packet size (max/avg) : %i/%i bytes\n", h->prop->max_packet_size, h->prop->avg_packet_size);
427 printf("packets : %i\n", h->prop->num_packets);
428 printf("duration : %i ms\n", h->prop->duration);
429 printf("pre-buffer : %i ms\n", h->prop->preroll);
430 printf("index offset : %i bytes\n", h->prop->index_offset);
431 printf("data offset : %i bytes\n", h->prop->data_offset);
432 printf("media streams : %i\n", h->prop->num_streams);
434 if (h->prop->flags & PN_SAVE_ENABLED) printf("save_enabled ");
435 if (h->prop->flags & PN_PERFECT_PLAY_ENABLED) printf("perfect_play_enabled ");
436 if (h->prop->flags & PN_LIVE_BROADCAST) printf("live_broadcast ");
442 printf("\nSTREAM %i:\n", (*stream)->stream_number);
443 printf("stream name [mime type] : %s [%s]\n", (*stream)->stream_name, (*stream)->mime_type);
444 printf("bit rate (max/avg) : %i/%i\n", (*stream)->max_bit_rate, (*stream)->avg_bit_rate);
445 printf("packet size (max/avg) : %i/%i bytes\n", (*stream)->max_packet_size, (*stream)->avg_packet_size);
446 printf("start time : %i\n", (*stream)->start_time);
447 printf("pre-buffer : %i ms\n", (*stream)->preroll);
448 printf("duration : %i ms\n", (*stream)->duration);
449 printf("type specific data:\n");
455 printf("size : %i\n", h->data->size);
456 printf("packets : %i\n", h->data->num_packets);
457 printf("next DATA : 0x%08x\n", h->data->next_data_header);
461 void rmff_fix_header(rmff_header_t *h) {
463 unsigned int num_headers=0;
464 unsigned int header_size=0;
465 rmff_mdpr_t **streams;
469 lprintf("rmff_fix_header: fatal: no header given.\n");
473 lprintf("rmff_fix_header: warning: no MDPR chunks\n");
479 header_size+=(*streams)->size;
484 if (h->prop->size != 50) {
485 lprintf("rmff_fix_header: correcting prop.size from %i to %i\n", h->prop->size, 50);
488 if (h->prop->num_streams != num_streams) {
489 lprintf("rmff_fix_header: correcting prop.num_streams from %i to %i\n", h->prop->num_streams, num_streams);
490 h->prop->num_streams=num_streams;
494 } else lprintf("rmff_fix_header: warning: no PROP chunk.\n");
498 header_size+=h->cont->size;
499 } else lprintf("rmff_fix_header: warning: no CONT chunk.\n");
502 lprintf("rmff_fix_header: no DATA chunk, creating one\n");
503 h->data = malloc(sizeof(rmff_data_t));
505 memset(h->data, 0, sizeof(rmff_data_t));
506 h->data->object_id=DATA_TAG;
507 h->data->object_version=0;
509 h->data->num_packets=0;
510 h->data->next_data_header=0;
515 if (!h->fileheader) {
516 lprintf("rmff_fix_header: no fileheader, creating one");
517 h->fileheader = malloc(sizeof(rmff_fileheader_t));
518 if( h->fileheader ) {
519 memset(h->fileheader, 0, sizeof(rmff_fileheader_t));
520 h->fileheader->object_id=RMF_TAG;
521 h->fileheader->size=34;
522 h->fileheader->object_version=0;
523 h->fileheader->file_version=0;
524 h->fileheader->num_headers=num_headers+1;
527 header_size+=h->fileheader->size;
530 if(h->fileheader->num_headers != num_headers) {
531 lprintf("rmff_fix_header: setting num_headers from %i to %i\n", h->fileheader->num_headers, num_headers);
532 h->fileheader->num_headers=num_headers;
535 if (h->prop->data_offset != header_size) {
536 lprintf("rmff_fix_header: setting prop.data_offset from %i to %i\n", h->prop->data_offset, header_size);
537 h->prop->data_offset=header_size;
539 if (h->prop->num_packets == 0) {
540 int p=(int)(h->prop->avg_bit_rate/8.0*(h->prop->duration/1000.0)/h->prop->avg_packet_size);
541 lprintf("rmff_fix_header: assuming prop.num_packets=%i\n", p);
542 h->prop->num_packets=p;
544 if (h->data->num_packets == 0) {
545 lprintf("rmff_fix_header: assuming data.num_packets=%i\n", h->prop->num_packets);
546 h->data->num_packets=h->prop->num_packets;
548 lprintf("rmff_fix_header: assuming data.size=%i\n", h->prop->num_packets*h->prop->avg_packet_size);
549 h->data->size=h->prop->num_packets*h->prop->avg_packet_size;
553 int rmff_get_header_size(rmff_header_t *h) {
555 if (!h->prop) return -1;
556 return h->prop->data_offset+18;
559 void rmff_free_header(rmff_header_t *h)
563 if (h->fileheader) free(h->fileheader);
564 if (h->prop) free(h->prop);
565 if (h->data) free(h->data);
567 free(h->cont->title);
568 free(h->cont->author);
569 free(h->cont->copyright);
570 free(h->cont->comment);
574 rmff_mdpr_t **s=h->streams;
577 free((*s)->stream_name);
578 free((*s)->mime_type);
579 free((*s)->type_specific_data);