umc_mp4_parser_w.cpp

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

/*//////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2003-2007 Intel Corporation. All Rights Reserved.
//
*/
#include "umc_mp4_parser_w.h"

UMC::Status Write_data(UMC::DataWriter *dw, Ipp8s *data, Ipp32s size)
{
    UMC::Status    ret;
    Ipp32s         temp = size;

    ret = dw->PutData(data, temp);
    ret = ((size != temp) ? UMC::UMC_ERR_FAILED : UMC::UMC_OK);
    return ret;
}

UMC::Status Write_32(UMC::DataWriter *dw, Ipp32s value)
{
    Ipp8u       data_char[4];
    UMC::Status ret;
    Ipp32s      size = 4;

    data_char[0] = (Ipp8u)((value >> 24) & 0xff);
    data_char[1] = (Ipp8u)((value >> 16) & 0xff);
    data_char[2] = (Ipp8u)((value >> 8) & 0xff);
    data_char[3] = (Ipp8u)(value & 0xff);
    ret = dw->PutData(data_char, size);
    ret = (size != 4) ? UMC::UMC_ERR_FAILED : UMC::UMC_OK;
    return ret;
}

UMC::Status Write_24(UMC::DataWriter *dw, Ipp32s value)
{
    Ipp8u       data_char[3];
    UMC::Status ret;
    Ipp32s      size = 3;

    data_char[0] = (Ipp8u)((value >> 16) & 0xff);
    data_char[1] = (Ipp8u)((value >> 8) & 0xff);
    data_char[2] = (Ipp8u)(value & 0xff);
    ret = dw->PutData(data_char, size);
    ret = (size != 3) ? UMC::UMC_ERR_FAILED : UMC::UMC_OK;
    return ret;
}

UMC::Status Write_16(UMC::DataWriter *dw, Ipp32s value)
{
    Ipp8u       data_char[2];
    UMC::Status ret;
    Ipp32s      size = 2;

    data_char[0] = (Ipp8u)((value >> 8) & 0xff);
    data_char[1] = (Ipp8u)(value & 0xff);
    ret = dw->PutData(data_char, size);
    ret = (size != 2) ? UMC::UMC_ERR_FAILED : UMC::UMC_OK;
    return ret;
}

UMC::Status    Write_8(UMC::DataWriter *dw, Ipp32s value)
{
    Ipp8u       data_char[1];
    UMC::Status ret;
    Ipp32s      size = 1;

    data_char[0] = (Ipp8u)(value & 0xff);
    ret = dw->PutData(data_char, size);
    ret = ((size != 1) ? UMC::UMC_ERR_FAILED : UMC::UMC_OK);
    return ret;
}

Ipp32s Write_mp4_descr_length(UMC::DataWriter *dw, Ipp32s length)
{
    Ipp8u  b;
    Ipp32s i;
    Ipp8u  numBytes = 4;

    for ( i = numBytes - 1; i >= 0; i-- ) {
        b = (Ipp8u)((length >> (i * 7)) & 0x7F);
        if (i != 0) {
            b |= 0x80;
        }
        Write_8(dw, b);
    }
    return numBytes;
}

UMC::Status Write_AtomHeader(UMC::DataWriter *dw, TM_atom_mp4 *atom, Ipp8s* type)
{
    UMC::Status result;

    result = Write_32(dw, atom->size);
    result = Write_data(dw, type, 4);
    return result;
}

UMC::Status Write_mvhd(UMC::DataWriter *dw, TM_mvhd_data *mvhd)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32s       i;

    atom.size = mvhd->size_atom;//108
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"mvhd");
    result = Write_8(dw, (Ipp8s)mvhd->version);
    result = Write_24(dw, mvhd->flags);
    result = Write_32(dw, (Ipp32s)mvhd->creation_time);
    result = Write_32(dw, (Ipp32s)mvhd->modification_time);
    result = Write_32(dw, (Ipp32s)(mvhd->nTimeScale));
    result = Write_32(dw, (Ipp32s)mvhd->duration);
    result = Write_32(dw, 0x00010000);
    result = Write_16(dw, 0x0100);
    result = Write_16(dw, 0x0000);
    result = Write_32(dw, 0x00000000);
    result = Write_32(dw, 0x00000000);
    result = Write_32(dw, 0x00010000);
    for ( i = 0; i < 3; i++ ) {
        result = Write_32(dw, 0x00000000);
    }
    result = Write_32(dw, 0x00010000);
    for ( i = 0; i < 3; i++ ) {
        result = Write_32(dw, 0x00000000);
    }
    result = Write_32(dw, 0x40000000);
    for ( i = 0; i < 6; i++ ) {
        result = Write_32(dw, 0x00000000);
    }
    result = Write_32(dw, mvhd->next_track_id);

    return result;
}

