← Back to branch summary

~ubuntu-dev/mplayer/ubuntu-feisty

« back to all changes in this revision

Viewing changes to libmpdemux/demux_real.c

  • Committer: Reinhard Tartler
  • Date: 2006-07-08 08:47:54 UTC
  • Revision ID: siretart@tauware.de-20060708084754-c3ff228cc9c2d8de
upgrade to pre8

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmpdemux/demux_real.c
122
122
    int audio_filepos; ///< file position of first audio packet in block
123
123
} real_priv_t;
124
124
 
 
125
//! use at most 200 MB of memory for index, corresponds to around 25 million entries
 
126
#define MAX_INDEX_ENTRIES (200*1024*1024 / sizeof(real_index_table_t))
 
127
 
125
128
/* originally from FFmpeg */
126
129
static void get_str(int isbyte, demuxer_t *demuxer, char *buf, int buf_size)
127
130
{
159
162
    real_index_table_t *index;
160
163
    int i, entries;
161
164
 
162
 
    if (verbose<=1)
 
165
    if ( mp_msg_test(MSGT_DEMUX,MSGL_V) )
163
166
        return;
164
167
    
165
 
    if (stream_id > MAX_STREAMS)
 
168
    if ((unsigned)stream_id >= MAX_STREAMS)
166
169
        return;
167
170
 
168
171
    index = priv->index_table[stream_id];
222
225
    
223
226
    next_header_pos = stream_read_dword(demuxer->stream);
224
227
    mp_msg(MSGT_DEMUX, MSGL_V,"next_header_pos: %d\n", next_header_pos);
225
 
    if (entries <= 0)
 
228
    if (entries <= 0 || entries > MAX_INDEX_ENTRIES)
226
229
    {
227
230
        if (next_header_pos)
228
231
            goto read_index;
231
234
    }
232
235
 
233
236
    priv->index_table_size[stream_id] = entries;
234
 
    priv->index_table[stream_id] = malloc(priv->index_table_size[stream_id] * sizeof(real_index_table_t));
 
237
    priv->index_table[stream_id] = calloc(priv->index_table_size[stream_id], sizeof(real_index_table_t));
235
238
    
236
239
    for (i = 0; i < entries; i++)
237
240
    {
267
270
  {
268
271
    real_priv_t *priv = demuxer->priv;
269
272
    real_index_table_t *index;
 
273
    if (priv->index_table_size[stream_id] >= MAX_INDEX_ENTRIES) {
 
274
      mp_msg(MSGT_DEMUXER, MSGL_WARN, "Index too large during building\n");
 
275
      return;
 
276
    }
270
277
    if (priv->index_table_size[stream_id] >= priv->index_malloc_size[stream_id])
271
278
    {
272
279
      if (priv->index_malloc_size[stream_id] == 0)
400
407
    for (i = 0; i < MAX_STREAMS; i++)
401
408
    {
402
409
    priv->index_table_size[i] = num_of_packets;
403
 
    priv->index_table[i] = malloc(priv->index_table_size[i] * sizeof(real_index_table_t));
 
410
    priv->index_table[i] = calloc(priv->index_table_size[i], sizeof(real_index_table_t));
404
411
//    priv->index_table[stream_id] = realloc(priv->index_table[stream_id],
405
412
//      priv->index_table_size[stream_id] * sizeof(real_index_table_t));
406
413
    }
1040
1047
        return 1;
1041
1048
    }
1042
1049
 
1043
 
if(stream_id<256){
 
1050
if((unsigned)stream_id<MAX_STREAMS){
1044
1051
 
1045
1052
    if(demuxer->audio->id==-1 && demuxer->a_streams[stream_id]){
1046
1053
        sh_audio_t *sh = demuxer->a_streams[stream_id];
1047
1054
        demuxer->audio->id=stream_id;
1048
1055
        sh->ds=demuxer->audio;
1049
1056
        demuxer->audio->sh=sh;
1050
 
        priv->audio_buf = malloc(priv->sub_packet_h[demuxer->audio->id] * priv->audiopk_size[demuxer->audio->id]);
1051
 
        priv->audio_timestamp = malloc(priv->sub_packet_h[demuxer->audio->id] * sizeof(float));
 
1057
        priv->audio_buf = calloc(priv->sub_packet_h[demuxer->audio->id], priv->audiopk_size[demuxer->audio->id]);
 
1058
        priv->audio_timestamp = calloc(priv->sub_packet_h[demuxer->audio->id], sizeof(float));
1052
1059
        mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected RM audio ID = %d\n",stream_id);
1053
1060
        goto got_audio;
1054
1061
    }
1070
1077
  }//    goto loop;
1071
1078
}
1072
1079
 
1073
 
extern void print_wave_header(WAVEFORMATEX *h);
 
1080
extern void print_wave_header(WAVEFORMATEX *h, int verbose_level);
1074
1081
 
1075
1082
static demuxer_t* demux_open_real(demuxer_t* demuxer)
1076
1083
{
1207
1214
                int codec_pos;
1208
1215
                int tmp;
1209
1216
                int len;
1210
 
                char *descr, *mimet;
 
1217
                char *descr, *mimet = NULL;
1211
1218
 
1212
1219
                stream_id = stream_read_word(demuxer->stream);
1213
1220
                mp_msg(MSGT_DEMUX,MSGL_V,"Found new stream (id: %d)\n", stream_id);
1225
1232
                    descr = malloc(len+1);
1226
1233
                stream_read(demuxer->stream, descr, len);
1227
1234
                    descr[len] = 0;
1228
 
                    printf("Stream description: %s\n", descr);
 
1235
                    mp_msg(MSGT_DEMUX, MSGL_INFO,"Stream description: %s\n", descr);
1229
1236
                    free(descr);
1230
1237
                }
1231
1238
//              skip_str(1, demuxer);   /* mimetype */
1233
1240
                    mimet = malloc(len+1);
1234
1241
                stream_read(demuxer->stream, mimet, len);
1235
1242
                    mimet[len] = 0;
1236
 
                    printf("Stream mimetype: %s\n", mimet);
 
1243
                    mp_msg(MSGT_DEMUX, MSGL_INFO,"Stream mimetype: %s\n", mimet);
1237
1244
                }
1238
1245
                
1239
1246
                /* Type specific header */
1409
1416
                            if (version==5)
1410
1417
                              stream_skip(demuxer->stream,1);  // Skip 1 additional unknown byte 
1411
1418
                            codecdata_length=stream_read_dword(demuxer->stream);
 
1419
                            // Check extradata len, we can't store bigger values in cbSize anyway
 
1420
                            if ((unsigned)codecdata_length > 0xffff) {
 
1421
                                mp_msg(MSGT_DEMUX,MSGL_ERR,"Extradata too big (%d)\n", codecdata_length);
 
1422
                                goto skip_this_chunk;
 
1423
                            }
1412
1424
                            sh->wf->cbSize = codecdata_length;
1413
1425
                            sh->wf = realloc(sh->wf, sizeof(WAVEFORMATEX)+sh->wf->cbSize);
1414
1426
                            stream_read(demuxer->stream, ((char*)(sh->wf+1)), codecdata_length); // extras
1448
1460
                    sh->wf->wFormatTag = sh->format;
1449
1461
                    
1450
1462
                    mp_msg(MSGT_DEMUX,MSGL_V,"audio fourcc: %.4s (%x)\n", (char *)&sh->format, sh->format);
1451
 
                    if (verbose > 0)
1452
 
                    print_wave_header(sh->wf);
 
1463
                    if ( mp_msg_test(MSGT_DEMUX,MSGL_V) )
 
1464
                    print_wave_header(sh->wf, MSGL_V);
1453
1465
 
1454
1466
                    /* Select audio stream with highest bitrate if multirate file*/
1455
1467
                    if (priv->is_multirate && ((demuxer->audio->id == -1) ||
1463
1475
                        demuxer->audio->id=stream_id;
1464
1476
                        sh->ds=demuxer->audio;
1465
1477
                        demuxer->audio->sh=sh;
1466
 
                priv->audio_buf = malloc(priv->sub_packet_h[demuxer->audio->id] * priv->audiopk_size[demuxer->audio->id]);
1467
 
                priv->audio_timestamp = malloc(priv->sub_packet_h[demuxer->audio->id] * sizeof(float));
 
1478
                priv->audio_buf = calloc(priv->sub_packet_h[demuxer->audio->id], priv->audiopk_size[demuxer->audio->id]);
 
1479
                priv->audio_timestamp = calloc(priv->sub_packet_h[demuxer->audio->id], sizeof(float));
1468
1480
                    }
1469
1481
                    
1470
1482
                    ++a_streams;
1635
1647
                    priv->is_multirate = 1;
1636
1648
                    stream_skip(demuxer->stream, 4); // Length of codec data (repeated)
1637
1649
                    stream_cnt = stream_read_dword(demuxer->stream); // Get number of audio or video streams
1638
 
                    if (stream_cnt >= MAX_STREAMS) {
 
1650
                    if ((unsigned)stream_cnt >= MAX_STREAMS) {
1639
1651
                        mp_msg(MSGT_DEMUX,MSGL_ERR,"Too many streams in %s. Big troubles ahead.\n", mimet);
1640
1652
                        goto skip_this_chunk;
1641
1653
                    }
1642
1654
                    for (i = 0; i < stream_cnt; i++)
1643
1655
                        stream_list[i] = stream_read_word(demuxer->stream);
1644
1656
                    for (i = 0; i < stream_cnt; i++)
1645
 
                        if (stream_list[i] >= MAX_STREAMS) {
 
1657
                        if ((unsigned)stream_list[i] >= MAX_STREAMS) {
1646
1658
                            mp_msg(MSGT_DEMUX,MSGL_ERR,"Stream id out of range: %d. Ignored.\n", stream_list[i]);
1647
1659
                            stream_skip(demuxer->stream, 4); // Skip DATA offset for broken stream
1648
1660
                        } else {
1825
1837
}
1826
1838
 
1827
1839
/* please upload RV10 samples WITH INDEX CHUNK */
1828
 
static void demux_seek_real(demuxer_t *demuxer, float rel_seek_secs, int flags)
 
1840
static void demux_seek_real(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags)
1829
1841
{
1830
1842
    real_priv_t *priv = demuxer->priv;
1831
1843
    demux_stream_t *d_audio = demuxer->audio;