libmp4.c

来自「VLC媒体播放程序」· C语言 代码 · 共 2,060 行 · 第 1/5 页

             "read box: \"dcom\" compression algorithm : %4.4s",
                      (char*)&p_box->data.p_dcom->i_algorithm );
#endif
    MP4_READBOX_EXIT( 1 );
}

static int MP4_ReadBox_cmvd( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
{
    MP4_READBOX_ENTER( MP4_Box_data_cmvd_t );

    MP4_GET4BYTES( p_box->data.p_cmvd->i_uncompressed_size );

    p_box->data.p_cmvd->i_compressed_size = i_read;

    if( !( p_box->data.p_cmvd->p_data = malloc( i_read ) ) )
    {
        msg_Dbg( p_stream->p_input, "read box: \"cmvd\" not enough memory to load data" );
        return( 1 );
    }

    /* now copy compressed data */
    memcpy( p_box->data.p_cmvd->p_data,
            p_peek,
            i_read);

    p_box->data.p_cmvd->b_compressed = 1;

#ifdef MP4_VERBOSE
    msg_Dbg( p_stream->p_input, "read box: \"cmvd\" compressed data size %d",
                      p_box->data.p_cmvd->i_compressed_size );
#endif

    MP4_READBOX_EXIT( 1 );
}
static void MP4_FreeBox_cmvd( MP4_Box_t *p_box )
{
    FREE( p_box->data.p_cmvd->p_data );
}


static int MP4_ReadBox_cmov( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
{
    MP4_Stream_t *p_stream_memory;

    MP4_Box_t *p_dcom;
    MP4_Box_t *p_cmvd;
#ifdef HAVE_ZLIB_H
    z_stream  z_data;
#endif
    uint8_t *p_data;

    int i_result;

    if( !( p_box->data.p_cmov = malloc( sizeof( MP4_Box_data_cmov_t ) ) ) )
    {
        msg_Err( p_stream->p_input, "out of memory" );
        return( 0 );
    }
    memset( p_box->data.p_cmov, 0, sizeof( MP4_Box_data_cmov_t ) );

    if( !p_box->p_father ||
        ( p_box->p_father->i_type != FOURCC_moov && p_box->p_father->i_type != FOURCC_foov) )
    {
        msg_Warn( p_stream->p_input, "Read box: \"cmov\" box alone" );
        return( 1 );
    }

    if( !(i_result = MP4_ReadBoxContainer( p_stream, p_box ) ) )
    {
        return( 0 );
    }

    if( ( p_dcom = MP4_BoxGet( p_box, "dcom" ) ) == NULL ||
        ( p_cmvd = MP4_BoxGet( p_box, "cmvd" ) ) == NULL ||
        p_cmvd->data.p_cmvd->p_data == NULL )
    {
        msg_Warn( p_stream->p_input, "read box: \"cmov\" incomplete" );
        return( 1 );
    }

    if( p_dcom->data.p_dcom->i_algorithm != FOURCC_zlib )
    {
        msg_Dbg( p_stream->p_input, "read box: \"cmov\" compression algorithm : %4.4s not supported",
                    (char*)&p_dcom->data.p_dcom->i_algorithm );
        return( 1 );
    }

#ifndef HAVE_ZLIB_H
    msg_Dbg( p_stream->p_input,
             "read box: \"cmov\" zlib unsupported" );
    return( 1 );
#else
    /* decompress data */
    /* allocate a new buffer */
    if( !( p_data = malloc( p_cmvd->data.p_cmvd->i_uncompressed_size ) ) )
    {
        msg_Err( p_stream->p_input,
                 "read box: \"cmov\" not enough memory to uncompress data" );
        return( 1 );
    }
    /* init default structures */
    z_data.next_in   = p_cmvd->data.p_cmvd->p_data;
    z_data.avail_in  = p_cmvd->data.p_cmvd->i_compressed_size;
    z_data.next_out  = p_data;
    z_data.avail_out = p_cmvd->data.p_cmvd->i_uncompressed_size;
    z_data.zalloc    = (alloc_func)Z_NULL;
    z_data.zfree     = (free_func)Z_NULL;
    z_data.opaque    = (voidpf)Z_NULL;

    /* init zlib */
    if( ( i_result = inflateInit( &z_data ) ) != Z_OK )
    {
        msg_Err( p_stream->p_input,
                 "read box: \"cmov\" error while uncompressing data" );
        free( p_data );
        return( 1 );
    }

    /* uncompress */
    i_result = inflate( &z_data, Z_NO_FLUSH );
    if( ( i_result != Z_OK )&&( i_result != Z_STREAM_END ) )
    {
        msg_Err( p_stream->p_input,
                 "read box: \"cmov\" error while uncompressing data" );
        free( p_data );
        return( 1 );
    }

    if( p_cmvd->data.p_cmvd->i_uncompressed_size != z_data.total_out )
    {
        msg_Warn( p_stream->p_input,
                  "read box: \"cmov\" uncompressing data size mismatch" );
    }
    p_cmvd->data.p_cmvd->i_uncompressed_size = z_data.total_out;

    /* close zlib */
    i_result = inflateEnd( &z_data );
    if( i_result != Z_OK )
    {
        msg_Warn( p_stream->p_input,
           "read box: \"cmov\" error while uncompressing data (ignored)" );
    }


    free( p_cmvd->data.p_cmvd->p_data );
    p_cmvd->data.p_cmvd->p_data = p_data;
    p_cmvd->data.p_cmvd->b_compressed = 0;

    msg_Dbg( p_stream->p_input,
             "read box: \"cmov\" box succesfully uncompressed" );

    /* now create a memory stream */
    p_stream_memory = MP4_MemoryStream( p_stream->p_input,
                                        p_cmvd->data.p_cmvd->i_uncompressed_size,
                                        p_cmvd->data.p_cmvd->p_data );

    /* and read uncompressd moov */
    p_box->data.p_cmov->p_moov = MP4_ReadBox( p_stream_memory, NULL );

    free( p_stream_memory );

#ifdef MP4_VERBOSE
    msg_Dbg( p_stream->p_input,
             "read box: \"cmov\" compressed movie header completed" );
#endif
    return( p_box->data.p_cmov->p_moov ? 1 : 0 );
#endif /* HAVE_ZLIB_H */
}

static int MP4_ReadBox_rdrf( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
{
    uint32_t i_len;
    MP4_READBOX_ENTER( MP4_Box_data_rdrf_t );

    MP4_GETVERSIONFLAGS( p_box->data.p_rdrf );
    MP4_GETFOURCC( p_box->data.p_rdrf->i_ref_type );
    MP4_GET4BYTES( i_len );
    if( i_len > 0 )
    {
        uint32_t i;
        p_box->data.p_rdrf->psz_ref = malloc( i_len  + 1);
        for( i = 0; i < i_len; i++ )
        {
            MP4_GET1BYTE( p_box->data.p_rdrf->psz_ref[i] );
        }
        p_box->data.p_rdrf->psz_ref[i_len] = '\0';
    }
    else
    {
        p_box->data.p_rdrf->psz_ref = NULL;
    }

#ifdef MP4_VERBOSE
    msg_Dbg( p_stream->p_input,
             "read box: \"rdrf\" type:%4.4s ref %s",
             (char*)&p_box->data.p_rdrf->i_ref_type,
             p_box->data.p_rdrf->psz_ref );

#endif
    MP4_READBOX_EXIT( 1 );
}

static void MP4_FreeBox_rdrf( MP4_Box_t *p_box )
{
    FREE( p_box->data.p_rdrf->psz_ref )
}


static int MP4_ReadBox_rmdr( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
{
    MP4_READBOX_ENTER( MP4_Box_data_rmdr_t );

    MP4_GETVERSIONFLAGS( p_box->data.p_rmdr );

    MP4_GET4BYTES( p_box->data.p_rmdr->i_rate );

#ifdef MP4_VERBOSE
    msg_Dbg( p_stream->p_input,
             "read box: \"rmdr\" rate:%d",
             p_box->data.p_rmdr->i_rate );
#endif
    MP4_READBOX_EXIT( 1 );
}

static int MP4_ReadBox_rmqu( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
{
    MP4_READBOX_ENTER( MP4_Box_data_rmqu_t );

    MP4_GET4BYTES( p_box->data.p_rmqu->i_quality );

#ifdef MP4_VERBOSE
    msg_Dbg( p_stream->p_input,
             "read box: \"rmqu\" quality:%d",
             p_box->data.p_rmqu->i_quality );
#endif
    MP4_READBOX_EXIT( 1 );
}

static int MP4_ReadBox_rmvc( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
{
    MP4_READBOX_ENTER( MP4_Box_data_rmvc_t );
    MP4_GETVERSIONFLAGS( p_box->data.p_rmvc );

    MP4_GETFOURCC( p_box->data.p_rmvc->i_gestaltType );
    MP4_GET4BYTES( p_box->data.p_rmvc->i_val1 );
    MP4_GET4BYTES( p_box->data.p_rmvc->i_val2 );
    MP4_GET2BYTES( p_box->data.p_rmvc->i_checkType );

#ifdef MP4_VERBOSE
    msg_Dbg( p_stream->p_input,
             "read box: \"rmvc\" gestaltType:%4.4s val1:0x%x val2:0x%x checkType:0x%x",
             (char*)&p_box->data.p_rmvc->i_gestaltType,
             p_box->data.p_rmvc->i_val1,p_box->data.p_rmvc->i_val2,
             p_box->data.p_rmvc->i_checkType );
#endif

    MP4_READBOX_EXIT( 1 );
}

static int MP4_ReadBox_drms( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
{
    MP4_Box_t *p_drms_box = p_box;

    MP4_READBOX_ENTER( uint8_t );

    do
    {
        p_drms_box = p_drms_box->p_father;
    } while( p_drms_box && p_drms_box->i_type != FOURCC_drms );

    if( p_drms_box && p_drms_box->data.p_sample_soun->p_drms )
    {
        if( drms_init( p_drms_box->data.p_sample_soun->p_drms,
                       p_box->i_type, p_peek, i_read ) )
        {
            msg_Err( p_stream->p_input, "drms_init( %4.4s ) failed",
                     (char *)&p_box->i_type );

            drms_free( p_drms_box->data.p_sample_soun->p_drms );
            p_drms_box->data.p_sample_soun->p_drms = NULL;
        }
    }

    MP4_READBOX_EXIT( 1 );
}


/**** ------------------------------------------------------------------- ****/
/****                   "Higher level" Functions                          ****/
/**** ------------------------------------------------------------------- ****/

static struct
{
    uint32_t i_type;
    int  (*MP4_ReadBox_function )( MP4_Stream_t *p_stream, MP4_Box_t *p_box );
    void (*MP4_FreeBox_function )( MP4_Box_t *p_box );
} MP4_Box_Function [] =
{
    /* Containers */
    { FOURCC_moov,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_trak,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_mdia,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_moof,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_minf,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_stbl,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_dinf,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_edts,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_udta,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_nmhd,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_hnti,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_rmra,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_rmda,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_tref,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_gmhd,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
    { FOURCC_wave,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },

    /* specific box */
    { FOURCC_ftyp,  MP4_ReadBox_ftyp,       MP4_FreeBox_ftyp },
    { FOURCC_cmov,  MP4_ReadBox_cmov,       MP4_FreeBox_Common },
    { FOURCC_mvhd,  MP4_ReadBox_mvhd,       MP4_FreeBox_Common },
    { FOURCC_tkhd,  MP4_ReadBox_tkhd,       MP4_FreeBox_Common },
    { FOURCC_mdhd,  MP4_ReadBox_mdhd,       MP4_FreeBox_Common },
    { FOURCC_hdlr,  MP4_ReadBox_hdlr,       MP4_FreeBox_hdlr },
    { FOURCC_vmhd,  MP4_ReadBox_vmhd,       MP4_FreeBox_Common },
    { FOURCC_smhd,  MP4_ReadBox_smhd,       MP4_FreeBox_Common },
    { FOURCC_hmhd,  MP4_ReadBox_hmhd,       MP4_FreeBox_Common },
    { FOURCC_url,   MP4_ReadBox_url,        MP4_FreeBox_url },
    { FOURCC_urn,   MP4_ReadBox_urn,        MP4_FreeBox_urn },
    { FOURCC_dref,  MP4_ReadBox_dref,       MP4_FreeBox_Common },
    { FOURCC_stts,  MP4_ReadBox_stts,       MP4_FreeBox_stts },
    { FOURCC_ctts,  MP4_ReadBox_ctts,       MP4_FreeBox_ctts },
    { FOURCC_stsd,  MP4_ReadBox_stsd,       MP4_FreeBox_Common },
    { FOURCC_stsz,  MP4_ReadBox_stsz,       MP4_FreeBox_stsz },
    { FOURCC_stsc,  MP4_ReadBox_stsc,       MP4_FreeBox_stsc },
    { FOURCC_stco,  MP4_ReadBox_stco_co64,  MP4_FreeBox_stco_co64 },
    { FOURCC_co64,  MP4_ReadBox_stco_co64,  MP4_FreeBox_stco_co64 },
    { FOURCC_stss,  MP4_ReadBox_stss,       MP4_FreeBox_stss },
    { FOURCC_stsh,  MP4_ReadBox_stsh,       MP4_FreeBox_stsh },
    { FOURCC_stdp,  MP4_ReadBox_stdp,       MP4_FreeBox_stdp },
    { FOURCC_padb,  MP4_ReadBox_padb,       MP4_FreeBox_padb },
    { FOURCC_elst,  MP4_ReadBox_elst,       MP4_FreeBox_elst },
    { FOURCC_cprt,  MP4_ReadBox_cprt,       MP4_FreeBox_cprt },
    { FOURCC_esds,  MP4_ReadBox_esds,       MP4_FreeBox_esds },
    { FOURCC_dcom,  MP4_ReadBox_dcom,       MP4_FreeBox_Common },
    { FOURCC_cmvd,  MP4_ReadBox_cmvd,       MP4_FreeBox_cmvd },

    /* Nothing to do with this box */
    { FOURCC_mdat,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
    { FOURCC_skip,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
    { FOURCC_free,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
    { FOURCC_wide,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },

    /* for codecs */
    { FOURCC_soun,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_ms02,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_ms11,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_ms55,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC__mp3,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_mp4a,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_twos,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_sowt,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_QDMC,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_QDM2,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_ima4,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_IMA4,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_dvi,   MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_alaw,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_ulaw,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_raw,   MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_MAC3,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_MAC6,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_Qclp,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_samr,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
    { FOURCC_OggS,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },

    { FOURCC_vide,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_mp4v,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_SVQ1,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_SVQ3,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_ZyGo,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_DIVX,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_h263,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_s263,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_cvid,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_3IV1,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_3iv1,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_3IV2,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_3iv2,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_3IVD,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_3ivd,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_3VID,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_3vid,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_mjpa,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_mjpb,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_mjqt,  NULL,                       NULL }, /* found in mjpa/b */
    { FOURCC_mjht,  NULL,                       NULL },
    { FOURCC_dvc,   MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_dvp,   MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_VP31,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
    { FOURCC_vp31,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },

    { FOURCC_jpeg,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },

    { FOURCC_mp4s,  NULL,                       MP4_FreeBox_Common },

    /* XXX there is 2 box where we could find this entry stbl and tref*/
    { FOURCC_hint,  NULL,                       MP4_FreeBox_Common },

    /* found in tref box */
    { FOURCC_dpnd,  NULL,   NULL },
    { FOURCC_ipir,  NULL,   NULL },