git.sesse.net Git - vlc/blob - modules/demux/real.c

   1 /*****************************************************************************
   2  * real.c: Real demuxer.
   3  *****************************************************************************
   4  * Copyright (C) 2004, 2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <stdlib.h>                                      /* malloc(), free() */
  28
  29 #include <vlc/vlc.h>
  30 #include <vlc/input.h>
  31
  32 /*****************************************************************************
  33  * Module descriptor
  34  *****************************************************************************/
  35 static int  Open    ( vlc_object_t * );
  36 static void Close  ( vlc_object_t * );
  37
  38 vlc_module_begin();
  39     set_description( _("Real demuxer" ) );
  40     set_capability( "demux2", 15 );
  41     set_category( CAT_INPUT );
  42     set_subcategory( SUBCAT_INPUT_DEMUX );
  43     set_callbacks( Open, Close );
  44     add_shortcut( "real" );
  45     add_shortcut( "rm" );
  46 vlc_module_end();
  47
  48 /*****************************************************************************
  49  * Local prototypes
  50  *****************************************************************************/
  51
  52 typedef struct
  53 {
  54     int         i_id;
  55     es_format_t fmt;
  56
  57     es_out_id_t *p_es;
  58
  59     int         i_frame;
  60     block_t     *p_frame;
  61
  62     int         i_subpacket_h;
  63     int         i_subpacket_size;
  64     int         i_coded_frame_size;
  65     int         i_frame_size;
  66
  67     int         i_subpacket;
  68     int         i_subpackets;
  69     block_t     **p_subpackets;
  70     int         i_out_subpacket;
  71
  72 } real_track_t;
  73
  74 struct demux_sys_t
  75 {
  76     int64_t  i_data_offset;
  77     int64_t  i_data_size;
  78     uint32_t i_data_packets_count;
  79     uint32_t i_data_packets;
  80     int64_t  i_data_offset_next;
  81
  82     int          i_track;
  83     real_track_t **track;
  84
  85     uint8_t buffer[65536];
  86
  87     int64_t     i_pcr;
  88
  89     vlc_meta_t *p_meta;
  90 };
  91
  92 static int Demux( demux_t *p_demux );
  93 static int Control( demux_t *p_demux, int i_query, va_list args );
  94
  95 static int HeaderRead( demux_t *p_demux );
  96 static int ReadCodecSpecificData( demux_t *p_demux, int i_len, int i_num );
  97
  98 /*****************************************************************************
  99  * Open
 100  *****************************************************************************/
 101 static int Open( vlc_object_t *p_this )
 102 {
 103     demux_t     *p_demux = (demux_t*)p_this;
 104     demux_sys_t *p_sys;
 105
 106     uint8_t     *p_peek;
 107
 108     if( stream_Peek( p_demux->s, &p_peek, 10 ) < 10 ) return VLC_EGENERIC;
 109     if( strncmp( (char *)p_peek, ".RMF", 4 ) ) return VLC_EGENERIC;
 110
 111     /* Fill p_demux field */
 112     p_demux->pf_demux = Demux;
 113     p_demux->pf_control = Control;
 114     p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
 115     memset( p_sys, 0, sizeof( demux_sys_t ) );
 116     p_sys->i_data_offset = 0;
 117     p_sys->i_track = 0;
 118     p_sys->track   = NULL;
 119     p_sys->i_pcr   = 1;
 120
 121
 122     /* Parse the headers */
 123     if( HeaderRead( p_demux ) )
 124     {
 125         int i;
 126         msg_Err( p_demux, "invalid header" );
 127         for( i = 0; i < p_sys->i_track; i++ )
 128         {
 129             real_track_t *tk = p_sys->track[i];
 130
 131             if( tk->p_es )
 132             {
 133                 es_out_Del( p_demux->out, tk->p_es );
 134             }
 135             free( tk );
 136         }
 137         if( p_sys->i_track > 0 )
 138         {
 139             free( p_sys->track );
 140         }
 141         free( p_sys );
 142         return VLC_EGENERIC;
 143     }
 144
 145     return VLC_SUCCESS;
 146 }
 147
 148 /*****************************************************************************
 149  * Close
 150  *****************************************************************************/
 151 static void Close( vlc_object_t *p_this )
 152 {
 153     demux_t *p_demux = (demux_t*)p_this;
 154     demux_sys_t *p_sys = p_demux->p_sys;
 155     int i;
 156
 157     for( i = 0; i < p_sys->i_track; i++ )
 158     {
 159         real_track_t *tk = p_sys->track[i];
 160         int j = tk->i_subpackets;
 161
 162         if( tk->p_frame ) block_Release( tk->p_frame );
 163         es_format_Clean( &tk->fmt );
 164
 165         while(  j-- )
 166         {
 167             if( tk->p_subpackets[ j ] )
 168                 block_Release( tk->p_subpackets[ j ] );
 169         }
 170         if( !tk->i_subpackets ) free( tk->p_subpackets );
 171
 172         free( tk );
 173     }
 174
 175     if( p_sys->i_track > 0 ) free( p_sys->track );
 176     free( p_sys );
 177 }
 178
 179
 180 /*****************************************************************************
 181  * Demux:
 182  *****************************************************************************/
 183 static int Demux( demux_t *p_demux )
 184 {
 185     demux_sys_t *p_sys = p_demux->p_sys;
 186     uint8_t     header[18];
 187     int         i_size, i_id, i_flags, i;
 188     int64_t     i_pts;
 189     real_track_t *tk = NULL;
 190     vlc_bool_t  b_selected;
 191
 192     if( p_sys->i_data_packets >= p_sys->i_data_packets_count &&
 193         p_sys->i_data_packets_count )
 194     {
 195         if( stream_Read( p_demux->s, header, 18 ) < 18 )
 196         {
 197             return 0;
 198         }
 199         if( strncmp( (char *)header, "DATA", 4 ) )
 200         {
 201             return 0;
 202         }
 203         p_sys->i_data_offset = stream_Tell( p_demux->s ) - 18;
 204         p_sys->i_data_size   = GetDWBE( &header[4] );
 205         p_sys->i_data_packets_count = GetDWBE( &header[10] );
 206         p_sys->i_data_packets = 0;
 207         p_sys->i_data_offset_next = GetDWBE( &header[14] );
 208
 209         msg_Dbg( p_demux, "entering new DATA packets=%d next=%u",
 210                  p_sys->i_data_packets_count,
 211                  (uint32_t)p_sys->i_data_offset_next );
 212     }
 213
 214     if( stream_Read( p_demux->s, header, 12 ) < 12 ) return 0;
 215
 216     i_size = GetWBE( &header[2] ) - 12;
 217     i_id   = GetWBE( &header[4] );
 218     i_pts  = 1000 * GetDWBE( &header[6] );
 219     i_pts += 1000; /* Avoid 0 pts */
 220     i_flags= header[11]; /* flags 0x02 -> keyframe */
 221
 222 #if 0
 223     msg_Dbg( p_demux, "packet %d size=%d id=%d pts=%u",
 224              p_sys->i_data_packets, i_size, i_id, (uint32_t)(i_pts/1000) );
 225 #endif
 226
 227     p_sys->i_data_packets++;
 228
 229     stream_Read( p_demux->s, p_sys->buffer, i_size );
 230
 231     for( i = 0; i < p_sys->i_track; i++ )
 232     {
 233         if( p_sys->track[i]->i_id == i_id ) tk = p_sys->track[i];
 234     }
 235
 236     if( tk == NULL )
 237     {
 238         msg_Warn( p_demux, "unknown track id(0x%x)", i_id );
 239         return 1;
 240     }
 241     es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE, tk->p_es, &b_selected );
 242
 243     if( tk->fmt.i_cat == VIDEO_ES && b_selected )
 244     {
 245         uint8_t *p = p_sys->buffer;
 246
 247         while( p < &p_sys->buffer[i_size - 2] )
 248         {
 249             uint8_t h = *p++;
 250             int     i_len = 0;
 251             int     i_copy;
 252             int     i_subseq = 0;
 253             int     i_seqnum = 0;
 254             int     i_offset = 0;
 255
 256             if( (h&0xc0) == 0x40 )
 257             {
 258                 /* Short header */
 259                 p++;
 260                 i_len = &p_sys->buffer[i_size] - p;
 261             }
 262             else
 263             {
 264                 if( (h&0x40) == 0 )
 265                 {
 266                     i_subseq = (*p++)&0x7f;
 267                 }
 268                 i_len = (p[0] << 8)|p[1]; p += 2;
 269                 if( (i_len&0xc000) == 0 )
 270                 {
 271                     i_len <<= 16;
 272                     i_len |= (p[0] << 8)|p[1]; p += 2;
 273                     i_len &= 0x3fffffff;
 274                 }
 275                 else
 276                 {
 277                     i_len &= 0x3fff;
 278                 }
 279
 280                 i_offset = (p[0] << 8)|p[1]; p += 2;
 281                 if( (i_offset&0xc000) == 0 )
 282                 {
 283                     i_offset <<= 16;
 284                     i_offset |= (p[0] << 8)|p[1]; p += 2;
 285                     i_offset &= 0x3fffffff;
 286                 }
 287                 else
 288                 {
 289                     i_offset &= 0x3fff;
 290                 }
 291                 i_seqnum = *p++;
 292             }
 293
 294             i_copy = i_len - i_offset;
 295             if( i_copy > &p_sys->buffer[i_size] - p )
 296             {
 297                 i_copy = &p_sys->buffer[i_size] - p;
 298             }
 299             else if( i_copy < 0 )
 300             {
 301                 break;
 302             }
 303
 304             msg_Dbg( p_demux, "    - len=%d offset=%d size=%d subseq=%d seqnum=%d",
 305                      i_len, i_offset, i_copy, i_subseq, i_seqnum );
 306
 307             if( (h&0xc0) == 0x80 )
 308             {
 309                 /* last fragment -> fixes */
 310                 i_copy = i_offset;
 311                 i_offset = i_len - i_copy;
 312                 msg_Dbg( p_demux, "last fixing copy=%d offset=%d",
 313                          i_copy, i_offset );
 314             }
 315
 316             if( tk->p_frame &&
 317                 ( tk->p_frame->i_dts != i_pts ||
 318                   tk->i_frame != i_len ) )
 319             {
 320                 msg_Dbg( p_demux, "sending size=%d", tk->p_frame->i_buffer );
 321
 322                 if( p_sys->i_pcr < tk->p_frame->i_dts )
 323                 {
 324                     p_sys->i_pcr = tk->p_frame->i_dts;
 325
 326                     es_out_Control( p_demux->out, ES_OUT_SET_PCR,
 327                                     (int64_t)p_sys->i_pcr );
 328                 }
 329                 es_out_Send( p_demux->out, tk->p_es, tk->p_frame );
 330
 331                 tk->i_frame = 0;
 332                 tk->p_frame = NULL;
 333             }
 334
 335             if( (h&0xc0) != 0x80 && (h&0xc0) != 0x00 && !tk->p_frame )
 336             {
 337                 /* no fragment */
 338                 i_len = i_copy;
 339                 i_offset = 0;
 340             }
 341
 342
 343             if( tk->p_frame == NULL )
 344             {
 345                 msg_Dbg( p_demux, "new frame size=%d", i_len );
 346                 tk->i_frame = i_len;
 347                 if( !( tk->p_frame = block_New( p_demux, i_len + 8 + 1000) ) )
 348                 {
 349                     return -1;
 350                 }
 351                 memset( &tk->p_frame->p_buffer[8], 0, i_len );
 352                 tk->p_frame->i_dts = i_pts;
 353                 tk->p_frame->i_pts = i_pts;
 354
 355                 ((uint32_t*)tk->p_frame->p_buffer)[0] = i_len;  /* len */
 356                 ((uint32_t*)tk->p_frame->p_buffer)[1] = 0;      /* chunk counts */
 357             }
 358
 359             if( i_offset < tk->i_frame)
 360             {
 361                 int i_ck = ((uint32_t*)tk->p_frame->p_buffer)[1]++;
 362
 363                 msg_Dbg( p_demux, "copying new buffer n=%d offset=%d copy=%d",
 364                          i_ck, i_offset, i_copy );
 365
 366                 ((uint32_t*)(tk->p_frame->p_buffer+i_len+8))[i_ck] = i_offset;
 367
 368                 memcpy( &tk->p_frame->p_buffer[i_offset + 8], p, i_copy );
 369             }
 370
 371             p += i_copy;
 372
 373             if( (h&0xc0) != 0x80 )
 374             {
 375                 break;
 376             }
 377
 378 #if 0
 379             if( tk->p_frame )
 380             {
 381                 /* append data */
 382                 int i_ck = ((uint32_t*)tk->p_frame->p_buffer)[1]++;
 383
 384                 if( (h&0xc0) == 0x80 )
 385                 {
 386                     /* last fragment */
 387                     i_copy = i_offset;
 388                     i_offset = i_len - i_offset;
 389
 390                     ((uint32_t*)(tk->p_frame->p_buffer+i_len+8))[i_ck] = i_offset;
 391                     memcpy( &tk->p_frame->p_buffer[i_offset+ 8], p, i_copy );
 392                     p += i_copy;
 393
 394                     if( p_sys->i_pcr < tk->p_frame->i_dts )
 395                     {
 396                         p_sys->i_pcr = tk->p_frame->i_dts;
 397                         es_out_Control( p_demux->out, ES_OUT_SET_PCR,
 398                                         (int64_t)p_sys->i_pcr );
 399                     }
 400                     es_out_Send( p_demux->out, tk->p_es, tk->p_frame );
 401
 402                     tk->i_frame = 0;
 403                     tk->p_frame = NULL;
 404
 405                     continue;
 406                 }
 407
 408                 ((uint32_t*)(tk->p_frame->p_buffer+i_len+8))[i_ck] = i_offset;
 409                 memcpy( &tk->p_frame->p_buffer[i_offset + 8], p, i_copy );
 410                 break;
 411             }
 412
 413             if( (h&0xc0) != 0x00 )
 414             {
 415                 block_t *p_frame;
 416
 417                 /* not fragmented */
 418                 if( !( p_frame = block_New( p_demux, i_copy + 8 + 8 ) ) )
 419                 {
 420                     return -1;
 421                 }
 422                 p_frame->i_dts = i_pts;
 423                 p_frame->i_pts = i_pts;
 424
 425                 ((uint32_t*)p_frame->p_buffer)[0] = i_copy;
 426                 ((uint32_t*)p_frame->p_buffer)[1] = 1;
 427                 ((uint32_t*)(p_frame->p_buffer+i_copy+8))[0] = 0;
 428                 memcpy( &p_frame->p_buffer[8], p, i_copy );
 429
 430                 p += i_copy;
 431
 432                 if( p_sys->i_pcr < p_frame->i_dts )
 433                 {
 434                     p_sys->i_pcr = p_frame->i_dts;
 435                     es_out_Control( p_demux->out, ES_OUT_SET_PCR,
 436                                     (int64_t)p_sys->i_pcr );
 437                 }
 438                 es_out_Send( p_demux->out, tk->p_es, p_frame );
 439             }
 440             else
 441             {
 442                 /* First fragment */
 443                 tk->i_frame = i_len;
 444                 if( !( tk->p_frame = block_New( p_demux, i_len + 8 + 1000) ) )
 445                 {
 446                     return -1;
 447                 }
 448                 memset( &tk->p_frame->p_buffer[8], 0, i_len );
 449                 tk->p_frame->i_dts = i_pts;
 450                 tk->p_frame->i_pts = i_pts;
 451
 452                 ((uint32_t*)tk->p_frame->p_buffer)[0] = i_len;  /* len */
 453                 ((uint32_t*)tk->p_frame->p_buffer)[1] = 1;      /* chunk counts */
 454                 ((uint32_t*)(tk->p_frame->p_buffer+i_len+8))[0] = i_offset;
 455                 memcpy( &tk->p_frame->p_buffer[i_offset + 8], p, i_copy );
 456
 457                 break;
 458             }
 459 #endif
 460         }
 461     }
 462     else if( tk->fmt.i_cat == AUDIO_ES && b_selected )
 463     {
 464         /* Set PCR */
 465         if( p_sys->i_pcr < i_pts )
 466         {
 467             p_sys->i_pcr = i_pts;
 468             es_out_Control( p_demux->out, ES_OUT_SET_PCR,
 469                             (int64_t)p_sys->i_pcr );
 470         }
 471
 472         if( tk->fmt.i_codec == VLC_FOURCC( 'm', 'p', '4', 'a' ) )
 473         {
 474             int     i_sub = (p_sys->buffer[1] >> 4)&0x0f;
 475             uint8_t *p_sub = &p_sys->buffer[2+2*i_sub];
 476
 477             int i;
 478             for( i = 0; i < i_sub; i++ )
 479             {
 480                 int i_sub_size = GetWBE( &p_sys->buffer[2+i*2]);
 481                 block_t *p_block = block_New( p_demux, i_sub_size );
 482                 if( p_block )
 483                 {
 484                     memcpy( p_block->p_buffer, p_sub, i_sub_size );
 485                     p_sub += i_sub_size;
 486
 487                     p_block->i_dts =
 488                     p_block->i_pts = ( i == 0 ? i_pts : 0 );
 489
 490                     es_out_Send( p_demux->out, tk->p_es, p_block );
 491                 }
 492             }
 493         }
 494         else if( tk->fmt.i_codec == VLC_FOURCC( 'c', 'o', 'o', 'k' ) ||
 495                  tk->fmt.i_codec == VLC_FOURCC('2','8','_','8') )
 496         {
 497             uint8_t *p_buf = p_sys->buffer;
 498             int y = tk->i_subpacket / (tk->i_frame_size /tk->i_subpacket_size);
 499             int i_index, i;
 500
 501             /* Sanity check */
 502             if( i_flags & 2 ) y = tk->i_subpacket = 0;
 503
 504             if( tk->fmt.i_codec == VLC_FOURCC( 'c', 'o', 'o', 'k' ) )
 505             for( i = 0; i < tk->i_frame_size / tk->i_subpacket_size; i++ )
 506             {
 507                 block_t *p_block = block_New( p_demux, tk->i_subpacket_size );
 508                 memcpy( p_block->p_buffer, p_buf, tk->i_subpacket_size );
 509                 p_buf += tk->i_subpacket_size;
 510
 511                 i_index = tk->i_subpacket_h * i +
 512                     ((tk->i_subpacket_h + 1) / 2) * (y&1) + (y>>1);
 513
 514                 p_block->i_dts = p_block->i_pts = i_pts;
 515                 tk->p_subpackets[i_index] = p_block;
 516                 tk->i_subpacket++;
 517             }
 518
 519             if( tk->fmt.i_codec == VLC_FOURCC('2','8','_','8') )
 520             for( i = 0; i < tk->i_subpacket_h / 2; i++ )
 521             {
 522                 block_t *p_block = block_New( p_demux, tk->i_coded_frame_size);
 523                 memcpy( p_block->p_buffer, p_buf, tk->i_coded_frame_size );
 524                 p_buf += tk->i_coded_frame_size;
 525
 526                 i_index = (i * 2 * tk->i_frame_size) /
 527                     tk->i_coded_frame_size + y;
 528
 529                 p_block->i_dts = p_block->i_pts = i_pts;
 530                 tk->p_subpackets[i_index] = p_block;
 531                 tk->i_subpacket++;
 532             }
 533
 534             while( tk->i_out_subpacket != tk->i_subpackets &&
 535                    tk->p_subpackets[tk->i_out_subpacket] )
 536             {
 537                 block_t *p_block = tk->p_subpackets[tk->i_out_subpacket];
 538                 tk->p_subpackets[tk->i_out_subpacket] = 0;
 539
 540                 if( tk->i_out_subpacket ) p_block->i_dts = p_block->i_pts = 0;
 541                 es_out_Send( p_demux->out, tk->p_es, p_block );
 542
 543                 tk->i_out_subpacket++;
 544             }
 545
 546             if( tk->i_subpacket == tk->i_subpackets &&
 547                 tk->i_out_subpacket != tk->i_subpackets )
 548             {
 549                 msg_Warn( p_demux, "i_subpacket != i_out_subpacket, "
 550                           "this shouldn't happen" );
 551             }
 552
 553             if( tk->i_subpacket == tk->i_subpackets )
 554             {
 555                 tk->i_subpacket = 0;
 556                 tk->i_out_subpacket = 0;
 557             }
 558         }
 559         else
 560         {
 561             block_t *p_block = block_New( p_demux, i_size );
 562
 563             if( tk->fmt.i_codec == VLC_FOURCC( 'a', '5', '2', ' ' ) )
 564             {
 565                 uint8_t *src = p_sys->buffer;
 566                 uint8_t *dst = p_block->p_buffer;
 567
 568                 /* byte swap data */
 569                 while( dst < &p_block->p_buffer[i_size- 1])
 570                 {
 571                     *dst++ = src[1];
 572                     *dst++ = src[0];
 573
 574                     src += 2;
 575                 }
 576             }
 577             else
 578             {
 579                 memcpy( p_block->p_buffer, p_sys->buffer, i_size );
 580             }
 581             p_block->i_dts = p_block->i_pts = i_pts;
 582             es_out_Send( p_demux->out, tk->p_es, p_block );
 583         }
 584     }
 585
 586
 587     return 1;
 588 }
 589
 590 /*****************************************************************************
 591  * Control:
 592  *****************************************************************************/
 593 static int Control( demux_t *p_demux, int i_query, va_list args )
 594 {
 595     demux_sys_t *p_sys = p_demux->p_sys;
 596 #if 0
 597     double f, *pf;
 598     int64_t i64, *pi64;
 599 #endif
 600
 601     switch( i_query )
 602     {
 603 #if 0
 604         case DEMUX_GET_POSITION:
 605             pf = (double*) va_arg( args, double* );
 606             i64 = stream_Size( p_demux->s );
 607             if( i64 > 0 )
 608             {
 609                 *pf = (double)stream_Tell( p_demux->s ) / (double)i64;
 610             }
 611             else
 612             {
 613                 *pf = 0.0;
 614             }
 615             return VLC_SUCCESS;
 616         case DEMUX_SET_POSITION:
 617             f = (double) va_arg( args, double );
 618             i64 = stream_Size( p_demux->s );
 619
 620             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
 621
 622             return stream_Seek( p_demux->s, (int64_t)(i64 * f) );
 623
 624         case DEMUX_GET_TIME:
 625             pi64 = (int64_t*)va_arg( args, int64_t * );
 626             if( p_sys->i_mux_rate > 0 )
 627             {
 628                 *pi64 = (int64_t)1000000 * ( stream_Tell( p_demux->s ) / 50 ) / p_sys->i_mux_rate;
 629                 return VLC_SUCCESS;
 630             }
 631             *pi64 = 0;
 632             return VLC_EGENERIC;
 633
 634         case DEMUX_GET_LENGTH:
 635             pi64 = (int64_t*)va_arg( args, int64_t * );
 636             if( p_sys->i_mux_rate > 0 )
 637             {
 638                 *pi64 = (int64_t)1000000 * ( stream_Size( p_demux->s ) / 50 ) / p_sys->i_mux_rate;
 639                 return VLC_SUCCESS;
 640             }
 641             *pi64 = 0;
 642             return VLC_EGENERIC;
 643 #endif
 644
 645         case DEMUX_GET_META:
 646         {
 647             vlc_meta_t **pp_meta = (vlc_meta_t**)va_arg( args, vlc_meta_t** );
 648             *pp_meta = p_sys->p_meta;
 649             return VLC_SUCCESS;
 650         }
 651
 652         case DEMUX_SET_TIME:
 653         case DEMUX_GET_FPS:
 654         default:
 655             return VLC_EGENERIC;
 656     }
 657     return VLC_EGENERIC;
 658 }
 659
 660 /*****************************************************************************
 661  * HeaderRead:
 662  *****************************************************************************/
 663 static int HeaderRead( demux_t *p_demux )
 664 {
 665     demux_sys_t *p_sys = p_demux->p_sys;
 666     uint8_t header[100];    /* FIXME */
 667
 668     uint32_t    i_id;
 669     uint32_t    i_size;
 670     int64_t     i_skip;
 671     int         i_version;
 672
 673     p_sys->p_meta = vlc_meta_New();
 674
 675     for( ;; )
 676     {
 677         /* Read the header */
 678         if( stream_Read( p_demux->s, header, 10 ) < 10 )
 679         {
 680             return VLC_EGENERIC;
 681         }
 682         i_id        = VLC_FOURCC( header[0], header[1], header[2], header[3] );
 683         i_size      = GetDWBE( &header[4] );
 684         i_version   = GetWBE( &header[8] );
 685
 686         msg_Dbg( p_demux, "object %4.4s size=%d version=%d",
 687                  (char*)&i_id, i_size, i_version );
 688
 689         if( i_size < 10 )
 690         {
 691             msg_Dbg( p_demux, "invalid size for object %4.4s", (char*)&i_id );
 692             return VLC_EGENERIC;
 693         }
 694         i_skip = i_size - 10;
 695
 696         if( i_id == VLC_FOURCC('.','R','M','F') )
 697         {
 698             if( stream_Read( p_demux->s, header, 8 ) < 8 ) return VLC_EGENERIC;
 699             msg_Dbg( p_demux, "    - file version=0x%x num headers=%d",
 700                      GetDWBE( &header[0] ), GetDWBE( &header[4] ) );
 701
 702             i_skip -= 8;
 703         }
 704         else if( i_id == VLC_FOURCC('P','R','O','P') )
 705         {
 706             int i_flags;
 707
 708             if( stream_Read(p_demux->s, header, 40) < 40 ) return VLC_EGENERIC;
 709
 710             msg_Dbg( p_demux, "    - max bitrate=%d avg bitrate=%d",
 711                      GetDWBE(&header[0]), GetDWBE(&header[4]) );
 712             msg_Dbg( p_demux, "    - max packet size=%d avg bitrate=%d",
 713                      GetDWBE(&header[8]), GetDWBE(&header[12]) );
 714             msg_Dbg( p_demux, "    - packets count=%d", GetDWBE(&header[16]) );
 715             msg_Dbg( p_demux, "    - duration=%d ms", GetDWBE(&header[20]) );
 716             msg_Dbg( p_demux, "    - preroll=%d ms", GetDWBE(&header[24]) );
 717             msg_Dbg( p_demux, "    - index offset=%d", GetDWBE(&header[28]) );
 718             msg_Dbg( p_demux, "    - data offset=%d", GetDWBE(&header[32]) );
 719             msg_Dbg( p_demux, "    - num streams=%d", GetWBE(&header[36]) );
 720             i_flags = GetWBE(&header[38]);
 721             msg_Dbg( p_demux, "    - flags=0x%x %s%s%s",
 722                      i_flags,
 723                      i_flags&0x0001 ? "PN_SAVE_ENABLED " : "",
 724                      i_flags&0x0002 ? "PN_PERFECT_PLAY_ENABLED " : "",
 725                      i_flags&0x0004 ? "PN_LIVE_BROADCAST" : "" );
 726             i_skip -= 40;
 727         }
 728         else if( i_id == VLC_FOURCC('C','O','N','T') )
 729         {
 730             int i_len;
 731             char *psz;
 732
 733             /* FIXME FIXME: should convert from whatever the character
 734              * encoding of the input meta data is to UTF-8. */
 735
 736             stream_Read( p_demux->s, header, 2 );
 737             if( ( i_len = GetWBE( header ) ) > 0 )
 738             {
 739                 psz = malloc( i_len + 1 );
 740                 stream_Read( p_demux->s, psz, i_len );
 741                 psz[i_len] = '\0';
 742
 743                 msg_Dbg( p_demux, "    - title=`%s'", psz );
 744                 EnsureUTF8( psz );
 745                 vlc_meta_Add( p_sys->p_meta, VLC_META_TITLE, psz );
 746                 free( psz );
 747                 i_skip -= i_len;
 748             }
 749             i_skip -= 2;
 750
 751             stream_Read( p_demux->s, header, 2 );
 752             if( ( i_len = GetWBE( header ) ) > 0 )
 753             {
 754                 psz = malloc( i_len + 1 );
 755                 stream_Read( p_demux->s, psz, i_len );
 756                 psz[i_len] = '\0';
 757
 758                 msg_Dbg( p_demux, "    - author=`%s'", psz );
 759                 EnsureUTF8( psz );
 760                 vlc_meta_Add( p_sys->p_meta, VLC_META_AUTHOR, psz );
 761                 free( psz );
 762                 i_skip -= i_len;
 763             }
 764             i_skip -= 2;
 765
 766             stream_Read( p_demux->s, header, 2 );
 767             if( ( i_len = GetWBE( header ) ) > 0 )
 768             {
 769                 psz = malloc( i_len + 1 );
 770                 stream_Read( p_demux->s, psz, i_len );
 771                 psz[i_len] = '\0';
 772
 773                 msg_Dbg( p_demux, "    - copyright=`%s'", psz );
 774                 EnsureUTF8( psz );
 775                 vlc_meta_Add( p_sys->p_meta, VLC_META_COPYRIGHT, psz );
 776                 free( psz );
 777                 i_skip -= i_len;
 778             }
 779             i_skip -= 2;
 780
 781             stream_Read( p_demux->s, header, 2 );
 782             if( ( i_len = GetWBE( header ) ) > 0 )
 783             {
 784                 psz = malloc( i_len + 1 );
 785                 stream_Read( p_demux->s, psz, i_len );
 786                 psz[i_len] = '\0';
 787
 788                 msg_Dbg( p_demux, "    - comment=`%s'", psz );
 789                 EnsureUTF8( psz );
 790                 vlc_meta_Add( p_sys->p_meta, VLC_META_DESCRIPTION, psz );
 791                 free( psz );
 792                 i_skip -= i_len;
 793             }
 794             i_skip -= 2;
 795         }
 796         else if( i_id == VLC_FOURCC('M','D','P','R') )
 797         {
 798             /* Media properties header */
 799             int  i_num;
 800             int  i_len;
 801             char *psz;
 802
 803             if( stream_Read(p_demux->s, header, 30) < 30 ) return VLC_EGENERIC;
 804             i_num = GetWBE( header );
 805             msg_Dbg( p_demux, "    - id=0x%x", i_num );
 806             msg_Dbg( p_demux, "    - max bitrate=%d avg bitrate=%d",
 807                      GetDWBE(&header[2]), GetDWBE(&header[6]) );
 808             msg_Dbg( p_demux, "    - max packet size=%d avg packet size=%d",
 809                      GetDWBE(&header[10]), GetDWBE(&header[14]) );
 810             msg_Dbg( p_demux, "    - start time=%d", GetDWBE(&header[18]) );
 811             msg_Dbg( p_demux, "    - preroll=%d", GetDWBE(&header[22]) );
 812             msg_Dbg( p_demux, "    - duration=%d", GetDWBE(&header[26]) );
 813             i_skip -= 30;
 814
 815             stream_Read( p_demux->s, header, 1 );
 816             if( ( i_len = header[0] ) > 0 )
 817             {
 818                 psz = malloc( i_len + 1 );
 819                 stream_Read( p_demux->s, psz, i_len );
 820                 psz[i_len] = '\0';
 821
 822                 msg_Dbg( p_demux, "    - name=`%s'", psz );
 823                 free( psz );
 824                 i_skip -= i_len;
 825             }
 826             i_skip--;
 827
 828             stream_Read( p_demux->s, header, 1 );
 829             if( ( i_len = header[0] ) > 0 )
 830             {
 831                 psz = malloc( i_len + 1 );
 832                 stream_Read( p_demux->s, psz, i_len );
 833                 psz[i_len] = '\0';
 834
 835                 msg_Dbg( p_demux, "    - mime=`%s'", psz );
 836                 free( psz );
 837                 i_skip -= i_len;
 838             }
 839             i_skip--;
 840
 841             stream_Read( p_demux->s, header, 4 );
 842             if( ( i_len = GetDWBE( header ) ) > 0 )
 843             {
 844                 ReadCodecSpecificData( p_demux, i_len, i_num );
 845                 stream_Read( p_demux->s, NULL, i_len );
 846
 847                 i_skip -= i_len;
 848             }
 849             i_skip -= 4;
 850         }
 851         else if( i_id == VLC_FOURCC('D','A','T','A') )
 852         {
 853             stream_Read( p_demux->s, header, 8 );
 854
 855             p_sys->i_data_offset    = stream_Tell( p_demux->s ) - 10;
 856             p_sys->i_data_size      = i_size;
 857             p_sys->i_data_packets_count = GetDWBE( header );
 858             p_sys->i_data_packets   = 0;
 859             p_sys->i_data_offset_next = GetDWBE( &header[4] );
 860
 861             msg_Dbg( p_demux, "    - packets count=%d next=%u",
 862                      p_sys->i_data_packets_count,
 863                      (uint32_t)p_sys->i_data_offset_next );
 864
 865             /* we have finished the header */
 866             break;
 867         }
 868         else
 869         {
 870             /* unknow header */
 871             msg_Dbg( p_demux, "unknown chunk" );
 872         }
 873
 874         if( i_skip < 0 ) return VLC_EGENERIC;
 875         stream_Read( p_demux->s, NULL, i_skip );
 876     }
 877
 878     /* TODO read index if possible */
 879
 880     return VLC_SUCCESS;
 881 }
 882
 883 static int ReadCodecSpecificData( demux_t *p_demux, int i_len, int i_num )
 884 {
 885     demux_sys_t *p_sys = p_demux->p_sys;
 886     es_format_t fmt;
 887     real_track_t *tk;
 888     uint8_t *p_peek;
 889
 890     msg_Dbg( p_demux, "    - specific data len=%d", i_len );
 891     if( stream_Peek(p_demux->s, &p_peek, i_len) < i_len ) return VLC_EGENERIC;
 892
 893     if( !strncmp( (char *)&p_peek[4], "VIDO", 4 ) )
 894     {
 895         es_format_Init( &fmt, VIDEO_ES, VLC_FOURCC( p_peek[8], p_peek[9],
 896                         p_peek[10], p_peek[11] ) );
 897         fmt.video.i_width = GetWBE( &p_peek[12] );
 898         fmt.video.i_height= GetWBE( &p_peek[14] );
 899
 900         fmt.i_extra = 8;
 901         fmt.p_extra = malloc( 8 );
 902         ((uint32_t*)fmt.p_extra)[0] = GetDWBE( &p_peek[26] );
 903         ((uint32_t*)fmt.p_extra)[1] = GetDWBE( &p_peek[30] );
 904
 905         msg_Dbg( p_demux, "    - video 0x%08x 0x%08x",
 906                  ((uint32_t*)fmt.p_extra)[0], ((uint32_t*)fmt.p_extra)[1] );
 907
 908         if( GetDWBE( &p_peek[30] ) == 0x10003000 ||
 909             GetDWBE( &p_peek[30] ) == 0x10003001 )
 910         {
 911             fmt.i_codec = VLC_FOURCC( 'R','V','1','3' );
 912         }
 913         else if( GetDWBE( &p_peek[30] ) == 0x20001000 ||
 914                  GetDWBE( &p_peek[30] ) == 0x20100001 ||
 915                  GetDWBE( &p_peek[30] ) == 0x20200002 )
 916         {
 917             fmt.i_codec = VLC_FOURCC( 'R','V','2','0' );
 918         }
 919         else if( GetDWBE( &p_peek[30] ) == 0x30202002 )
 920         {
 921             fmt.i_codec = VLC_FOURCC( 'R','V','3','0' );
 922         }
 923         else if( GetDWBE( &p_peek[30] ) == 0x40000000 )
 924         {
 925             fmt.i_codec = VLC_FOURCC( 'R','V','4','0' );
 926         }
 927
 928         msg_Dbg( p_demux, "    - video %4.4s %dx%d",
 929                  (char*)&fmt.i_codec, fmt.video.i_width, fmt.video.i_height );
 930
 931         tk = malloc( sizeof( real_track_t ) );
 932         tk->i_out_subpacket = 0;
 933         tk->i_subpacket = 0;
 934         tk->i_subpackets = 0;
 935         tk->p_subpackets = NULL;
 936         tk->i_id = i_num;
 937         tk->fmt = fmt;
 938         tk->i_frame = 0;
 939         tk->p_frame = NULL;
 940         tk->p_es = es_out_Add( p_demux->out, &fmt );
 941
 942         TAB_APPEND( p_sys->i_track, p_sys->track, tk );
 943     }
 944     else if( !strncmp( (char *)p_peek, ".ra\xfd", 4 ) )
 945     {
 946         int i_version = GetWBE( &p_peek[4] );
 947         int i_header_size, i_flavor, i_coded_frame_size, i_subpacket_h;
 948         int i_frame_size, i_subpacket_size;
 949
 950         msg_Dbg( p_demux, "    - audio version=%d", i_version );
 951
 952         p_peek += 6;
 953         es_format_Init( &fmt, AUDIO_ES, 0 );
 954
 955         if( i_version == 3 )
 956         {
 957             msg_Dbg( p_demux, "    - audio version 3 is not supported!" );
 958             return VLC_EGENERIC;
 959         }
 960
 961         p_peek += 2; /* 00 00 */
 962         p_peek += 4; /* .ra4 or .ra5 */
 963         p_peek += 4; /* ?? */
 964         p_peek += 2; /* version (4 or 5) */
 965         i_header_size = GetDWBE( p_peek ); p_peek += 4; /* header size */
 966         i_flavor = GetWBE( p_peek ); p_peek += 2; /* codec flavor */
 967         i_coded_frame_size = GetDWBE( p_peek ); p_peek += 4;
 968         p_peek += 4; /* ?? */
 969         p_peek += 4; /* ?? */
 970         p_peek += 4; /* ?? */
 971         i_subpacket_h = GetWBE( p_peek ); p_peek += 2;
 972         i_frame_size = GetWBE( p_peek ); p_peek += 2;
 973         i_subpacket_size = GetWBE( p_peek ); p_peek += 2;
 974         p_peek += 2; /* ?? */
 975
 976         if( i_version == 5 ) p_peek += 6; /* 0, srate, 0 */
 977
 978         fmt.audio.i_rate = GetWBE( p_peek ); p_peek += 2;
 979         p_peek += 2; /* ?? */
 980         fmt.audio.i_bitspersample = GetWBE( p_peek ); p_peek += 2;
 981         fmt.audio.i_channels = GetWBE( p_peek ); p_peek += 2;
 982         fmt.audio.i_blockalign = i_frame_size;
 983
 984         if( i_version == 5 )
 985         {
 986             p_peek += 4; /* genr */
 987             memcpy( (char *)&fmt.i_codec, p_peek, 4 ); p_peek += 4;
 988         }
 989         else
 990         {
 991             p_peek += p_peek[0] + 1; /* descr 1 */
 992             memcpy( (char *)&fmt.i_codec, p_peek + 1, 4 ); /* descr 2 */
 993             p_peek += p_peek[0] + 1;
 994         }
 995
 996         msg_Dbg( p_demux, "    - audio codec=%4.4s channels=%d rate=%dHz",
 997                  (char*)&fmt.i_codec, fmt.audio.i_channels, fmt.audio.i_rate );
 998
 999         p_peek += 3; /* ?? */
1000         if( i_version == 5 ) p_peek++;
1001
1002         switch( fmt.i_codec )
1003         {
1004         case VLC_FOURCC( 'd', 'n', 'e', 't' ):
1005             fmt.i_codec = VLC_FOURCC( 'a', '5', '2', ' ' );
1006             break;
1007
1008         case VLC_FOURCC( 'r', 'a', 'a', 'c' ):
1009         case VLC_FOURCC( 'r', 'a', 'c', 'p' ):
1010             fmt.i_extra = GetDWBE( p_peek ); p_peek += 4;
1011             if( fmt.i_extra > 0 ) { fmt.i_extra--; p_peek++; }
1012             if( fmt.i_extra > 0 )
1013             {
1014                 fmt.p_extra = malloc( fmt.i_extra );
1015                 memcpy( fmt.p_extra, p_peek, fmt.i_extra );
1016             }
1017
1018             fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'a' );
1019             break;
1020
1021         case VLC_FOURCC('c','o','o','k'):
1022             fmt.audio.i_blockalign = i_subpacket_size;
1023             if( !(fmt.i_extra = GetDWBE( p_peek )) ) break;
1024             fmt.p_extra = malloc( fmt.i_extra );
1025             memcpy( fmt.p_extra, p_peek + 4, fmt.i_extra );
1026             break;
1027
1028         case VLC_FOURCC('2','8','_','8'):
1029             fmt.audio.i_blockalign = i_coded_frame_size;
1030             break;
1031
1032         default:
1033             msg_Dbg( p_demux, "    - unknown audio codec=%4.4s",
1034                      (char*)&fmt.i_codec );
1035             break;
1036         }
1037
1038         if( fmt.i_codec != 0 )
1039         {
1040             int i;
1041
1042             msg_Dbg( p_demux, "        - extra data=%d", fmt.i_extra );
1043
1044             tk = malloc( sizeof( real_track_t ) );
1045             tk->i_id = i_num;
1046             tk->fmt = fmt;
1047             tk->i_frame = 0;
1048             tk->p_frame = NULL;
1049
1050             tk->i_subpacket_h = i_subpacket_h;
1051             tk->i_subpacket_size = i_subpacket_size;
1052             tk->i_coded_frame_size = i_coded_frame_size;
1053             tk->i_frame_size = i_frame_size;
1054
1055             tk->i_out_subpacket = 0;
1056             tk->i_subpacket = 0;
1057             tk->i_subpackets = 0;
1058             tk->p_subpackets = NULL;
1059             if( fmt.i_codec == VLC_FOURCC('c','o','o','k') )
1060             {
1061                 tk->i_subpackets =
1062                     i_subpacket_h * i_frame_size / tk->i_subpacket_size;
1063                 tk->p_subpackets =
1064                     malloc( tk->i_subpackets * sizeof(block_t *) );
1065             }
1066             else if( fmt.i_codec == VLC_FOURCC('2','8','_','8') )
1067             {
1068                 tk->i_subpackets =
1069                     i_subpacket_h * i_frame_size / tk->i_coded_frame_size;
1070                 tk->p_subpackets =
1071                     malloc( tk->i_subpackets * sizeof(block_t *) );
1072             }
1073
1074             for( i = 0; i < tk->i_subpackets; i++ ) tk->p_subpackets[i] = NULL;
1075
1076             tk->p_es = es_out_Add( p_demux->out, &fmt );
1077
1078             TAB_APPEND( p_sys->i_track, p_sys->track, tk );
1079         }
1080     }
1081
1082     return VLC_SUCCESS;
1083 }