/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
************************************************************************
* @file M4READER_Common.h
* @brief Shell Reader common interface declaration
* @note This file declares the common interfaces that reader shells must implement
*
************************************************************************
*/
#ifndef __M4READER_COMMON_H__
#define __M4READER_COMMON_H__
#include "M4OSA_Types.h"
#include "M4OSA_Error.h"
#include "M4OSA_FileReader.h"
#include "M4OSA_CoreID.h"
#include "M4DA_Types.h"
#include "M4Common_types.h"
/* ERRORS */
#define M4ERR_READER_UNKNOWN_STREAM_TYPE M4OSA_ERR_CREATE(M4_ERR, M4READER_COMMON, 0x0001)
/* WARNINGS */
#define M4WAR_READER_NO_METADATA M4OSA_ERR_CREATE(M4_WAR, M4READER_COMMON, 0x0001)
#define M4WAR_READER_INFORMATION_NOT_PRESENT M4OSA_ERR_CREATE(M4_WAR, M4READER_COMMON, 0x0002)
/**
************************************************************************
* enum M4READER_MediaType
* @brief This enum defines the Media types used to create media readers
* @note This enum is used internally by the VPS to identify a currently supported
* media reader interface. Each reader is registered with one of this type associated.
* When a reader instance is needed, this type is used to identify and
* and retrieve its interface.
************************************************************************
*/
typedef enum
{
M4READER_kMediaTypeUnknown = -1, /**< Unknown media type */
M4READER_kMediaType3GPP = 0, /**< 3GPP file media type */
M4READER_kMediaTypeAVI = 1, /**< AVI file media type */
M4READER_kMediaTypeAMR = 2, /**< AMR file media type */
M4READER_kMediaTypeMP3 = 3, /**< MP3 file media type */
M4READER_kMediaTypeRTSP = 4, /**< RTSP network accessed media type */
M4READER_kMediaType3GPPHTTP = 5, /**< Progressively downloaded 3GPP file media type */
M4READER_kMediaTypePVHTTP = 6, /**< Packet Video HTTP proprietary type */
M4READER_kMediaTypeWAV = 7, /**< WAV file media type */
M4READER_kMediaType3GPEXTHTTP = 8, /**< An external progressively downloaded 3GPP file
media type */
M4READER_kMediaTypeAAC = 9, /**< ADTS and ADIF AAC support */
M4READER_kMediaTypeREAL = 10, /**< REAL Media type */
M4READER_kMediaTypeASF = 11, /**< ASF Media type */
M4READER_kMediaTypeFLEXTIME = 12, /**< FlexTime Media type */
M4READER_kMediaTypeBBA = 13, /**< Beatbrew audio Media type */
M4READER_kMediaTypeSYNTHAUDIO = 14, /**< Synthesis audio Media type */
M4READER_kMediaTypePCM = 15, /**< PCM Media type */
M4READER_kMediaTypeJPEG = 16, /**< JPEG Media type */
M4READER_kMediaTypeGIF = 17, /**< GIF Media type */
M4READER_kMediaTypeADIF = 18, /**< AAC-ADTS Media type */
M4READER_kMediaTypeADTS = 19, /**< AAC-ADTS Media type */
M4READER_kMediaType_NB /* number of readers, keep it as last enum entry */
} M4READER_MediaType;
/**
************************************************************************
* enum M4READER_MediaFamily
* @brief This enum defines the Media family of a stream
* @note This enum is used internally by the VPS to identify what kind of stream
* has been retrieved via getNextStream() function.
************************************************************************
*/
typedef enum
{
M4READER_kMediaFamilyUnknown = -1,
M4READER_kMediaFamilyVideo = 0,
M4READER_kMediaFamilyAudio = 1,
M4READER_kMediaFamilyText = 2
} M4READER_MediaFamily;
/**
************************************************************************
* enum M4READER_OptionID
* @brief This enum defines the reader options
* @note These options can be read from a reader via M4READER_getOption_fct
************************************************************************
*/
typedef enum
{
/**
Get the duration of the movie (in ms)
*/
M4READER_kOptionID_Duration = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0),
/**
Get the version of the core reader
*/
M4READER_kOptionID_Version = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 1),
/**
Get the copyright from the media (if present)
(currently implemented for 3GPP only: copyright get from the cprt atom in the udta if present)
*/
M4READER_kOptionID_Copyright= M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 2),
/**
Set the OSAL file reader functions to the reader (type of value: M4OSA_FileReadPointer*)
*/
M4READER_kOptionID_SetOsaFileReaderFctsPtr = M4OSA_OPTION_ID_CREATE(M4_READ,\
M4READER_COMMON, 3),
/**
Set the OSAL file writer functions to the reader (type of value: M4OSA_FileWriterPointer*)
*/
M4READER_kOptionID_SetOsaFileWriterFctsPtr = M4OSA_OPTION_ID_CREATE(M4_READ,\
M4READER_COMMON, 4),
/**
Set the OSAL file writer functions to the reader (type of value: M4OSA_NetFunction*)
*/
M4READER_kOptionID_SetOsaNetFctsPtr = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 5),
/**
Creation time in sec. since midnight, Jan. 1, 1970 (type of value: M4OSA_UInt32*)
(available only for 3GPP content, including PGD)
*/
M4READER_kOptionID_CreationTime = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 6),
/**
Bitrate in bps (type of value: M4OSA_Double*)
*/
M4READER_kOptionID_Bitrate = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 7),
/**
Tag ID3v1 of MP3 source (type of value: M4MP3R_ID3Tag*)
*/
M4READER_kOptionID_Mp3Id3v1Tag = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 8),
/**
Tag ID3v2 of MP3 source (type of value: M4MP3R_ID3Tag*)
*/
M4READER_kOptionID_Mp3Id3v2Tag = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 9),
/**
Number of Access Unit in the Audio stream (type of value: M4OSA_UInt32*)
*/
M4READER_kOptionID_GetNumberOfAudioAu = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0xA),
/**
Number of frames per bloc
*/
M4READER_kOptionID_GetNbframePerBloc = M4OSA_OPTION_ID_CREATE(M4_READ,\
M4READER_COMMON, 0xB),
/**
Flag for protection presence
*/
M4READER_kOptionID_GetProtectPresence = M4OSA_OPTION_ID_CREATE(M4_READ,\
M4READER_COMMON, 0xC),
/**
Set DRM Context
*/
M4READER_kOptionID_SetDRMContext = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0xD),
/**
Get ASF Content Description Object
*/
M4READER_kOptionID_ContentDescription = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0xE),
/**
Get ASF Content Description Object
*/
M4READER_kOptionID_ExtendedContentDescription = M4OSA_OPTION_ID_CREATE(M4_READ,\
M4READER_COMMON, 0xF),
/**
Get Asset 3gpp Fields
*/
M4READER_kOptionID_3gpAssetFields = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x10),
/**
Set the max metadata size supported in the reader
Only relevant in 3gp parser till now, but can be used for other readers
*/
M4READER_kOptionID_MaxMetadataSize = M4OSA_OPTION_ID_CREATE(M4_WRITE, M4READER_COMMON, 0x11),
M4READER_kOptionID_GetMetadata = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x12),
/**
Get 3gpp 'ftyp' atom
*/
M4READER_kOptionID_3gpFtypBox = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x13),
/* value is M4OSA_Bool* */
/* return the drm protection status of the file*/
M4READER_kOptionID_isProtected = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x14),
/* value is a void* */
/* return the aggregate rights of the file*/
/* The buffer must be allocated by the application and must be big enough*/
/* By default, the size for WMDRM is 76 bytes */
M4READER_kOptionID_getAggregateRights = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x15),
/**
Get ASF Content Description Object
*/
M4READER_kOptionID_ExtendedContentEncryption = M4OSA_OPTION_ID_CREATE(M4_READ,\
M4READER_COMMON, 0x16),
/**
Number of Access Unit in the Video stream (type of value: M4OSA_UInt32*)
*/
M4READER_kOptionID_GetNumberOfVideoAu = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x17),
/**
Chunk mode activation size in case of JPG reader */
M4READER_kOptionID_JpegChunckSize = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x18),
/**
Check if ASF file contains video */
M4READER_kOptionID_hasVideo = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x19),
/**
Set specific read mode for Random Access JPEG */
M4READER_kOptionID_JpegRAMode = M4OSA_OPTION_ID_CREATE(M4_WRITE, M4READER_COMMON, 0x20),
/**
Get Thumbnail buffer in case of JPG reader */
M4READER_kOptionID_JpegThumbnail = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x21),
/**
Get FPDATA buffer in case of JPG reader */
M4READER_kOptionID_JpegFPData = M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x22),
/**
Get JPEG info (progressive, subsampling) */
M4READER_kOptionID_JpegInfo= M4OSA_OPTION_ID_CREATE(M4_READ, M4READER_COMMON, 0x23)
/*****************************************/
} M4READER_OptionID;
/*****************************************/
/**
************************************************************************
* structure M4READER_CopyRight
* @brief This structure defines a copyRight description
* @note This structure is used to retrieve the copyRight of the media
* (if present) via the getOption() function
************************************************************************
*/
typedef struct _M4READER_CopyRight
{
/**
Pointer to copyright data (allocated by user)
*/
M4OSA_UInt8* m_pCopyRight;
/**
Pointer to copyright size. The pCopyRightSize must
be Initialized with the size available in the pCopyRight buffer
*/
M4OSA_UInt32 m_uiCopyRightSize;
} M4READER_CopyRight;
/**
************************************************************************
* structure M4READER_StreamDataOption
* @brief This structure defines a generic stream data option
* @note It is used is used to set or get a stream specific data defined
* by a relevant reader option ID.
************************************************************************
*/
typedef struct _M4READER_StreamDataOption
{
M4_StreamHandler* m_pStreamHandler; /**< identifier of the stream */
M4OSA_Void* m_pOptionValue; /**< value of the data option to get or to set */
} M4READER_StreamDataOption;
/**
************************************************************************
* enumeration M4_EncodingFormat
* @brief Text encoding format
************************************************************************
*/
// typedef enum
// {
// M4_kEncFormatUnknown = 0, /**< Unknown format */
// M4_kEncFormatASCII = 1, /**< ISO-8859-1. Terminated with $00 */
// M4_kEncFormatUTF8 = 2, /**< UTF-8 encoded Unicode . Terminated with $00 */
// M4_kEncFormatUTF16 = 3 /**< UTF-16 encoded Unicode. Terminated with $00 00 */
/*} M4_EncodingFormat;*/
/**
************************************************************************
* structure M4_StringAttributes
* @brief This structure defines string attribute
************************************************************************
*/
// typedef struct
// {
// M4OSA_Void* m_pString; /**< Pointer to text */
// M4OSA_UInt32 m_uiSize; /**< Size of text */
// M4_EncodingFormat m_EncodingFormat; /**< Text encoding format */
// } M4_StringAttributes;
/**
************************************************************************
* structure M4READER_Buffer
* @brief This structure defines a buffer in all readers
************************************************************************
*/
typedef struct
{
M4OSA_UInt8* m_pData;
M4OSA_UInt32 m_uiBufferSize;
} M4READER_Buffer;
typedef struct
{
M4OSA_UInt32 m_uiSessionId;
M4OSA_UInt32 m_uiMediaId;
M4OSA_UInt32 m_uiNbInstance;
M4OSA_Char** m_pInstance;
} M4_SdpAssetInstance;
/*
typedef enum
{
M4READER_kUnknownFormat = 0,
M4READER_kTagID3V1,
M4READER_kTagID3V2,
M4READER_kASFContentDesc,
M4READER_k3GppAssetBoxFromUDTA,
M4READER_k3GppAssetBoxFromSDP,
M4READER_kJpegExif
} M4READER_MetaDataType;*/
/**
************************************************************************
* structure M4_3gpAssetFields
* @brief This structure defines fields of a 3gpp asset information
************************************************************************
*/
typedef struct
{
M4COMMON_MetaDataFields m_metadata;
M4OSA_UInt32 m_uiSessionID; /* For SDP */
M4OSA_UInt32 m_uiMediaID; /* For SDP */
/* Note: The two following fields were added for internal use
(For Music manager project..) !! */
M4_StreamType m_VideoStreamType; /**< Video stream type */
M4_StreamType m_AudioStreamType; /**< Audio stream type */
} M4_MetaDataFields;
#define M4_METADATA_STR_NB 22 /* one string in album art structure*/
typedef struct
{
M4OSA_UInt32 m_uiNbBuffer;
M4_SdpAssetInstance* m_pAssetInfoInst; /* Set of 3gpp asset boxes */
M4COMMON_MetaDataAlbumArt m_albumArt; /* RC: PV specific album art:added
here because this type is used by
union below in streaming */
} M4READER_netInfos;
typedef union
{
M4READER_Buffer m_pTagID3Buffer[2]; /* Tag ID3 V1, V2 */
struct
{
M4READER_Buffer m_pAsfDescContent; /* ASF description content buffer */
M4READER_Buffer m_pAsfExtDescContent; /* ASF extended description content buffer */
} m_asf;
M4_MetaDataFields m_pMetadataFields; /* Already parsed and filled 3gpp asset fields */
M4READER_netInfos m_pAssetInfoInstance; /* Set of 3gpp asset boxes in the sdp file */
} M4_MetadataBuffer;
/*********** READER GLOBAL Interface ************************************/
/**
************************************************************************
* @brief create an instance of the reader
* @note create the context
* @param pContext: (OUT) pointer on a reader context
* @return M4NO_ERROR there is no error
* @return M4ERR_PARAMETER at least one parameter is not properly set
* @return M4ERR_ALLOC a memory allocation has failed
************************************************************************
*/
typedef M4OSA_ERR (M4READER_create_fct) (M4OSA_Context* pContext);
/**
************************************************************************
* @brief destroy the instance of the reader
* @note after this call the context is invalid
* @param context: (IN) Context of the reader
* @return M4NO_ERROR there is no error
* @return M4ERR_PARAMETER at least one parameter is not properly set
************************************************************************
*/
typedef M4OSA_ERR (M4READER_destroy_fct) (M4OSA_Context context);
/**
************************************************************************
* @brief open the reader and initializes its created instance
* @note this function, for the network reader, sends the DESCRIBE
* @param context: (IN) Context of the reader
* @param pFileDescriptor: (IN) Pointer to proprietary data identifying the media to open
* @return M4NO_ERROR there is no error
* @return M4ERR_PARAMETER the context is NULL
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
************************************************************************
*/
typedef M4OSA_ERR (M4READER_open_fct) (M4OSA_Context context, M4OSA_Void* pFileDescriptor);
/**
************************************************************************
* @brief close the reader
* @note
* @param context: (IN) Context of the reader
* @return M4NO_ERROR there is no error
* @return M4ERR_PARAMETER the context is NULL
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
************************************************************************
*/
typedef M4OSA_ERR (M4READER_close_fct) (M4OSA_Context context);
/**
************************************************************************
* @brief Get the next stream found in the media
* @note
* @param context: (IN) Context of the reader
* @param pMediaFamily: (OUT) pointer to a user allocated M4READER_MediaFamily that will
* be filled with the media family of the found stream
* @param pStreamHandler: (OUT) pointer to a stream handler that will be allocated and
* filled with the found stream description
* @return M4NO_ERROR there is no error
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
* @return M4ERR_PARAMETER at least one parameter is not properly set
* @return M4WAR_NO_MORE_STREAM no more available stream in the media (all streams found)
************************************************************************
*/
typedef M4OSA_ERR (M4READER_getNextStream_fct) (M4OSA_Context context,
M4READER_MediaFamily *pMediaFamily,
M4_StreamHandler **pStreamHandler);
/**
************************************************************************
* @brief fill the access unit structure with initialization values
* @note
* @param context: (IN) Context of the reader
* @param pStreamHandler: (IN) pointer to the stream handler to which the access unit
* will be associated
* @param pAccessUnit: (IN/OUT) pointer to the access unit (allocated by the caller)
* to initialize
* @return M4NO_ERROR there is no error
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
* @return M4ERR_PARAMETER at least one parameter is not properly set
* @return M4ERR_ALLOC there is no more memory available
************************************************************************
*/
typedef M4OSA_ERR (M4READER_fillAuStruct_fct) (M4OSA_Context context,
M4_StreamHandler *pStreamHandler,
M4_AccessUnit *pAccessUnit);
/**
************************************************************************
* @brief starts the instance of the reader
* @note only needed for network until now...
* @param context: (IN) Context of the reader
* @return M4NO_ERROR there is no error
* @return M4ERR_PARAMETER the context is NULL
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
************************************************************************
*/
typedef M4OSA_ERR (M4READER_start_fct) (M4OSA_Context context);
/**
************************************************************************
* @brief stop reading
* @note only needed for network until now... (makes a pause)
* @param context: (IN) Context of the reader
* @return M4NO_ERROR there is no error
* @return M4ERR_PARAMETER the context is NULL
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
************************************************************************
*/
typedef M4OSA_ERR (M4READER_stop_fct) (M4OSA_Context context);
/**
************************************************************************
* @brief get an option value from the reader
* @note this function follows the set/get option mechanism described in OSAL 3.0
* it allows the caller to retrieve a property value:
* -the duration of the longest stream of the media
* -the version number of the reader
*
* @param context: (IN) Context of the reader
* @param optionId: (IN) indicates the option to get
* @param pValue: (OUT) pointer to structure or value (allocated by user)
* where option is stored
*
* @return M4NO_ERROR there is no error
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
* @return M4ERR_PARAMETER at least one parameter is not properly set
* @return M4ERR_BAD_OPTION_ID when the option ID is not a valid one
************************************************************************
*/
typedef M4OSA_ERR (M4READER_getOption_fct) (M4OSA_Context context, M4OSA_OptionID optionId,
M4OSA_DataOption pValue);
/**
************************************************************************
* @brief set en option value of the readder
* @note this function follows the set/get option mechanism described in OSAL 3.0
* it allows the caller to set a property value:
* - nothing for the moment
*
* @param context: (IN) Context of the reader
* @param optionId: (IN) indicates the option to set
* @param pValue: (IN) pointer to structure or value (allocated by user) where
* option is stored
*
* @return M4NO_ERROR there is no error
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
* @return M4ERR_PARAMETER at least one parameter is not properly set
* @return M4ERR_BAD_OPTION_ID when the option ID is not a valid one
************************************************************************
*/
typedef M4OSA_ERR (M4READER_setOption_fct) (M4OSA_Context context, M4OSA_OptionID optionId,
M4OSA_DataOption pValue);
/**
************************************************************************
* @brief jump into the stream at the specified time
* @note
* @param context: (IN) Context of the reader
* @param pStreamHandler (IN) the stream handler of the stream to make jump
* @param pTime (IN/OUT) IN: the time to jump to (in ms)
* OUT: the time to which the stream really jumped
* @return M4NO_ERROR there is no error
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
* @return M4ERR_PARAMETER at least one parameter is not properly set
* @return M4ERR_ALLOC there is no more memory available
* @return M4ERR_BAD_STREAM_ID the streamID does not exist
************************************************************************
*/
typedef M4OSA_ERR (M4READER_jump_fct) (M4OSA_Context context,
M4_StreamHandler *pStreamHandler,
M4OSA_Int32* pTime);
/**
************************************************************************
* @brief reset the stream, that is seek it to beginning and make it ready to be read
* @note
* @param context: (IN) Context of the reader
* @param pStreamHandler (IN) The stream handler of the stream to reset
* @return M4NO_ERROR there is no error
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
* @return M4ERR_PARAMETER at least one parameter is not properly set
* @return M4ERR_ALLOC there is no more memory available
* @return M4ERR_BAD_STREAM_ID the streamID does not exist
************************************************************************
*/
typedef M4OSA_ERR (M4READER_reset_fct) (M4OSA_Context context,
M4_StreamHandler *pStreamHandler);
/**
************************************************************************
* @brief get the time of the closest RAP access unit before the given time
* @note
* @param context: (IN) Context of the reader
* @param pStreamHandler (IN) the stream handler of the stream to search
* @param pTime (IN/OUT) IN: the time to search from (in ms)
* OUT: the time (cts) of the preceding RAP AU.
* @return M4NO_ERROR there is no error
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
* @return M4ERR_PARAMETER at least one parameter is not properly set
* @return M4ERR_BAD_STREAM_ID the streamID does not exist
************************************************************************
*/
typedef M4OSA_ERR (M4READER_getPrevRapTime_fct) (M4OSA_Context context,
M4_StreamHandler *pStreamHandler,
M4OSA_Int32* pTime);
/**
************************************************************************
* structure M4READER_GlobalInterface
* @brief This structure defines the generic media reader GLOBAL interface
* @note This structure stores the pointers to functions concerning
* creation and control of one reader type.
* The reader type is one of the M4READER_MediaType
************************************************************************
*/
typedef struct _M4READER_GlobalInterface
/*****************************************/
{
M4READER_create_fct* m_pFctCreate;
M4READER_destroy_fct* m_pFctDestroy;
M4READER_open_fct* m_pFctOpen;
M4READER_close_fct* m_pFctClose;
M4READER_getOption_fct* m_pFctGetOption;
M4READER_setOption_fct* m_pFctSetOption;
M4READER_getNextStream_fct* m_pFctGetNextStream;
M4READER_fillAuStruct_fct* m_pFctFillAuStruct;
M4READER_start_fct* m_pFctStart;
M4READER_stop_fct* m_pFctStop;
M4READER_jump_fct* m_pFctJump;
M4READER_reset_fct* m_pFctReset;
M4READER_getPrevRapTime_fct* m_pFctGetPrevRapTime;
} M4READER_GlobalInterface;
/************* READER DATA Interface ************************************/
/**
************************************************************************
* @brief Gets an access unit (AU) from the stream handler source.
* @note An AU is the smallest possible amount of data to be decoded by a decoder (audio/video).
*
* @param context: (IN) Context of the reader
* @param pStreamHandler (IN) The stream handler of the stream to make jump
* @param pAccessUnit (IN/OUT) Pointer to an access unit to fill with read data
* (the au structure is allocated by the user, and must be
* initialized by calling M4READER_fillAuStruct_fct after
* creation)
* @return M4NO_ERROR there is no error
* @return M4ERR_BAD_CONTEXT provided context is not a valid one
* @return M4ERR_PARAMETER at least one parameter is not properly set
* @returns M4ERR_ALLOC memory allocation failed
* @returns M4ERR_BAD_STREAM_ID at least one of the stream Id. does not exist.
* @returns M4WAR_NO_DATA_YET there is no enough data on the stream for new
* access unit
* @returns M4WAR_NO_MORE_AU there are no more access unit in the stream
* (end of stream)
************************************************************************
*/
typedef M4OSA_ERR (M4READER_getNextAu_fct)(M4OSA_Context context,
M4_StreamHandler *pStreamHandler,
M4_AccessUnit *pAccessUnit);
/**
************************************************************************
* structure M4READER_DataInterface
* @brief This structure defines the generic media reader DATA interface
* @note This structure stores the pointers to functions concerning
* data access for one reader type.(those functions are typically called from
* a decoder) The reader type is one of the M4READER_MediaType
************************************************************************
*/
typedef struct _M4READER_DataInterface
{
M4READER_getNextAu_fct* m_pFctGetNextAu;
/**
stores the context created by the M4READER_create_fct() function
so it is accessible without decoder
*/
M4OSA_Context m_readerContext;
/*****************************************/
} M4READER_DataInterface;
/*****************************************/
#endif /*__M4READER_COMMON_H__*/