umc_mp4_parser_w.cpp

audio-video-codecs.rar语音编解码器

    Write_mp4_descr_length(dw, 13 + (5 + esds->decoderConfigLen));
    result = Write_8(dw, esds->objectTypeID);
    result = Write_8(dw, esds->streamType);
    result = Write_24(dw, esds->bufferSizeDB);
    result = Write_32(dw, esds->maxBitrate);
    result = Write_32(dw, esds->avgBitrate);
    result = Write_8(dw, 0x05);
    Write_mp4_descr_length(dw, esds->decoderConfigLen);
    result = Write_data(dw, (Ipp8s*)esds->decoderConfig, esds->decoderConfigLen);
// SL
    result = Write_8(dw, 0x06);
    result = Write_8(dw, 0x01);
    result = Write_8(dw, 0x02);
    return result;
}

UMC::Status Write_avcC(UMC::DataWriter *dw, TM_esds_data *esds)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = esds->decoderConfigLen + 8;
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"avcC");
    result = Write_data(dw, (Ipp8s*)esds->decoderConfig, esds->decoderConfigLen);
    return result;
}

UMC::Status Write_stsd_audio(UMC::DataWriter *dw, TM_stsd_table_data *table)
{
    UMC::Status    result;

    result = Write_32(dw, 0);
    result = Write_32(dw, 0);
    result = Write_16(dw, table->channels);
    result = Write_16(dw, table->sample_size);
    result = Write_32(dw, 0);
    result = Write_32(dw, table->sample_rate << 16);
    result = Write_esds(dw, &(table->esds));
    return result;
}

UMC::Status Write_stsd_video(UMC::DataWriter *dw, TM_stsd_table_data *table)
{
    UMC::Status    result;
    Ipp32s i;

    result = Write_32(dw, 0);
    result = Write_32(dw, 0);
    result = Write_32(dw, 0);
    result = Write_32(dw, 0);
    result = Write_16(dw, table->width);
    result = Write_16(dw, table->height);
    result = Write_32(dw, 0x00480000);
    result = Write_32(dw, 0x00480000);
    result = Write_32(dw, 0);
    result = Write_16(dw, 1);
    for (i = 0; i < 32; i++)
    {
        result = Write_8(dw, 0);
    }
    //result = Write_data(dw, "________________________________", 32);
    result = Write_16(dw, 0x0018);
    result = Write_16(dw, 0xffff);
    result = Write_esds(dw, &(table->esds));
    return result;
}

UMC::Status Write_h264_video(UMC::DataWriter *dw, TM_stsd_table_data *table)
{
    UMC::Status    result;
    Ipp32s i;

    result = Write_32(dw, 0);
    result = Write_32(dw, 0);
    result = Write_32(dw, 0);
    result = Write_32(dw, 0);
    result = Write_16(dw, table->width);
    result = Write_16(dw, table->height);
    result = Write_32(dw, 0x00480000);
    result = Write_32(dw, 0x00480000);
    result = Write_32(dw, 0);
    result = Write_16(dw, 1);
    for (i = 0; i < 32; i++)
    {
        result = Write_8(dw, 0);
    }
    //result = Write_data(dw, "________________________________", 32);
    result = Write_16(dw, 0x0018);
    result = Write_16(dw, 0xffff);
    result = Write_avcC(dw, &(table->esds));
    return result;
}

UMC::Status Write_stsd_table(UMC::DataWriter *dw, TM_stsd_table_data *table)
{
    TM_atom_mp4  atom;
    UMC::Status  result = UMC::UMC_OK;

    atom.size = table->size_atom;
    if ( table->format[0] == 'm' && table->format[1] == 'p' && table->format[2] == '4' && table->format[3] == 'a' )
    {
        result = Write_AtomHeader(dw, &atom, (Ipp8s *)"mp4a");
        result = Write_32(dw, 0); // table->reserved
        result = Write_16(dw, 0); // table->reserved
        result = Write_16(dw, table->data_reference);
        result = Write_stsd_audio(dw, table);
    }
    if ( table->format[0] == 'm' && table->format[1] == 'p' && table->format[2] == '4' && table->format[3] == 'v' )
    {
        result = Write_AtomHeader(dw, &atom, (Ipp8s *)"mp4v");
        result = Write_32(dw, 0); // table->reserved
        result = Write_16(dw, 0); // table->reserved
        result = Write_16(dw, table->data_reference);
        result = Write_stsd_video(dw, table);
    }
    if ( table->format[0] == 'a' && table->format[1] == 'v' && table->format[2] == 'c' && table->format[3] == '1' )
    {
        result = Write_AtomHeader(dw, &atom, (Ipp8s *)"avc1");
        result = Write_32(dw, 0); // table->reserved
        result = Write_16(dw, 0); // table->reserved
        result = Write_16(dw, table->data_reference);
        result = Write_h264_video(dw, table);
    }

    return result;
}