UMC::Status Write_iods(UMC::DataWriter *dw, TM_iods_data *iods)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = iods->size_atom;//24
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"iods");
    result = Write_8(dw, (Ipp8s)iods->version);
    result = Write_24(dw, iods->flags);
    Write_8(dw, 0x10);    /* MP4_IOD_Tag */
    Write_mp4_descr_length(dw, 7);    /* length */
    Write_16(dw, 0x004F); /* ObjectDescriptorID = 1 */
    Write_8(dw, 0xFF);    /* ODProfileLevel */
    Write_8(dw, 0xFF);    /* sceneProfileLevel */
    Write_8(dw, iods->audioProfileId);    /* audioProfileLevel */
    Write_8(dw, iods->videoProfileId);    /* videoProfileLevel */
    Write_8(dw, 0xFF);    /* graphicsProfileLevel */
    return result;
}

UMC::Status Write_tkhd(UMC::DataWriter *dw, TM_tkhd_data *tkhd)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32s       i;

    atom.size = tkhd->size_atom;//92+

    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"tkhd");
    result = Write_8(dw, tkhd->version);
    result = Write_24(dw, tkhd->flags);
    result = Write_32(dw, (Ipp32s)tkhd->creation_time);
    result = Write_32(dw, (Ipp32s)tkhd->modification_time);
    result = Write_32(dw, tkhd->track_id);
    result = Write_32(dw, 0x00000000); //tkhd->reserved1
//saosipov ?????*3    result = Write_32(dw, (Ipp32s)tkhd->duration * 3);
    result = Write_32(dw, (Ipp32s)tkhd->duration);

/*
    for ( i = 0; i < 3; i++ )
    {
        result = Write_32(dw, 0x00000000);
    }
*/

    for ( i = 0; i < 2; i++ )
    {
        result = Write_32(dw, 0x00000000);
    }

/*
    if ( tkhd->is_audio )
    {
        result = Write_16(dw, 0x0100);
    }
    else
    {
        result = Write_16(dw, 0x0000);
    }
*/
    result = Write_16(dw, 0x0000); // layer
    result = Write_16(dw, 0x0000); // alternative_group

    if ( tkhd->is_audio ) // volume
    {
        result = Write_16(dw, 0x0100);
    }
    else
    {
        result = Write_16(dw, 0x0000);
    }
    result = Write_16(dw, 0x0000); // reserved

    /* unity matrix */
    result = Write_32(dw, 0x00010000);
    for ( i = 0; i < 3; i++ )
    {
        result = Write_32(dw, 0x00000000);
    }
    result = Write_32(dw, 0x00010000);
    for ( i = 0; i < 3; i++ )
    {
        result = Write_32(dw, 0x00000000);
    }
    result = Write_32(dw, 0x40000000);

/*
    if ( tkhd->is_video )
    {
        result = Write_32(dw, 0x01400000);
    }
    else
    {
        result = Write_32(dw, 0x00000000);
    }

    if ( tkhd->is_video )
    {
        result = Write_32(dw, 0x00F00000);
    }
    else
    {
        result = Write_32(dw, 0x00000000);
    }
*/
    result = Write_32(dw, (Ipp32s)(tkhd->track_width));    // width
    result = Write_32(dw, (Ipp32s)(tkhd->track_height));   // height
 //   result = Write_32(dw, tkhd->track_width);    // width
 //   result = Write_32(dw, tkhd->track_height);   // heght

    return result;
}

UMC::Status Write_mdhd(UMC::DataWriter *dw, TM_mdhd_data *mdhd)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = mdhd->size_atom;
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"mdhd");
    result = Write_8(dw, mdhd->version);
    result = Write_24(dw, mdhd->flags);
    result = Write_32(dw, (Ipp32s)mdhd->creation_time);
    result = Write_32(dw, (Ipp32s)mdhd->modification_time);
    result = Write_32(dw, mdhd->nTimeScale);
    result = Write_32(dw, (Ipp32s)mdhd->duration);
    result = Write_16(dw, mdhd->language);

    result = Write_16(dw, 0x0000);    //mdhd->pre_defined
    return result;
}

