开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
real_rmff.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：19k
源码类别：

midi

开发平台：

Unix_Linux

real_rmff.c：源码内容
  1. /*
  2.  * Copyright (C) 2002-2003 the xine project
  3.  *
  4.  * This file is part of xine, a free video player.
  5.  *
  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.
  10.  *
  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.
  15.  *
  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
  19.  *
  20.  * $Id: 14e4ec4d0df318dcd200f28ecc648588d48b7024 $
  21.  *
  22.  * functions for real media file format
  23.  * adopted from joschkas real tools
  24.  */
  26. #include "real.h"
  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) | 
  32.                     ((uint8_t*)(x))[3])
  34. /*
  35.  * writes header data to a buffer
  36.  */
  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)
  41.         return -1;
  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;
  60. }
  62. static int rmff_dump_prop(rmff_prop_t *prop, uint8_t *buffer, int bufsize) {
  64.     if (!prop) return 0;
  65.     
  66.     if (bufsize < RMFF_PROPHEADER_SIZE)
  67.         return -1;
  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;
  106. }
  108. static int rmff_dump_mdpr(rmff_mdpr_t *mdpr, uint8_t *buffer, unsigned int bufsize) {
  110.     int s1, s2, s3;
  112.     if (!mdpr) return 0;
  113.     if (bufsize < RMFF_MDPRHEADER_SIZE + mdpr->type_specific_len +
  114.             mdpr->stream_name_size + mdpr->mime_type_size)
  115.     return -1;
  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;
  159. }
  161. static int rmff_dump_cont(rmff_cont_t *cont, uint8_t *buffer, int bufsize) {
  163.     int p;
  165.     if (!cont) return 0;
  166.     
  167.     if (bufsize < RMFF_CONTHEADER_SIZE + cont->title_len + cont->author_len + 
  168.             cont->copyright_len + cont->comment_len)
  169.         return -1;
  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;
  207. }
  209. static int rmff_dump_dataheader(rmff_data_t *data, uint8_t *buffer, int bufsize) {
  211.   if (!data) return 0;
  212.   
  213.   if (bufsize < RMFF_DATAHEADER_SIZE)
  214.       return -1;
  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;
  234. }
  236. int rmff_dump_header(rmff_header_t *h, void *buf_gen, int max) {
  237.     uint8_t *buffer = buf_gen;
  239.     int written=0, size;
  240.     rmff_mdpr_t **stream=h->streams;
  242.     if ((size=rmff_dump_fileheader(h->fileheader, &buffer[written], max)) < 0)
  243.         return -1;
  244.     
  245.     written += size;
  246.     max -= size;
  248.     if ((size=rmff_dump_prop(h->prop, &buffer[written], max)) < 0)
  249.         return -1;
  250.     
  251.     written += size;
  252.     max -= size;
  254.     if ((size=rmff_dump_cont(h->cont, &buffer[written], max)) < 0)
  255.         return -1;
  257.     written += size;
  258.     max -= size;
  260.     if (stream) {
  261.         while(*stream) {
  262.             if ((size=rmff_dump_mdpr(*stream, &buffer[written], max)) < 0)
  263.                 return -1;
  264.             written += size;
  265.             max -= size;
  266.             stream++;
  267.         }
  268.     }
  270.     if ((size=rmff_dump_dataheader(h->data, &buffer[written], max)) < 0)
  271.         return -1;
  272.     
  273.     written+=size;
  275.     return written;
  276. }
  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;
  291.   data[11]=h->flags;
  292. }
  294. rmff_fileheader_t *rmff_new_fileheader(uint32_t num_headers) {
  296.   rmff_fileheader_t *fileheader = calloc( 1, sizeof(rmff_fileheader_t) );
  297.   if( !fileheader )
  298.     return NULL;
  300.   fileheader->object_id=RMF_TAG;
  301.   fileheader->size=18;
  302.   fileheader->object_version=0;
  303.   fileheader->file_version=0;
  304.   fileheader->num_headers=num_headers;
  306.   return fileheader;
  307. }
  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,
  315.   uint32_t duration,
  316.   uint32_t preroll,
  317.   uint32_t index_offset,
  318.   uint32_t data_offset,
  319.   uint16_t num_streams,
  320.   uint16_t flags ) {
  322.   rmff_prop_t *prop = calloc( 1, sizeof(rmff_prop_t) );
  323.   if( !prop )
  324.     return NULL;
  326.   prop->object_id=PROP_TAG;
  327.   prop->size=50;
  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;
  339.   prop->flags=flags;
  341.   return prop;
  342. }
  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,
  350.   uint32_t   start_time,
  351.   uint32_t   preroll,
  352.   uint32_t   duration,
  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) );
  359.   if( !mdpr )
  360.     return NULL;
  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;
  373.   if (stream_name) {
  374.     mdpr->stream_name=strdup(stream_name);
  375.     mdpr->stream_name_size=strlen(stream_name);
  376.   }
  377.   mdpr->mime_type_size=0;
  378.   if (mime_type) {
  379.     mdpr->mime_type=strdup(mime_type);
  380.     mdpr->mime_type_size=strlen(mime_type);
  381.   }
  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 );
  387.     free( mdpr );
  388.     return NULL;
  389.   }
  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;
  393.   return mdpr;
  394. }
  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) );
  399.   if( !cont )
  400.     return NULL;
  402.   cont->object_id=CONT_TAG;
  403.   cont->object_version=0;
  404.   cont->title=NULL;
  405.   cont->author=NULL;
  406.   cont->copyright=NULL;
  407.   cont->comment=NULL;
  408.   cont->title_len=0;
  409.   cont->author_len=0;
  410.   cont->copyright_len=0;
  411.   cont->comment_len=0;
  413.   if (title) {
  414.     cont->title_len=strlen(title);
  415.     cont->title=strdup(title);
  416.   }
  417.   if (author)
  418.   {
  419.     cont->author_len=strlen(author);
  420.     cont->author=strdup(author);
  421.   }
  422.   if (copyright) {
  423.     cont->copyright_len=strlen(copyright);
  424.     cont->copyright=strdup(copyright);
  425.   }
  426.   if (comment) {
  427.     cont->comment_len=strlen(comment);
  428.     cont->comment=strdup(comment);
  429.   }
  430.   cont->size=cont->title_len+cont->author_len+cont->copyright_len+cont->comment_len+18;
  431.   return cont;
  432. }
  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) );
  436.   if( !data )
  437.     return NULL;
  439.   data->object_id=DATA_TAG;
  440.   data->size=18;
  441.   data->object_version=0;
  442.   data->num_packets=num_packets;
  443.   data->next_data_header=next_data_header;
  445.   return data;
  446. }
  448. void rmff_print_header(rmff_header_t *h) {
  449.   rmff_mdpr_t **stream;
  451.   if(!h) {
  452.     printf("rmff_print_header: NULL givenn");
  453.     return;
  454.   }
  455.   if(h->fileheader)
  456.   {
  457.     printf("nFILE:n");
  458.     printf("file version      : %dn", h->fileheader->file_version);
  459.     printf("number of headers : %dn", h->fileheader->num_headers);
  460.   }
  461.   if(h->cont)
  462.   {
  463.     printf("nCONTENT:n");
  464.     printf("title     : %sn", h->cont->title);
  465.     printf("author    : %sn", h->cont->author);
  466.     printf("copyright : %sn", h->cont->copyright);
  467.     printf("comment   : %sn", h->cont->comment);
  468.   }
  469.   if(h->prop)
  470.   {
  471.     printf("nSTREAM PROPERTIES:n");
  472.     printf("bit rate (max/avg)    : %i/%in", h->prop->max_bit_rate, h->prop->avg_bit_rate);
  473.     printf("packet size (max/avg) : %i/%i bytesn", h->prop->max_packet_size, h->prop->avg_packet_size);
  474.     printf("packets       : %in", h->prop->num_packets);
  475.     printf("duration      : %i msn", h->prop->duration);
  476.     printf("pre-buffer    : %i msn", h->prop->preroll);
  477.     printf("index offset  : %i bytesn", h->prop->index_offset);
  478.     printf("data offset   : %i bytesn", h->prop->data_offset);
  479.     printf("media streams : %in", h->prop->num_streams);
  480.     printf("flags         : ");
  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 ");
  484.     printf("n");
  485.   }
  486.   stream=h->streams;
  487.   if(stream)
  488.   {
  489.     while (*stream)
  490.     {
  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/%in", (*stream)->max_bit_rate, (*stream)->avg_bit_rate);
  494.       printf("packet size (max/avg)   : %i/%i bytesn", (*stream)->max_packet_size, (*stream)->avg_packet_size);
  495.       printf("start time : %in", (*stream)->start_time);
  496.       printf("pre-buffer : %i msn", (*stream)->preroll);
  497.       printf("duration   : %i msn", (*stream)->duration);
  498.       printf("type specific data:n");
  499.       stream++;
  500.     }
  501.   }
  502.   if(h->data)
  503.   {
  504.     printf("nDATA:n");
  505.     printf("size      : %in", h->data->size);
  506.     printf("packets   : %in", h->data->num_packets);
  507.     printf("next DATA : 0x%08xn", h->data->next_data_header);
  508.   }
  509. }
  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;
  516.   int num_streams=0;
  518.   if (!h) {
  519.     lprintf("rmff_fix_header: fatal: no header given.n");
  520.     return;
  521.   }
  522.   if (!h->streams) {
  523.     lprintf("rmff_fix_header: warning: no MDPR chunksn");
  524.   } else
  525.   {
  526.     streams=h->streams;
  527.     while (*streams)
  528.     {
  529.         num_streams++;
  530.         num_headers++;
  531.         header_size+=(*streams)->size;
  532.         streams++;
  533.     }
  534.   }
  535.   if (h->prop) {
  536.     if (h->prop->size != 50)
  537.     {
  538.       lprintf("rmff_fix_header: correcting prop.size from %i to %in", h->prop->size, 50);
  539.       h->prop->size=50;
  540.     }
  541.     if (h->prop->num_streams != num_streams)
  542.     {
  543.       lprintf("rmff_fix_header: correcting prop.num_streams from %i to %in", h->prop->num_streams, num_streams);
  544.       h->prop->num_streams=num_streams;
  545.     }
  546.     num_headers++;
  547.     header_size+=50;
  548.   } else
  549.     lprintf("rmff_fix_header: warning: no PROP chunk.n");
  551.   if (h->cont) {
  552.     num_headers++;
  553.     header_size+=h->cont->size;
  554.   } else
  555.     lprintf("rmff_fix_header: warning: no CONT chunk.n");
  557.   if (!h->data) {
  558.     lprintf("rmff_fix_header: no DATA chunk, creating onen");
  559.     h->data = calloc( 1, sizeof(rmff_data_t) );
  560.     if( h->data )
  561.     {
  562.       h->data->object_id=DATA_TAG;
  563.       h->data->object_version=0;
  564.       h->data->size=18;
  565.       h->data->num_packets=0;
  566.       h->data->next_data_header=0;
  567.     }
  568.   }
  569.   num_headers++;
  571.   if (!h->fileheader) {
  572.     lprintf("rmff_fix_header: no fileheader, creating one");
  573.     h->fileheader = calloc( 1, sizeof(rmff_fileheader_t) );
  574.     if( h->fileheader )
  575.     {
  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;
  581.     }
  582.   }
  583.   header_size+=h->fileheader->size;
  584.   num_headers++;
  586.   if(h->fileheader->num_headers != num_headers) {
  587.     lprintf("rmff_fix_header: setting num_headers from %i to %in", h->fileheader->num_headers, num_headers);
  588.     h->fileheader->num_headers=num_headers;
  589.   }
  590.   if(h->prop) {
  591.     if (h->prop->data_offset != header_size) {
  592.       lprintf("rmff_fix_header: setting prop.data_offset from %i to %in", h->prop->data_offset, header_size);
  593.       h->prop->data_offset=header_size;
  594.     }
  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=%in", p);
  601.       h->prop->num_packets=p;
  602.     }
  603.     if (h->data->num_packets == 0) {
  604.       lprintf("rmff_fix_header: assuming data.num_packets=%in", h->prop->num_packets);
  605.       h->data->num_packets=h->prop->num_packets;
  606.     }
  607.     if (h->data->size == 18 || !h->data->size ) {
  608.       lprintf("rmff_fix_header: assuming data.size=%in", h->prop->num_packets*h->prop->avg_packet_size);
  609.       h->data->size+=h->prop->num_packets*h->prop->avg_packet_size;
  610.     }
  611.   }
  612. }
  614. int rmff_get_header_size(rmff_header_t *h) {
  615.   if (!h) return 0;
  616.   if (!h->prop) return -1;
  617.   return h->prop->data_offset+18;
  618. }
  620. void rmff_free_header(rmff_header_t *h)
  621. {
  622.   if (!h) return;
  624.   free( h->fileheader );
  625.   free( h->prop );
  626.   free( h->data );
  627.   if( h->cont ) {
  628.     free( h->cont->title );
  629.     free( h->cont->author );
  630.     free( h->cont->copyright );
  631.     free( h->cont->comment );
  632.     free( h->cont );
  633.   }
  634.   if (h->streams)
  635.   {
  636.     rmff_mdpr_t **s=h->streams;
  638.     while(*s) {
  639.       free((*s)->stream_name);
  640.       free((*s)->mime_type);
  641.       free((*s)->type_specific_data);
  642.       free(*s);
  643.       s++;
  644.     }
  645.     free(h->streams);
  646.   }
  647.   free(h);
  648. }