UMC::Status Write_stsd(UMC::DataWriter *dw, TM_stsd_data *stsd)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

    atom.size = stsd->size_atom;//100 138
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"stsd");
    result = Write_8(dw, stsd->version);
    result = Write_24(dw, stsd->flags);
    result = Write_32(dw, stsd->total_entries);
    for ( i = 0; i < stsd->total_entries; i++ )
    {
        result = Write_stsd_table(dw, &(stsd->table[i]));
    }
    return result;
}

UMC::Status Write_stsz(UMC::DataWriter *dw, TM_stsz_data *stsz)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

    atom.size = stsz->size_atom;//10960 7012
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"stsz");
    result = Write_8(dw, stsz->version);
    result = Write_24(dw, stsz->flags);
    result = Write_32(dw, stsz->sample_size);
    result = Write_32(dw, stsz->total_entries);
    if ( !stsz->sample_size ) {
        for ( i = 0; i < stsz->total_entries; i++ ) {
            result = Write_32(dw, stsz->table[i].size);
        }
    }
    return result;
}

UMC::Status Write_stco(UMC::DataWriter *dw, TM_stco_data *stco)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

    atom.size = stco->size_atom;//10956 7008
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"stco");
    result = Write_8(dw, stco->version);
    result = Write_24(dw, stco->flags);
    result = Write_32(dw, stco->total_entries);
    for ( i = 0; i < stco->total_entries; i++ )
    {
           result = Write_32(dw, stco->table[i].offset);
    }
    return result;
}

UMC::Status Write_stsc(UMC::DataWriter *dw, TM_stsc_data *stsc)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

    atom.size = stsc->size_atom;//32836 20992
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"stsc");
    result = Write_8(dw, stsc->version);
    result = Write_24(dw, stsc->flags);
    result = Write_32(dw, stsc->total_entries);

    for ( i = 0; i < stsc->total_entries; i++ )
    {
        result = Write_32(dw, stsc->table[i].chunk);
        result = Write_32(dw, stsc->table[i].samples);
        result = Write_32(dw, stsc->table[i].id);
    }
    return result;
}

UMC::Status Write_stbl(UMC::DataWriter *dw, TM_stbl_data *stbl)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = stbl->size_atom;//54900 46206
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"stbl");
    result = Write_stts(dw, &(stbl->stts));
    if (stbl->ctts.total_entries)
      result = Write_ctts(dw, &(stbl->ctts));
    result = Write_stsd(dw, &(stbl->stsd));
    result = Write_stsz(dw, &(stbl->stsz));
    result = Write_stco(dw, &(stbl->stco));
    result = Write_stsc(dw, &(stbl->stsc));
    result = Write_stss(dw, &(stbl->stss));
    return result;
}

UMC::Status Write_stss(UMC::DataWriter *dw, TM_stss_data *stss)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

    atom.size = stss->size_atom;//16  1016
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"stss");
    result = Write_8(dw, stss->version);
    result = Write_24(dw, stss->flags);
    result = Write_32(dw, stss->total_entries);

    for ( i = 0; i < stss->total_entries; i++ )
    {
        result = Write_32(dw, stss->table[i].sample + 1);
    }
    return result;
}

UMC::Status Write_vmhd(UMC::DataWriter *dw, TM_vmhd_data *vmhd)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = vmhd->size_atom;//20
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"vmhd");
    result = Write_8(dw, vmhd->version);
    result = Write_24(dw, vmhd->flags);
    result = Write_16(dw, 0);
    result = Write_16(dw, 0);
    result = Write_16(dw, 0);
    result = Write_16(dw, 0);
    return result;
}

UMC::Status Write_smhd(UMC::DataWriter *dw, TM_smhd_data *smhd)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = smhd->size_atom;//16
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"smhd");
    result = Write_8(dw, smhd->version);
    result = Write_24(dw, smhd->flags);
    result = Write_16(dw, 0);
    result = Write_16(dw, 0);
    return result;
}

