Exemplo n.º 1
0
/*----------------------------------------------------------------------
|       AP4_AtomFactory::CreateAtomFromStream
+---------------------------------------------------------------------*/
AP4_Result
AP4_AtomFactory::CreateAtomFromStream(AP4_ByteStream& stream,
                                      AP4_Size&       bytes_available,
                                      AP4_Atom*&      atom,
                                      AP4_Atom*	      parent)
{
    AP4_Result result;


    // NULL by default
    atom = NULL;

    // check that there are enough bytes for at least a header
    if (bytes_available < 8) return AP4_ERROR_EOS;

    // remember current stream offset
    AP4_Offset start;
    stream.Tell(start);

    // read atom size

    AP4_UI64 size = 0;
    result = stream.ReadUI32((AP4_UI32&)size);
    if (AP4_FAILED(result)) {
        stream.Seek(start);
        return result;
    }

    if (size == 0) {
        // atom extends to end of file
        AP4_Size streamSize = 0;
        stream.GetSize(streamSize);
        if (streamSize >= start) {
            size = streamSize - start;
        }
    }

    // check the size (we don't handle extended size yet)
    if (size != 1 && size < 8 || size > bytes_available) {
        stream.Seek(start);
        return AP4_ERROR_INVALID_FORMAT;
    }

    // read atom type
    AP4_Atom::Type type;
    result = stream.ReadUI32(type);
    if (AP4_FAILED(result)) {
        stream.Seek(start);
        return result;
    }

    if (size == 1)
    {
        AP4_UI64 size_high;

        result = stream.ReadUI64(size_high);
        if (AP4_FAILED(result) ) {
            stream.Seek(start);
            return AP4_ERROR_INVALID_FORMAT;
        }
        size = size_high;
    }

    // create the atom
    switch (type) {
    case AP4_ATOM_TYPE_MOOV:
        atom = DNew AP4_MoovAtom(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_MVHD:
        atom = DNew AP4_MvhdAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_TRAK:
        atom = DNew AP4_TrakAtom(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_HDLR:
        atom = DNew AP4_HdlrAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_DREF:
        atom = DNew AP4_DrefAtom(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_URL:
        atom = DNew AP4_UrlAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_TKHD:
        atom = DNew AP4_TkhdAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_MDHD:
        atom = DNew AP4_MdhdAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_STSD:
        atom = DNew AP4_StsdAtom(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_STSC:
        atom = DNew AP4_StscAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_STCO:
        atom = DNew AP4_StcoAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_CO64:
        atom = DNew AP4_Co64Atom(size, stream);
        break;

    case AP4_ATOM_TYPE_STSZ:
        atom = DNew AP4_StszAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_STTS:
        atom = DNew AP4_SttsAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_CTTS:
        atom = DNew AP4_CttsAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_STSS:
        atom = DNew AP4_StssAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_MP4S:
        atom = DNew AP4_Mp4sSampleEntry(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_MP4A:
        atom = parent && parent->GetType() == AP4_ATOM_TYPE_STSD
               ? (AP4_Atom*)DNew AP4_Mp4aSampleEntry(size, stream, *this)
               : (AP4_Atom*)DNew AP4_UnknownAtom(type, size, false, stream);
        break;

    case AP4_ATOM_TYPE_MP4V:
        atom = DNew AP4_Mp4vSampleEntry(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_AVC1:
        atom = DNew AP4_Avc1SampleEntry(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_ENCA:
        atom = DNew AP4_EncaSampleEntry(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_ENCV:
        atom = DNew AP4_EncvSampleEntry(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_ESDS:
        atom = DNew AP4_EsdsAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_VMHD:
        atom = DNew AP4_VmhdAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_SMHD:
        atom = DNew AP4_SmhdAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_NMHD:
        atom = DNew AP4_NmhdAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_HMHD:
        atom = DNew AP4_HmhdAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_FRMA:
        atom = DNew AP4_FrmaAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_SCHM:
        atom = DNew AP4_SchmAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_FTYP:
        atom = DNew AP4_FtypAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_RTP:
        if (m_Context == AP4_ATOM_TYPE_HNTI) {
            atom = DNew AP4_RtpAtom(size, stream);
        } else {
            atom = DNew AP4_RtpHintSampleEntry(size, stream, *this);
        }
        break;

    case AP4_ATOM_TYPE_TIMS:
        atom = DNew AP4_TimsAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_SDP:
        atom = DNew AP4_SdpAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_IKMS:
        atom = DNew AP4_IkmsAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_ISFM:
        atom = DNew AP4_IsfmAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_HINT:
        atom = DNew AP4_TrefTypeAtom(type, size, stream);
        break;

    // container atoms
    case AP4_ATOM_TYPE_TREF:
    case AP4_ATOM_TYPE_HNTI:
    case AP4_ATOM_TYPE_STBL:
    case AP4_ATOM_TYPE_MDIA:
    case AP4_ATOM_TYPE_DINF:
    case AP4_ATOM_TYPE_MINF:
    case AP4_ATOM_TYPE_SCHI:
    case AP4_ATOM_TYPE_SINF:
    case AP4_ATOM_TYPE_UDTA:
    case AP4_ATOM_TYPE_ILST:
    case AP4_ATOM_TYPE_NAM:
    case AP4_ATOM_TYPE_ART:
    case AP4_ATOM_TYPE_WRT:
    case AP4_ATOM_TYPE_ALB:
    case AP4_ATOM_TYPE_DAY:
    case AP4_ATOM_TYPE_TOO:
    case AP4_ATOM_TYPE_CMT:
    case AP4_ATOM_TYPE_GEN:
    case AP4_ATOM_TYPE_TRKN:
    case AP4_ATOM_TYPE_EDTS:
    case AP4_ATOM_TYPE_WAVE:
    case AP4_ATOM_TYPE_CMOV: {
        AP4_UI32 context = m_Context;
        m_Context = type; // set the context for the children
        atom = DNew AP4_ContainerAtom(type, size, false, stream, *this);
        m_Context = context; // restore the previous context
        break;
    }

    // full container atoms
    case AP4_ATOM_TYPE_META:
        atom = DNew AP4_ContainerAtom(type, size, true, stream, *this);
        break;

    // other
    case AP4_ATOM_TYPE_AVCC:
        atom = DNew AP4_AvcCAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_TEXT:
        atom = DNew AP4_TextSampleEntry(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_TX3G:
        atom = DNew AP4_Tx3gSampleEntry(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_FTAB:
        atom = DNew AP4_FtabAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_CVID:
    case AP4_ATOM_TYPE_SVQ1:
    case AP4_ATOM_TYPE_SVQ2:
    case AP4_ATOM_TYPE_SVQ3:
    case AP4_ATOM_TYPE_H261:
    case AP4_ATOM_TYPE_H263:
    case AP4_ATOM_TYPE_S263:
    case AP4_ATOM_TYPE_JPEG:
    case AP4_ATOM_TYPE_PNG:
    case AP4_ATOM_TYPE_RLE:
    case AP4_ATOM_TYPE_MJPA:
    case AP4_ATOM_TYPE_MJPB:
    case AP4_ATOM_TYPE_RPZA:
    case AP4_ATOM_TYPE_DIV3:
    case AP4_ATOM_TYPE_DIVX:
    case AP4_ATOM_TYPE_8BPS:
    case AP4_ATOM_TYPE_3IV1:
    case AP4_ATOM_TYPE_3IV2:
    case AP4_ATOM_TYPE_IV32:
    case AP4_ATOM_TYPE_IV41:
    case AP4_ATOM_TYPE_VP31:
    case AP4_ATOM_TYPE_YV12:
    case AP4_ATOM_TYPE_DVC:
    case AP4_ATOM_TYPE_DV5P:
    case AP4_ATOM_TYPE_DVCP:
    case AP4_ATOM_TYPE_DVPP:
        atom = DNew AP4_VisualSampleEntry(type, size, stream, *this);
        break;

    case AP4_ATOM_TYPE_MJPG:
    case AP4_ATOM_TYPE_AVDJ://uncommon fourcc
    case AP4_ATOM_TYPE_DMB1://uncommon fourcc
        atom = DNew AP4_VisualSampleEntry(AP4_ATOM_TYPE_MJPG, size, stream, *this);
        break;

    case AP4_ATOM_TYPE_SAMR:
    case AP4_ATOM_TYPE__MP3:
    case AP4_ATOM_TYPE_IMA4:
    case AP4_ATOM_TYPE_QDMC:
    case AP4_ATOM_TYPE_QDM2:
    case AP4_ATOM_TYPE_NONE:
    case AP4_ATOM_TYPE_RAW:
    case AP4_ATOM_TYPE_TWOS:
    case AP4_ATOM_TYPE_SOWT:
    case AP4_ATOM_TYPE_IN24:
    case AP4_ATOM_TYPE_IN32:
    case AP4_ATOM_TYPE_FL32:
    case AP4_ATOM_TYPE_FL64:
    case AP4_ATOM_TYPE_LPCM:
    case AP4_ATOM_TYPE_ALAW:
    case AP4_ATOM_TYPE_ULAW:
    case AP4_ATOM_TYPE_NMOS:
    case AP4_ATOM_TYPE_ALAC:
        atom = DNew AP4_AudioSampleEntry(type, size, stream, *this);
        break;

    case AP4_ATOM_TYPE__AC3: // AC3-in-MP4 from ISO Standard
    case AP4_ATOM_TYPE_SAC3: // AC3-in-MP4 from Nero Stuff >.<
        atom = DNew AP4_AC3SampleEntry(size, stream, *this);
        break;
    case AP4_ATOM_TYPE_EAC3:
        atom = DNew AP4_EAC3SampleEntry(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_CHPL:
        atom = DNew AP4_ChplAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_DATA:
        atom = DNew AP4_DataAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_DCOM:
        atom = DNew AP4_DcomAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_CMVD:
        atom = DNew AP4_CmvdAtom(size, stream, *this);
        break;

    case AP4_ATOM_TYPE_ENDA:
        atom = DNew AP4_EndaAtom(size, stream);
        break;

    case AP4_ATOM_TYPE_PASP:
        atom = DNew AP4_PaspAtom(size, stream);
        break;

    default:
        if(parent && parent->GetType() == AP4_ATOM_TYPE_STSD && (type & 0xffff0000) == AP4_ATOM_TYPE('m', 's', 0, 0)) {
            atom = DNew AP4_AudioSampleEntry(type, size, stream, *this);
        } else {// try all the external type handlers
            atom = NULL;
            AP4_List<TypeHandler>::Item* handler_item = m_TypeHandlers.FirstItem();
            while (handler_item) {
                TypeHandler* handler = handler_item->GetData();
                if (AP4_SUCCEEDED(handler->CreateAtom(type, size, stream, atom))) {
                    break;
                }
                handler_item = handler_item->GetNext();
            }
            if (atom == NULL) {
                // no custom handlers, create a generic atom
                atom = DNew AP4_UnknownAtom(type, size, false, stream);
            }
        }

        break;
    }

    // skip to the end of the atom
    bytes_available -= size;
    result = stream.Seek(start+size);
    if (AP4_FAILED(result)) {
        delete atom;
        atom = NULL;
    }

    return result;
}
Exemplo n.º 2
0
/*----------------------------------------------------------------------
|       AP4_TrakAtom::AP4_TrakAtom
+---------------------------------------------------------------------*/
AP4_TrakAtom::AP4_TrakAtom(AP4_SampleTable* sample_table,
                           AP4_Atom::Type   hdlr_type,
                           const char*      hdlr_name, 
                           AP4_UI32         track_id,
                           AP4_UI64         creation_time,
                           AP4_UI64         modification_time,
                           AP4_UI64         track_duration,
                           AP4_UI32         media_time_scale,
                           AP4_UI64         media_duration,
                           AP4_UI16         volume,
                           const char*      language,
                           AP4_UI32         width,
                           AP4_UI32         height) :
    AP4_ContainerAtom(AP4_ATOM_TYPE_TRAK)
{
    AP4_Result result;

    // create a tkhd atom
    m_TkhdAtom = DNew AP4_TkhdAtom(creation_time, 
                                  modification_time, 
                                  track_id,
                                  track_duration, 
                                  volume, 
                                  width, 
                                  height);

    // create an edts

    // create a mdia atom
    AP4_ContainerAtom* mdia = DNew AP4_ContainerAtom(AP4_ATOM_TYPE_MDIA);

    // create a hdlr atom for the mdia atom
    m_HdlrAtom = DNew AP4_HdlrAtom(hdlr_type, hdlr_name);

    // create a minf atom 
    AP4_ContainerAtom* minf = DNew AP4_ContainerAtom(AP4_ATOM_TYPE_MINF);

    // create a media header atom for minf (vmhd, smhd, hmhd or nmhd)
    AP4_Atom* minf_header;
    switch (hdlr_type) {
        case AP4_HANDLER_TYPE_VIDE:
            minf_header = DNew AP4_VmhdAtom(0, 0, 0, 0);
            break;

        case AP4_HANDLER_TYPE_SOUN:
            minf_header = DNew AP4_SmhdAtom(0);
            break;

        default:
            minf_header = DNew AP4_NmhdAtom();
            break;
    }

    // create a dinf atom for minf
    AP4_ContainerAtom* dinf = DNew AP4_ContainerAtom(AP4_ATOM_TYPE_DINF);

    // create a url atom as a ref for dref
    AP4_Atom* url = DNew AP4_UrlAtom(); // local ref

    // create a dref atom for dinf
    AP4_DrefAtom* dref = DNew AP4_DrefAtom(&url, 1);

    // create a stbl atom for minf
    AP4_ContainerAtom* stbl;
    result = sample_table->GenerateStblAtom(stbl);
    if (AP4_FAILED(result)) stbl = NULL;
    
    // populate the dinf atom
    dinf->AddChild(dref);

    // populate the minf atom
    minf->AddChild(minf_header);
    minf->AddChild(dinf);
    if (stbl) minf->AddChild(stbl);

    // create a mdhd atom for the mdia atom
    AP4_MdhdAtom* mdhd = DNew AP4_MdhdAtom(creation_time,
                                          modification_time,
                                          media_time_scale,
                                          media_duration,
                                          language);

    // populate the mdia atom
    mdia->AddChild(mdhd);
    mdia->AddChild(m_HdlrAtom);
    mdia->AddChild(minf);

    // attach the children
    AddChild(m_TkhdAtom);
    AddChild(mdia);
}