real.c

VLC Player Source Code

                i_seqnum = *p++;
            }

            i_copy = i_len - i_offset;
            if( i_copy > &p_sys->buffer[i_size] - p )
            {
                i_copy = &p_sys->buffer[i_size] - p;
            }
            else if( i_copy < 0 )
            {
                break;
            }

            msg_Dbg( p_demux, "    - len=%d offset=%d size=%d subseq=%d seqnum=%d",
                     i_len, i_offset, i_copy, i_subseq, i_seqnum );

            if( (h&0xc0) == 0x80 )
            {
                /* last fragment -> fixes */
                i_copy = i_offset;
                i_offset = i_len - i_copy;
                msg_Dbg( p_demux, "last fixing copy=%d offset=%d",
                         i_copy, i_offset );
            }

            if( tk->p_frame &&
                ( tk->p_frame->i_dts != i_pts ||
                  tk->i_frame != i_len ) )
            {
                msg_Dbg( p_demux, "sending size=%zu", tk->p_frame->i_buffer );

                es_out_Send( p_demux->out, tk->p_es, tk->p_frame );

                tk->i_frame = 0;
                tk->p_frame = NULL;
            }

            if( (h&0xc0) != 0x80 && (h&0xc0) != 0x00 && !tk->p_frame )
            {
                /* no fragment */
                i_len = i_copy;
                i_offset = 0;
            }


            if( tk->p_frame == NULL )
            {
                msg_Dbg( p_demux, "new frame size=%d", i_len );
                tk->i_frame = i_len;
                if( !( tk->p_frame = block_New( p_demux, i_len + 8 + 1000) ) )
                {
                    return -1;
                }
                memset( &tk->p_frame->p_buffer[8], 0, i_len );
                tk->p_frame->i_dts = i_pts;
                tk->p_frame->i_pts = i_pts;

                ((uint32_t*)tk->p_frame->p_buffer)[0] = i_len;  /* len */
                ((uint32_t*)tk->p_frame->p_buffer)[1] = 0;      /* chunk counts */
            }

            if( i_offset < tk->i_frame)
            {
                int i_ck = ((uint32_t*)tk->p_frame->p_buffer)[1]++;

                msg_Dbg( p_demux, "copying new buffer n=%d offset=%d copy=%d",
                         i_ck, i_offset, i_copy );

                ((uint32_t*)(tk->p_frame->p_buffer+i_len+8))[i_ck*2 +0 ] = 1;
                ((uint32_t*)(tk->p_frame->p_buffer+i_len+8))[i_ck*2 +1 ] = i_offset;


                memcpy( &tk->p_frame->p_buffer[i_offset + 8], p, i_copy );
            }

            p += i_copy;

            if( (h&0xc0) != 0x80 )
            {
                break;
            }

#if 0
            if( tk->p_frame )
            {
                /* append data */
                int i_ck = ((uint32_t*)tk->p_frame->p_buffer)[1]++;

                if( (h&0xc0) == 0x80 )
                {
                    /* last fragment */
                    i_copy = i_offset;
                    i_offset = i_len - i_offset;

                    ((uint32_t*)(tk->p_frame->p_buffer+i_len+8))[i_ck] = i_offset;
                    memcpy( &tk->p_frame->p_buffer[i_offset+ 8], p, i_copy );
                    p += i_copy;

                    if( p_sys->i_pcr < tk->p_frame->i_dts )
                    {
                        p_sys->i_pcr = tk->p_frame->i_dts;
                        es_out_Control( p_demux->out, ES_OUT_SET_PCR,
                                        (int64_t)p_sys->i_pcr );
                    }
                    es_out_Send( p_demux->out, tk->p_es, tk->p_frame );

                    tk->i_frame = 0;
                    tk->p_frame = NULL;

                    continue;
                }

                ((uint32_t*)(tk->p_frame->p_buffer+i_len+8))[i_ck] = i_offset;
                memcpy( &tk->p_frame->p_buffer[i_offset + 8], p, i_copy );
                break;
            }

            if( (h&0xc0) != 0x00 )
            {
                block_t *p_frame;

                /* not fragmented */
                if( !( p_frame = block_New( p_demux, i_copy + 8 + 8 ) ) )
                {
                    return -1;
                }
                p_frame->i_dts = i_pts;
                p_frame->i_pts = i_pts;

                ((uint32_t*)p_frame->p_buffer)[0] = i_copy;
                ((uint32_t*)p_frame->p_buffer)[1] = 1;
                ((uint32_t*)(p_frame->p_buffer+i_copy+8))[0] = 0;
                memcpy( &p_frame->p_buffer[8], p, i_copy );

                p += i_copy;

                if( p_sys->i_pcr < p_frame->i_dts )
                {
                    p_sys->i_pcr = p_frame->i_dts;
                    es_out_Control( p_demux->out, ES_OUT_SET_PCR,
                                    (int64_t)p_sys->i_pcr );
                }
                es_out_Send( p_demux->out, tk->p_es, p_frame );
            }
            else
            {
                /* First fragment */
                tk->i_frame = i_len;
                if( !( tk->p_frame = block_New( p_demux, i_len + 8 + 1000) ) )
                {
                    return -1;
                }
                memset( &tk->p_frame->p_buffer[8], 0, i_len );
                tk->p_frame->i_dts = i_pts;
                tk->p_frame->i_pts = i_pts;

                ((uint32_t*)tk->p_frame->p_buffer)[0] = i_len;  /* len */
                ((uint32_t*)tk->p_frame->p_buffer)[1] = 1;      /* chunk counts */
                ((uint32_t*)(tk->p_frame->p_buffer+i_len+8))[0] = i_offset;
                memcpy( &tk->p_frame->p_buffer[i_offset + 8], p, i_copy );

                break;
            }