UMC::Status Write_minf(UMC::DataWriter *dw, TM_minf_data *minf)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = minf->size_atom;//54960 46270
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"minf");
//    result = Write_dinf(dw, &(minf->dinf));
//    result = Write_stbl(dw, &(minf->stbl));
    if ( minf->is_video ) {
        result = Write_vmhd(dw, &(minf->vmhd));
    }
    if ( minf->is_audio ) {
        result = Write_smhd(dw, &(minf->smhd));
    }

    result = Write_dinf(dw, &(minf->dinf));
    result = Write_stbl(dw, &(minf->stbl));

    return result;
}

UMC::Status Write_mdia(UMC::DataWriter *dw, TM_mdia_data *mdia)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = mdia->size_atom;//55058 46368
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"mdia");
    result = Write_mdhd(dw, &(mdia->mdhd));
    result = Write_hdlr(dw, &(mdia->hdlr));
    result = Write_minf(dw, &(mdia->minf));
    return result;
}
UMC::Status Write_trak(UMC::DataWriter *dw, TM_trak_data *trak)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = trak->size_atom;//55158 46468
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"trak");
    result = Write_tkhd(dw, &(trak->tkhd));
    result = Write_mdia(dw, &(trak->mdia));
    return result;
}
UMC::Status Write_mvex(UMC::DataWriter *dw, TM_mvex *mvex)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u i;

    atom.size = mvex->size_atom;
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"mvex");

    atom.size -= 8;
    atom.size /= mvex->total_tracks;
    for (i = 0; i< mvex->total_tracks; i++ )
    {
        result = Write_AtomHeader(dw, &atom, (Ipp8s *)"trex");
        result = Write_8(dw, 0);
        result = Write_24(dw, 0);
        result = Write_32(dw, i + 1);
        result = Write_32(dw, 0);
        result = Write_32(dw, 0);
        result = Write_32(dw, 0);
        result = Write_32(dw, 0);
    }

    return result;
}

void Write_head(UMC::DataWriter *dw)
{
    Write_24(dw, 0x00);
    Write_8(dw, 0x18);
    Write_8(dw, 'f');
    Write_8(dw, 't');
    Write_8(dw, 'y');
    Write_8(dw, 'p');
    Write_8(dw, 'm');
    Write_8(dw, 'p');
    Write_8(dw, '4');
    Write_8(dw, '1');
    Write_24(dw, 0x00);
    Write_8(dw, 0x01);
    Write_8(dw, 'm');
    Write_8(dw, 'p');
    Write_8(dw, '4');
    Write_8(dw, '1');
    Write_8(dw, 'i');
    Write_8(dw, 's');
    Write_8(dw, 'o');
    Write_8(dw, 'm');

}

UMC::Status Write_moov(UMC::DataWriter *dw, TM_moov *moov)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

    atom.size = moov->size_atom;//101766
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"moov");
    result = Write_mvhd(dw, &(moov->mvhd));
    result = Write_iods(dw, &(moov->iods));
    for ( i = 0; i < moov->total_tracks; i++ ) {
        result = Write_trak(dw, moov->trak[i]);
    }
    return result;
}

UMC::Status Write_moof(UMC::DataWriter *dw, TM_moof *moof)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

    atom.size = moof->size_atom;
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"moof");

    atom.size = 16;
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"mfhd");
    Write_32(dw, 0x00);
    Write_32(dw, moof->sequence_number);

    for (i = 0; i < moof->total_tracks; i++)
    {
        atom.size = 8;
        atom.size += (8 + 4 + 4);
        atom.size += (8 + 4 + 4 + moof->trun[i].entry_count * 8);
        result = Write_AtomHeader(dw, &atom, (Ipp8s *)"traf");

        atom.size = (8 + 4 + 4);
        result = Write_AtomHeader(dw, &atom, (Ipp8s *)"tfhd");
        Write_8(dw, 0x00);
        Write_24(dw, 0x00);
        Write_32(dw, i + 1);

        atom.size = (8 + 4 + 4 + moof->trun[i].entry_count * 8);
        result = Write_AtomHeader(dw, &atom, (Ipp8s *)"trun");
        Write_8(dw, 0x00);
        Write_24(dw, 0x100 | 0x200);
        Write_32(dw, moof->trun[i].entry_count);
        for (Ipp32u j = 0; j < moof->trun[i].entry_count; j++)
        {
            Write_32(dw, moof->trun[i].trun[j].sample_duration);
            Write_32(dw, moof->trun[i].trun[j].sample_size);
        }
    }

    return result;
}