UMC::Status Write_hdlr(UMC::DataWriter *dw, TM_hdlr_data *hdlr)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32s i;

    atom.size = hdlr->size_atom;

    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"hdlr");
    result = Write_8(dw, hdlr->version);
    result = Write_24(dw, hdlr->flags);
    result = Write_32(dw, 0x00);

    for (i = 0; i < 4; i++)
    {
        result = Write_8(dw, hdlr->component_type[i]);
    }

    for (i = 0; i < 3; i++)
    {
        result = Write_32(dw, 0x00);
    }

    for (i = 0; i < 25; i++)
    {
        result = Write_8(dw, hdlr->component_name[i]);
    }

    Write_8(dw, 0x00);

    return result;
};

UMC::Status Write_dref_table(UMC::DataWriter *dw, TM_dref_table_data *table)
{
    UMC::Status    result;
    Ipp32s         len;
    Ipp32s         i;

    if ( table->size - 12 ) {
        len = vm_string_strlen(table->data_reference);
    } else {
        len = 0;
    }
    result = Write_32(dw, 12 + len);
    for ( i = 0; i < 4; i++ ) {
        Write_8(dw, table->type[i]);
    }
    result = Write_8(dw, table->version);
    result = Write_24(dw, table->flags);
    if ( len ) {
        result = Write_data(dw, (Ipp8s *)table->data_reference, len);
    }
    return result;
}

UMC::Status Write_dref(UMC::DataWriter *dw, TM_dref_data *dref)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

    atom.size = dref->size_atom;
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"dref");
    result = Write_8(dw, dref->version);
    result = Write_24(dw, dref->flags);

    result = Write_32(dw, dref->total_entries);
    for ( i = 0; i < dref->total_entries; i++ )
    {
        result = Write_32(dw, 0x0C);
        result = Write_8(dw, 0x75);
        result = Write_8(dw, 0x72);
        result = Write_8(dw, 0x6C);
        result = Write_8(dw, 0x20);
        result = Write_32(dw, 1);
        //Write_dref_table(dw, &(dref->table[i]));
    }
    /*result = Write_32(dw, 1);
    result = Write_32(dw, 0x0C);
    result = Write_char(dw, 0x75);
    result = Write_char(dw, 0x72);
    result = Write_char(dw, 0x6C);
    result = Write_char(dw, 0x20);
    result = Write_32(dw, 1);*/

    return result;
}

UMC::Status Write_dinf(UMC::DataWriter *dw, TM_dinf_data *dinf)
{
    TM_atom_mp4  atom;
    UMC::Status  result;

    atom.size = dinf->size_atom;
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"dinf");
    result = Write_dref(dw, &(dinf->dref));
    return result;
}

UMC::Status Write_stts(UMC::DataWriter *dw, TM_stts_data *stts)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

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

    for ( i = 0; i < stts->total_entries; i++ )
    {
        result = Write_32(dw, stts->table[i].sample_count);
        result = Write_32(dw, stts->table[i].sample_duration);
    }

    return result;
}

UMC::Status Write_ctts(UMC::DataWriter *dw, TM_ctts_data *ctts)
{
    TM_atom_mp4  atom;
    UMC::Status  result;
    Ipp32u    i;

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

    for ( i = 0; i < ctts->total_entries; i++ )
    {
        result = Write_32(dw, ctts->table[i].sample_count);
        result = Write_32(dw, ctts->table[i].sample_offset);
    }

    return result;
}

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

    atom.size = esds->size_atom;
    result = Write_AtomHeader(dw, &atom, (Ipp8s *)"esds");
    result = Write_8(dw, esds->version);
    result = Write_24(dw, esds->flags);
    result = Write_8(dw, 0x03);
    Write_mp4_descr_length(dw, 3 + (5 + (13 + (5 + esds->decoderConfigLen))) + 3);
//    result = Write_16(dw, 0);
    result = Write_16(dw, 1); // 0x0 is forbidden
    result = Write_8(dw, 0x10);
    result = Write_8(dw, 0x04);