#endif
        }
    }
    else if( tk->fmt.i_cat == AUDIO_ES && b_selected )
    {
        if( tk->fmt.i_codec == VLC_FOURCC( 'c', 'o', 'o', 'k' ) ||
            tk->fmt.i_codec == VLC_FOURCC( 'a', 't', 'r', 'c') ||
            tk->fmt.i_codec == VLC_FOURCC( 's', 'i', 'p', 'r') ||
            tk->fmt.i_codec == VLC_FOURCC( '2', '8', '_', '8') )
        {
            uint8_t *p_buf = p_sys->buffer;
            int y = tk->i_subpacket / ( tk->i_frame_size /tk->i_subpacket_size);
            int i_index, i;

            /* Sanity check */
            if( i_flags & 2 || ( p_sys->b_seek ) )
            {
                y = tk->i_subpacket = 0;
                tk->i_out_subpacket = 0;
                p_sys->b_seek = 0;
            }

            if( tk->fmt.i_codec == VLC_FOURCC( 'c', 'o', 'o', 'k' ) ||
                tk->fmt.i_codec == VLC_FOURCC( 'a', 't', 'r', 'c' ))
            {
                int num = tk->i_frame_size / tk->i_subpacket_size;
                for( i = 0; i <  num; i++ )
                {
                    block_t *p_block = block_New( p_demux, tk->i_subpacket_size );
                    memcpy( p_block->p_buffer, p_buf, tk->i_subpacket_size );
                    p_buf += tk->i_subpacket_size;

                    i_index = tk->i_subpacket_h * i +
                        ((tk->i_subpacket_h + 1) / 2) * (y&1) + (y>>1);

                    if ( tk->p_subpackets[i_index]  != NULL )
                    {
                        msg_Dbg(p_demux, "p_subpackets[ %d ] not null!",  i_index );
                        free( tk->p_subpackets[i_index] );
                    }

                    tk->p_subpackets[i_index] = p_block;
                    tk->i_subpacket++;
                    p_block->i_dts = p_block->i_pts = 0;
                }
                tk->p_subpackets_timecode[tk->i_subpacket - num] = i_pts;
            }

            if( tk->fmt.i_codec == VLC_FOURCC( '2', '8', '_', '8' ) ||
                tk->fmt.i_codec == VLC_FOURCC( 's', 'i', 'p', 'r' ) )
            for( i = 0; i < tk->i_subpacket_h / 2; i++ )
            {
                block_t *p_block = block_New( p_demux, tk->i_coded_frame_size);
                memcpy( p_block->p_buffer, p_buf, tk->i_coded_frame_size );
                p_buf += tk->i_coded_frame_size;

                i_index = (i * 2 * tk->i_frame_size) /
                    tk->i_coded_frame_size + y;

                p_block->i_dts = p_block->i_pts = i_pts;
                tk->p_subpackets[i_index] = p_block;
                tk->i_subpacket++;
            }

            while( tk->i_out_subpacket != tk->i_subpackets &&
                   tk->p_subpackets[tk->i_out_subpacket] )
            {
                /* Set the PCR */
#if 0
                if (tk->i_out_subpacket == 0)
                {
                    p_sys->i_pcr = tk->p_subpackets[tk->i_out_subpacket]->i_dts;
                    es_out_Control( p_demux->out, ES_OUT_SET_PCR,
                            (int64_t)p_sys->i_pcr );
                }

                block_t *p_block = tk->p_subpackets[tk->i_out_subpacket];
                tk->p_subpackets[tk->i_out_subpacket] = 0;

                if( tk->i_out_subpacket ) p_block->i_dts = p_block->i_pts = 0;
#endif

                block_t *p_block = tk->p_subpackets[tk->i_out_subpacket];
                tk->p_subpackets[tk->i_out_subpacket] = 0;
                if ( tk->p_subpackets_timecode[tk->i_out_subpacket]  )
                {
                    p_block->i_dts = p_block->i_pts =
                        tk->p_subpackets_timecode[tk->i_out_subpacket];
                    tk->p_subpackets_timecode[tk->i_out_subpacket] = 0;

                    p_sys->i_pcr = p_block->i_dts;
                    es_out_Control( p_demux->out, ES_OUT_SET_PCR,
                            (int64_t)p_sys->i_pcr );
                }
                es_out_Send( p_demux->out, tk->p_es, p_block );

                tk->i_out_subpacket++;
            }

            if( tk->i_subpacket == tk->i_subpackets &&
                tk->i_out_subpacket != tk->i_subpackets )
            {
                msg_Warn( p_demux, "i_subpacket != i_out_subpacket, "
                          "this shouldn't happen" );
            }

            if( tk->i_subpacket == tk->i_subpackets )
            {
                tk->i_subpacket = 0;
                tk->i_out_subpacket = 0;
            }
        }
        else
        {
            /* Set PCR */
            if( p_sys->i_pcr < i_pts )
            {
                p_sys->i_pcr = i_pts;
                es_out_Control( p_demux->out, ES_OUT_SET_PCR,
                        (int64_t)p_sys->i_pcr );
            }

            if( tk->fmt.i_codec == VLC_FOURCC( 'm','p','4','a' ) )
            {
                int     i_sub = (p_sys->buffer[1] >> 4)&0x0f;
                uint8_t *p_sub = &p_sys->buffer[2+2*i_sub];

                int i;
                for( i = 0; i < i_sub; i++ )
                {
                    int i_sub_size = GetWBE( &p_sys->buffer[2+i*2]);
                    block_t *p_block = block_New( p_demux, i_sub_size );
                    if( p_block )
                    {
                        memcpy( p_block->p_buffer, p_sub, i_sub_size );
                        p_sub += i_sub_size;

                        p_block->i_dts =
                            p_block->i_pts = ( i == 0 ? i_pts : 0 );

                        es_out_Send( p_demux->out, tk->p_es, p_block );
                    }
                }
            }
            else
            {
                block_t *p_block = block_New( p_demux, i_size );

                if( tk->fmt.i_codec == VLC_FOURCC( 'a', '5', '2', ' ' ) )
                {
                    uint8_t *src = p_sys->buffer;
                    uint8_t *dst = p_block->p_buffer;

                    /* byte swap data */
                    while( dst < &p_block->p_buffer[i_size- 1])
                    {
                        *dst++ = src[1];
                        *dst++ = src[0];

                        src += 2;
                    }
                }
                else
                {
                    memcpy( p_block->p_buffer, p_sys->buffer, i_size );
                }
                p_block->i_dts = p_block->i_pts = i_pts;
                es_out_Send( p_demux->out, tk->p_es, p_block );
            }
        }
    }


    return 1;
}

