umc_avs_dec_fussion_core.h

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) 2007 Intel Corporation. All Rights Reserved.
//
//
*/

#ifndef __UMC_AVS_DEC_FUSSION_CORE_H
#define __UMC_AVS_DEC_FUSSION_CORE_H

#include "ippdefs.h"
#include "umc_structures.h"
#include "umc_avs_dec_list.h"
#include "umc_avs_dec_pic.h"
#include "umc_avs_sequence_header.h"
#include "umc_avs_picture_header.h"

#include "umc_mutex.h"

namespace UMC
{

// forward declaration of used types
class MediaData;
class VideoData;
class VideoDecoderParams;
class AVSProcessingUnit;
class AVSSlice;
class AVSMemory;

enum
{
    AVS_DEF_NUMBER_OF_FRAMES    = 3
};

class AVSFussionCore
{
public:
    // Default constructor
    AVSFussionCore(void);
    // Destructor
    virtual
    ~AVSFussionCore(void);

    // Initialize the core
    Status Init(Ipp32s iNumThreads, VideoDecoderParams *pParams);
    // Release the object
    Status Close(void);
    // Reset the core
    Status Reset(void);
    // Add a piece of source data to the core
    Status LoadSource(MediaData *pSrc);
    // Set destination fideo frame
    Status SetDestination(VideoData *pDst);

    // Get next available task
    AVSProcessingUnit *GetTask(Ipp32s iThreadNum);

protected:
    // Load single NAL unit into the core
    Status LoadNALUnit(Ipp8u *pbSrc, size_t srcSize);

    // Parse a sequence header
    void ParseSequenceHeader(Ipp8u *pbSrc, size_t srcSize);
    // Parse a picture header
    void ParsePictureHeader(Ipp8u *pbSrc, size_t srcSize);
    // Add a slice to being collected picture
    Status AddSliceToPicture(Ipp8u *pbSrc, size_t srcSize);
    // Finalize the current being collected picture
    Status FinalizePicture(void);

    // Obtain one more unused frame
    AVSListElement<AVSFrame> *AllocateFrame(void);
    // Obtain one more memory piece
    AVSListElement<AVSMemory> *AllocateMemoryPiece(size_t nSize);
    // Obtain one more slice object
    AVSListElement<AVSSlice> *AllocateSlice(void);

    // Initialize the frame
    Status InitializeFrame(AVSFrame *pFrame);
    // Create frame's reference list
    Status CreateReferenceLists(AVSFrame *pFrame);
    // De-initialize the frame
    Status PurgeFrame(AVSFrame *pFrame);

    //
    // these members could be accessed without synchronization
    //

    AVSList<AVSFrame> m_FreeFrames;                             // (AVSList<AVSFrame>) the list of free frames
    AVSList<AVSSlice> m_FreeSlices;                             // (AVSList<AVSSlice>) the list of free slices
    AVSList<AVSMemory> m_FreeMemory;                            // (AVSList<AVSMemory>) the list of free memory pieces

    AVSList<AVSProcessingUnit> *m_pPerformers;                  // (AVSList<AVSProcessingUnit> *) pointer to an array of performers
    Ipp32s m_iNumberOfThreads;                                  // (Ipp32s) current number of working threads

    AVS_SEQUENCE_HEADER m_seqHeader;                            // (AVS_SEQUENCE_HEADER) sequence header
    AVS_PICTURE_HEADER m_picHeader;                             // (AVS_PICTURE_HEADER) picture header
    Ipp32s m_iPrevSliceStartCode;                               // (Ipp32s) start code of the previously collected slice

    Ipp32s m_iNumFrames;                                        // (Ipp32s) number of allocated frames

    Mutex m_guard;                                              // (Mutex) the sync object

    //
    // these members could be accessed only through synchronization
    //

    AVSList<AVSFrame> m_Frames;                                 // (AVSList<AVSFrame>) pointer to being processed frame(s)
};

} // namespace UMC

#endif // __UMC_AVS_DEC_FUSSION_CORE_H