/*****************************************************************************
 * Control:
 *****************************************************************************/
static int Control( demux_t *p_demux, int i_query, va_list args )
{
    demux_sys_t *p_sys = p_demux->p_sys;
    double f, *pf;
    int64_t i64;
    rm_index_t * p_index;
    int64_t *pi64;

    switch( i_query )
    {
        case DEMUX_GET_POSITION:
            pf = (double*) va_arg( args, double* );

            if( p_sys->i_our_duration > 0 )
            {
                *pf = (double)p_sys->i_pcr / 1000.0 / p_sys->i_our_duration;
                return VLC_SUCCESS;
            }

            /* read stream size maybe failed in rtsp streaming, 
               so use duration to determin the position at first  */
            i64 = stream_Size( p_demux->s );
            if( i64 > 0 )
            {
                *pf = (double)1.0*stream_Tell( p_demux->s ) / (double)i64;
            }
            else
            {
                *pf = 0.0;
            }
            return VLC_SUCCESS;

        case DEMUX_GET_TIME:
            pi64 = (int64_t*)va_arg( args, int64_t * );

            if( p_sys->i_our_duration > 0 )
            {
                *pi64 = p_sys->i_pcr;
                return VLC_SUCCESS;
            }

            /* same as GET_POSTION */
            i64 = stream_Size( p_demux->s );
            if( p_sys->i_our_duration > 0 && i64 > 0 )
            {