From: Sejun Park Date: Mon, 13 Jun 2016 10:29:15 +0000 (+0900) Subject: modify to create caps X-Git-Tag: submit/tizen/20160614.103947^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=6b4f14aec33a1f5c77b0c8500dc9c5e5512799b9;p=platform%2Fcore%2Fapi%2Fmediacodec.git modify to create caps Change-Id: I1e2bb1060f52ba767a6b7f45ab2e1b7044631cd5 --- diff --git a/doc/media_codec_doc.h b/doc/media_codec_doc.h index 28971c8..03bed18 100644 --- a/doc/media_codec_doc.h +++ b/doc/media_codec_doc.h @@ -39,4 +39,4 @@ * */ -#endif // __TIZEN_MEDIA_CODEC_DOC_H__ +#endif /* __TIZEN_MEDIA_CODEC_DOC_H__ */ diff --git a/include/media_codec.h b/include/media_codec.h index 011d5ba..b6fa990 100755 --- a/include/media_codec.h +++ b/include/media_codec.h @@ -48,89 +48,85 @@ typedef struct mediacodec_s *mediacodec_h; * @remarks If this codec is to be used as an encoder or decoder, the codec flag must be set to #MEDIACODEC_ENCODER or * #MEDIACODEC_DECODER. If user doesn't set optional flag, default flags will be set to #MEDIACODEC_SUPPORT_TYPE_SW. */ -typedef enum -{ - MEDIACODEC_ENCODER = 0x1, /**< This flag is for using the encoder */ - MEDIACODEC_DECODER = 0x2, /**< This flag is for using the decoder */ - MEDIACODEC_SUPPORT_TYPE_HW = 0x4, /**< This is an optional flag for using the h/w codec */ - MEDIACODEC_SUPPORT_TYPE_SW = 0x8, /**< This is an optional flag for using the s/w codec */ +typedef enum { + MEDIACODEC_ENCODER = 0x1, /**< This flag is for using the encoder */ + MEDIACODEC_DECODER = 0x2, /**< This flag is for using the decoder */ + MEDIACODEC_SUPPORT_TYPE_HW = 0x4, /**< This is an optional flag for using the h/w codec */ + MEDIACODEC_SUPPORT_TYPE_SW = 0x8, /**< This is an optional flag for using the s/w codec */ } mediacodec_support_type_e; /** * @brief Enumerations of media codec type * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif */ -typedef enum -{ - MEDIACODEC_NONE = 0x0, /**< NONE*/ - MEDIACODEC_L16 = 0x1010, /**< L16*/ - MEDIACODEC_ALAW = 0x1020, /**< ALAW*/ - MEDIACODEC_ULAW = 0x1030, /**< ULAW*/ - MEDIACODEC_AMR = 0x1040, /**< MEDIACDEC_AMR indicates AMR-NB (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_AMR_NB = 0x1040, /**< AMR-NB (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_AMR_WB = 0x1041, /**< AMR-WB (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_G729 = 0x1050, /**< G729*/ - MEDIACODEC_AAC = 0x1060, /**< MEDIACDEC_AAC indicates AAC-LC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_AAC_LC = 0x1060, /**< AAC-LC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_AAC_HE = 0x1061, /**< HE-AAC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_AAC_HE_PS = 0x1062, /**< HE-AAC-PS (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_MP3 = 0x1070, /**< MP3*/ - MEDIACODEC_VORBIS = 0x1080, /**< VORBIS (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_FLAC = 0x1090, /**< FLAC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_WMAV1 = 0x10A0, /**< WMA version 1 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_WMAV2 = 0x10A1, /**< WMA version 2 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_WMAPRO = 0x10A2, /**< WMA Professional (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_WMALSL = 0x10A3, /**< WMA Lossless (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - - MEDIACODEC_H261 = 0x2010, /**< H.261*/ - MEDIACODEC_H263 = 0x2020, /**< H.263*/ - MEDIACODEC_H264 = 0x2030, /**< H.264*/ - MEDIACODEC_MJPEG = 0x2040, /**< MJPEG*/ - MEDIACODEC_MPEG1 = 0x2050, /**< MPEG1*/ - MEDIACODEC_MPEG2 = 0x2060, /**< MPEG2*/ - MEDIACODEC_MPEG4 = 0x2070, /**< MPEG4*/ - MEDIACODEC_HEVC = 0x2080, /**< HEVC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_VP8 = 0x2090, /**< VP8 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_VP9 = 0x20A0, /**< VP9 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_VC1 = 0x20B0, /**< VC1 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ +typedef enum { + MEDIACODEC_NONE = 0x0, /**< NONE*/ + MEDIACODEC_L16 = 0x1010, /**< L16*/ + MEDIACODEC_ALAW = 0x1020, /**< ALAW*/ + MEDIACODEC_ULAW = 0x1030, /**< ULAW*/ + MEDIACODEC_AMR = 0x1040, /**< MEDIACDEC_AMR indicates AMR-NB (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_AMR_NB = 0x1040, /**< AMR-NB (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_AMR_WB = 0x1041, /**< AMR-WB (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_G729 = 0x1050, /**< G729*/ + MEDIACODEC_AAC = 0x1060, /**< MEDIACDEC_AAC indicates AAC-LC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_AAC_LC = 0x1060, /**< AAC-LC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_AAC_HE = 0x1061, /**< HE-AAC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_AAC_HE_PS = 0x1062, /**< HE-AAC-PS (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_MP3 = 0x1070, /**< MP3*/ + MEDIACODEC_VORBIS = 0x1080, /**< VORBIS (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_FLAC = 0x1090, /**< FLAC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_WMAV1 = 0x10A0, /**< WMA version 1 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_WMAV2 = 0x10A1, /**< WMA version 2 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_WMAPRO = 0x10A2, /**< WMA Professional (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_WMALSL = 0x10A3, /**< WMA Lossless (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + + MEDIACODEC_H261 = 0x2010, /**< H.261*/ + MEDIACODEC_H263 = 0x2020, /**< H.263*/ + MEDIACODEC_H264 = 0x2030, /**< H.264*/ + MEDIACODEC_MJPEG = 0x2040, /**< MJPEG*/ + MEDIACODEC_MPEG1 = 0x2050, /**< MPEG1*/ + MEDIACODEC_MPEG2 = 0x2060, /**< MPEG2*/ + MEDIACODEC_MPEG4 = 0x2070, /**< MPEG4*/ + MEDIACODEC_HEVC = 0x2080, /**< HEVC (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_VP8 = 0x2090, /**< VP8 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_VP9 = 0x20A0, /**< VP9 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_VC1 = 0x20B0, /**< VC1 (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ } mediacodec_codec_type_e; /** * @brief Enumeration of media codec error * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif */ -typedef enum -{ - MEDIACODEC_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ - MEDIACODEC_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ - MEDIACODEC_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ - MEDIACODEC_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */ - MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ - MEDIACODEC_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ - MEDIACODEC_ERROR_INVALID_STATE = TIZEN_ERROR_MEDIACODEC | 0x01, /**< Invalid state */ - MEDIACODEC_ERROR_INVALID_INBUFFER = TIZEN_ERROR_MEDIACODEC | 0x02, /**< Invalid input buffer */ - MEDIACODEC_ERROR_INVALID_OUTBUFFER = TIZEN_ERROR_MEDIACODEC | 0x03, /**< Invalid output buffer */ - MEDIACODEC_ERROR_INTERNAL = TIZEN_ERROR_MEDIACODEC | 0x04, /**< Internal error */ - MEDIACODEC_ERROR_NOT_INITIALIZED = TIZEN_ERROR_MEDIACODEC | 0x05, /**< Not initialized mediacodec */ - MEDIACODEC_ERROR_INVALID_STREAM = TIZEN_ERROR_MEDIACODEC | 0x06, /**< Invalid stream */ - MEDIACODEC_ERROR_CODEC_NOT_FOUND = TIZEN_ERROR_MEDIACODEC | 0x07, /**< Not supported format */ - MEDIACODEC_ERROR_DECODE = TIZEN_ERROR_MEDIACODEC | 0x08, /**< Error while decoding data */ - MEDIACODEC_ERROR_NO_FREE_SPACE = TIZEN_ERROR_MEDIACODEC | 0x09, /**< Out of storage */ - MEDIACODEC_ERROR_STREAM_NOT_FOUND = TIZEN_ERROR_MEDIACODEC | 0x0a, /**< Cannot find stream */ - MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT = TIZEN_ERROR_MEDIACODEC | 0x0b, /**< Not supported format */ - MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE = TIZEN_ERROR_MEDIACODEC | 0x0c, /**< Not available buffer */ - MEDIACODEC_ERROR_OVERFLOW_INBUFFER = TIZEN_ERROR_MEDIACODEC | 0x0d, /**< Overflow input buffer (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ - MEDIACODEC_ERROR_RESOURCE_OVERLOADED = TIZEN_ERROR_MEDIACODEC | 0x0e, /**< Exceed the instance limits (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ +typedef enum { + MEDIACODEC_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + MEDIACODEC_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ + MEDIACODEC_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ + MEDIACODEC_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */ + MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ + MEDIACODEC_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ + MEDIACODEC_ERROR_INVALID_STATE = TIZEN_ERROR_MEDIACODEC | 0x01, /**< Invalid state */ + MEDIACODEC_ERROR_INVALID_INBUFFER = TIZEN_ERROR_MEDIACODEC | 0x02, /**< Invalid input buffer */ + MEDIACODEC_ERROR_INVALID_OUTBUFFER = TIZEN_ERROR_MEDIACODEC | 0x03, /**< Invalid output buffer */ + MEDIACODEC_ERROR_INTERNAL = TIZEN_ERROR_MEDIACODEC | 0x04, /**< Internal error */ + MEDIACODEC_ERROR_NOT_INITIALIZED = TIZEN_ERROR_MEDIACODEC | 0x05, /**< Not initialized mediacodec */ + MEDIACODEC_ERROR_INVALID_STREAM = TIZEN_ERROR_MEDIACODEC | 0x06, /**< Invalid stream */ + MEDIACODEC_ERROR_CODEC_NOT_FOUND = TIZEN_ERROR_MEDIACODEC | 0x07, /**< Not supported format */ + MEDIACODEC_ERROR_DECODE = TIZEN_ERROR_MEDIACODEC | 0x08, /**< Error while decoding data */ + MEDIACODEC_ERROR_NO_FREE_SPACE = TIZEN_ERROR_MEDIACODEC | 0x09, /**< Out of storage */ + MEDIACODEC_ERROR_STREAM_NOT_FOUND = TIZEN_ERROR_MEDIACODEC | 0x0a, /**< Cannot find stream */ + MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT = TIZEN_ERROR_MEDIACODEC | 0x0b, /**< Not supported format */ + MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE = TIZEN_ERROR_MEDIACODEC | 0x0c, /**< Not available buffer */ + MEDIACODEC_ERROR_OVERFLOW_INBUFFER = TIZEN_ERROR_MEDIACODEC | 0x0d, /**< Overflow input buffer (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ + MEDIACODEC_ERROR_RESOURCE_OVERLOADED = TIZEN_ERROR_MEDIACODEC | 0x0e, /**< Exceed the instance limits (Since @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif)*/ } mediacodec_error_e; /** * @brief Enumeration of buffer status * @since_tizen @if MOBILE 2.4 @elseif WEARABLE 3.0 @endif */ -typedef enum -{ - MEDIACODEC_NEED_DATA, - MEDIACODEC_ENOUGH_DATA +typedef enum { + MEDIACODEC_NEED_DATA, + MEDIACODEC_ENOUGH_DATA } mediacodec_status_e; /** @@ -358,7 +354,7 @@ int mediacodec_unprepare(mediacodec_h mediacodec); * @retval #MEDIACODEC_ERROR_INVALID_OPERATION Invalid operation * @retval #MEDIACODEC_ERROR_OVERFLOW_INBUFFER Overflow inputbuffer */ -int mediacodec_process_input (mediacodec_h mediacodec, media_packet_h inbuf, uint64_t timeOutUs); +int mediacodec_process_input(mediacodec_h mediacodec, media_packet_h inbuf, uint64_t timeOutUs); /** * @brief Gets the decoded or encoded packet from the output queue. @@ -374,7 +370,7 @@ int mediacodec_process_input (mediacodec_h mediacodec, media_packet_h inbuf, uin * @retval #MEDIACODEC_ERROR_OUT_OF_MEMORY Out of memory * @retval #MEDIACODEC_ERROR_INVALID_OPERATION Invalid operation */ -int mediacodec_get_output (mediacodec_h mediacodec, media_packet_h *outbuf, uint64_t timeOutUs); +int mediacodec_get_output(mediacodec_h mediacodec, media_packet_h *outbuf, uint64_t timeOutUs); /** * @brief Flushes both input and output buffers. @@ -384,7 +380,7 @@ int mediacodec_get_output (mediacodec_h mediacodec, media_packet_h *outbuf, uint * @retval #MEDIACODEC_ERROR_NONE Successful * @retval #MEDIACODEC_ERROR_INVALID_PARAMETER Invalid parameter */ -int mediacodec_flush_buffers (mediacodec_h mediacodec); +int mediacodec_flush_buffers(mediacodec_h mediacodec); /** * @brief set empty buffer callback the media codec for process, asynchronously. diff --git a/include/media_codec_bitstream.h b/include/media_codec_bitstream.h index 44329ba..e8af1af 100755 --- a/include/media_codec_bitstream.h +++ b/include/media_codec_bitstream.h @@ -22,61 +22,56 @@ typedef struct _mc_bitstream_t mc_bitstream_t; -typedef enum -{ - NAL_SLICE_NO_PARTITIONING = 1, - NAL_SLICE_PART_A, - NAL_SLICE_PART_B, - NAL_SLICE_PART_C, - NAL_SLICE_IDR, - NAL_SEI, - NAL_SEQUENCE_PARAMETER_SET, - NAL_PICTURE_PARAMETER_SET, - NAL_PICTURE_DELIMITER, - NAL_END_OF_SEQUENCE, - NAL_END_OF_STREAM, - NAL_FILLER_DATA, - NAL_PREFIX_SVC = 14 +typedef enum { + NAL_SLICE_NO_PARTITIONING = 1, + NAL_SLICE_PART_A, + NAL_SLICE_PART_B, + NAL_SLICE_PART_C, + NAL_SLICE_IDR, + NAL_SEI, + NAL_SEQUENCE_PARAMETER_SET, + NAL_PICTURE_PARAMETER_SET, + NAL_PICTURE_DELIMITER, + NAL_END_OF_SEQUENCE, + NAL_END_OF_STREAM, + NAL_FILLER_DATA, + NAL_PREFIX_SVC = 14 } mc_nal_unit_type_e; -enum -{ - MC_EXIST_SPS = 1 << 0, - MC_EXIST_PPS = 1 << 1, - MC_EXIST_IDR = 1 << 2, - MC_EXIST_SLICE = 1 << 3, +enum { + MC_EXIST_SPS = 1 << 0, + MC_EXIST_PPS = 1 << 1, + MC_EXIST_IDR = 1 << 2, + MC_EXIST_SLICE = 1 << 3, - MC_VALID_HEADER = ( MC_EXIST_SPS | MC_EXIST_PPS ), - MC_VALID_FIRST_SLICE = ( MC_EXIST_SPS | MC_EXIST_PPS | MC_EXIST_IDR ) + MC_VALID_HEADER = (MC_EXIST_SPS | MC_EXIST_PPS), + MC_VALID_FIRST_SLICE = (MC_EXIST_SPS | MC_EXIST_PPS | MC_EXIST_IDR) }; #define CHECK_VALID_PACKET(state, expected_state) \ - ((state & (expected_state)) == (expected_state)) - -static const unsigned int mask[33] = -{ - 0x00000000, 0x00000001, 0x00000003, 0x00000007, - 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f, - 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, - 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, - 0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff, - 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff, - 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff, - 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, - 0xffffffff + ((state & (expected_state)) == (expected_state)) + +static const unsigned int mask[33] = { + 0x00000000, 0x00000001, 0x00000003, 0x00000007, + 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f, + 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, + 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, + 0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff, + 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff, + 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff, + 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, + 0xffffffff }; -struct _mc_bitstream_t -{ - unsigned char *data; - unsigned int numBytes; - unsigned int bytePos; - unsigned int buffer; - unsigned int dataBitPos; - unsigned int bitcnt; +struct _mc_bitstream_t { + unsigned char *data; + unsigned int numBytes; + unsigned int bytePos; + unsigned int buffer; + unsigned int dataBitPos; + unsigned int bitcnt; }; - #ifdef __cplusplus extern "C" { #endif @@ -84,28 +79,26 @@ extern "C" { #define MC_READ16B(x) ((((const unsigned char*)(x))[0] << 8) | ((const unsigned char*)(x))[1]) #define MC_READ32B(x) ((((const unsigned char*)(x))[0] << 24) | \ - (((const unsigned char*)(x))[1] << 16) | \ - (((const unsigned char*)(x))[2] << 8) | \ - ((const unsigned char*)(x))[3]) + (((const unsigned char*)(x))[1] << 16) | \ + (((const unsigned char*)(x))[2] << 8) | \ + ((const unsigned char*)(x))[3]) void mc_init_bits(mc_bitstream_t *stream, unsigned char *data, int size); short mc_show_bits(mc_bitstream_t *stream, unsigned char nbits, unsigned int *pulOutData); -short mc_read_bits( mc_bitstream_t *stream, unsigned char nbits, unsigned int *pulOutData ); -short mc_byte_align( mc_bitstream_t *stream ); +short mc_read_bits(mc_bitstream_t *stream, unsigned char nbits, unsigned int *pulOutData); +short mc_byte_align(mc_bitstream_t *stream); bool _mc_is_voss(unsigned char *buf, int size, int *codec_size); bool _mc_is_ivop(unsigned char *p, int size, int pos); bool _mc_is_vop(unsigned char *p, int size, int pos); - int __mc_decode_sps(mc_bitstream_t *pstream, int *width, int *height); -unsigned int __mc_bytestream_to_nal( unsigned char* data, int size ); -int _mc_check_h264_bytestream ( unsigned char *nal, int byte_length, bool port, bool *codec_config, bool *sync_flag, bool *slice); +unsigned int __mc_bytestream_to_nal(unsigned char* data, int size); +int _mc_check_h264_bytestream(unsigned char *nal, int byte_length, bool port, bool *codec_config, bool *sync_flag, bool *slice); int _mc_check_valid_h263_frame(unsigned char *p, int size); bool _mc_check_h263_out_bytestream(unsigned char *p, int buf_length, bool* need_sync_flag); int _mc_check_mpeg4_out_bytestream(unsigned char *buf, int buf_length, bool* need_codec_data, bool *need_sync_flag); - #ifdef __cplusplus } #endif diff --git a/include/media_codec_port.h b/include/media_codec_port.h index e31dfd8..2b7ec12 100755 --- a/include/media_codec_port.h +++ b/include/media_codec_port.h @@ -43,16 +43,17 @@ #define GET_IS_DECODER(x) CHECK_BIT(x, 1) #define GET_IS_HW(x) CHECK_BIT(x, 2) #define GET_IS_SW(x) CHECK_BIT(x, 3) - -//#define GET_IS_OMX(x) CHECK_BIT(x, 4) -//#define GET_IS_GEN(x) CHECK_BIT(x, 5) +/* +#define GET_IS_OMX(x) CHECK_BIT(x, 4) +#define GET_IS_GEN(x) CHECK_BIT(x, 5) +*/ #if 1 #define MEDIACODEC_FENTER(); #define MEDIACODEC_FLEAVE(); #else -#define MEDIACODEC_FENTER(); LOGW("%s Enter",__FUNCTION__); -#define MEDIACODEC_FLEAVE(); LOGW("%s Exit",__FUNCTION__); +#define MEDIACODEC_FENTER(); LOGW("%s Enter", __FUNCTION__); +#define MEDIACODEC_FLEAVE(); LOGW("%s Exit", __FUNCTION__); #endif /*--------------------------------------------------------------------------- @@ -61,8 +62,7 @@ /** * @brief Enumerations of media codec port's retrun value */ -typedef enum -{ +typedef enum { MC_ERROR_NONE = 0, MC_ERROR = -1, /**< codec happens error */ MC_MEMORY_ERROR = -2, /**< codec memory is not enough */ @@ -112,100 +112,94 @@ typedef void (*mc_buffer_status_cb)(mediacodec_status_e status, void *user_data) typedef void (*mc_supported_codec_cb)(mediacodec_codec_type_e codec_type, void *user_data); typedef enum { - _MEDIACODEC_EVENT_TYPE_COMPLETE, - _MEDIACODEC_EVENT_TYPE_EMPTYBUFFER, - _MEDIACODEC_EVENT_TYPE_FILLBUFFER, - _MEDIACODEC_EVENT_TYPE_ERROR, - _MEDIACODEC_EVENT_TYPE_EOS, - _MEDIACODEC_EVENT_TYPE_BUFFER_STATUS, - _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER, - _MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC, - _MEDIACODEC_EVENT_TYPE_NUM + _MEDIACODEC_EVENT_TYPE_COMPLETE, + _MEDIACODEC_EVENT_TYPE_EMPTYBUFFER, + _MEDIACODEC_EVENT_TYPE_FILLBUFFER, + _MEDIACODEC_EVENT_TYPE_ERROR, + _MEDIACODEC_EVENT_TYPE_EOS, + _MEDIACODEC_EVENT_TYPE_BUFFER_STATUS, + _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER, + _MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC, + _MEDIACODEC_EVENT_TYPE_NUM } _mediacodec_event_e; -typedef enum _mc_codec_port_type_e -{ - CODEC_PORT_TYPE_GENERAL, - CODEC_PORT_TYPE_OMX, - CODEC_PORT_TYPE_GST, - CODEC_PORT_TYPE_MAX, +typedef enum _mc_codec_port_type_e { + CODEC_PORT_TYPE_GENERAL, + CODEC_PORT_TYPE_OMX, + CODEC_PORT_TYPE_GST, + CODEC_PORT_TYPE_MAX, } mc_codec_port_type_e; -typedef enum _mc_vendor_e -{ - MC_VENDOR_DEFAULT, - MC_VENDOR_SLSI_SEC, - MC_VENDOR_SLSI_EXYNOS, - MC_VENDOR_QCT, - MC_VENDOR_SPRD +typedef enum _mc_vendor_e { + MC_VENDOR_DEFAULT, + MC_VENDOR_SLSI_SEC, + MC_VENDOR_SLSI_EXYNOS, + MC_VENDOR_QCT, + MC_VENDOR_SPRD } mc_vendor_e; -struct _mc_decoder_info_t -{ - int width; - int height; - int actwidth; - int actheight; +struct _mc_decoder_info_t { + int width; + int height; + int actwidth; + int actheight; - int samplerate; - int channel; - int bit; + int samplerate; + int channel; + int bit; }; -struct _mc_encoder_info_t -{ - int width; - int height; - int bitrate; - int format; - int fps; - int qp_min; - int qp_max; - int vbvbuffer_size; - int level; - int profile; - - int samplerate; - int channel; - int bit; +struct _mc_encoder_info_t { + int width; + int height; + int bitrate; + int format; + int fps; + int qp_min; + int qp_max; + int vbvbuffer_size; + int level; + int profile; + + int samplerate; + int channel; + int bit; }; /* Codec Private data */ -struct _mc_handle_t -{ - int state; /**< mc current state */ - bool is_encoder; - bool is_video; - bool is_hw; - bool is_prepared; - - GList *supported_codecs; - mediacodec_port_type_e port_type; - mediacodec_codec_type_e codec_id; - mc_vendor_e vendor; - - void *ports[2]; - void *core; - - union - { - mc_decoder_info_t decoder; - mc_encoder_info_t encoder; - } info; - - /* for process done cb */ - void* user_cb[_MEDIACODEC_EVENT_TYPE_NUM]; - void* user_data[_MEDIACODEC_EVENT_TYPE_NUM]; - - mc_codec_map_t encoder_map[MEDIA_CODEC_MAX_CODEC_TYPE]; - mc_codec_map_t decoder_map[MEDIA_CODEC_MAX_CODEC_TYPE]; - - int num_supported_codecs; - int num_supported_decoder; - int num_supported_encoder; - - mc_ini_t ini; +struct _mc_handle_t { + int state; /**< mc current state */ + bool is_encoder; + bool is_video; + bool is_hw; + bool is_prepared; + + GList *supported_codecs; + mediacodec_port_type_e port_type; + mediacodec_codec_type_e codec_id; + mc_vendor_e vendor; + + void *ports[2]; + void *core; + + union { + mc_decoder_info_t decoder; + mc_encoder_info_t encoder; + } info; + + /* for process done cb */ + void* user_cb[_MEDIACODEC_EVENT_TYPE_NUM]; + void* user_data[_MEDIACODEC_EVENT_TYPE_NUM]; + + mc_codec_map_t encoder_map[MEDIA_CODEC_MAX_CODEC_TYPE]; + mc_codec_map_t decoder_map[MEDIA_CODEC_MAX_CODEC_TYPE]; + + int num_supported_codecs; + int num_supported_decoder; + int num_supported_encoder; + + mc_ini_t ini; }; /*=========================================================================================== diff --git a/include/media_codec_port_gst.h b/include/media_codec_port_gst.h index 52793e2..552162d 100755 --- a/include/media_codec_port_gst.h +++ b/include/media_codec_port_gst.h @@ -36,21 +36,23 @@ extern "C" { #endif #define GST_INIT_STRUCTURE(param) \ - memset(&(param), 0, sizeof(param)); - -#define MEDIACODEC_ELEMENT_SET_STATE( x_element, x_state ) \ - do { \ - LOGD("setting state [%s:%d] to [%s]\n", #x_state, x_state, GST_ELEMENT_NAME( x_element ) ); \ - if ( GST_STATE_CHANGE_FAILURE == gst_element_set_state ( x_element, x_state) ) \ - { \ - LOGE("failed to set state %s to %s\n", #x_state, GST_ELEMENT_NAME( x_element )); \ - goto STATE_CHANGE_FAILED; \ - } \ - } while (0) + memset(&(param), 0, sizeof(param)); + +#define MEDIACODEC_ELEMENT_SET_STATE(x_element, x_state) \ + do { \ + LOGD("setting state [%s:%d] to [%s]\n", #x_state, x_state, GST_ELEMENT_NAME(x_element)); \ + if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(x_element, x_state)) { \ + LOGE("failed to set state %s to %s\n", #x_state, GST_ELEMENT_NAME(x_element)); \ + goto STATE_CHANGE_FAILED; \ + } \ + } while (0) #define SCMN_IMGB_MAX_PLANE 4 #define TBM_API_CHANGE #define DEFAULT_POOL_SIZE 20 +#define AAC_CODECDATA_SIZE 16 +#define WMA_CODECDATA_SIZE 64 +#define VORBIS_CODECDATA_SIZE 4096 /* gst port layer */ typedef struct _mc_gst_port_t mc_gst_port_t; @@ -73,8 +75,7 @@ struct ion_mmu_data { }; #endif -struct _mc_gst_port_t -{ +struct _mc_gst_port_t { mc_gst_core_t *core; unsigned int num_buffers; unsigned int buffer_size; @@ -86,17 +87,17 @@ struct _mc_gst_port_t GCond buffer_cond; }; -struct _mc_gst_core_t -{ +struct _mc_gst_core_t { int(**vtable)(); const char *mime; gchar *format; - GstElement* pipeline; - GstElement* appsrc; - GstElement* capsfilter; - GstElement* parser; - GstElement* fakesink; - GstElement* codec; + GstElement *pipeline; + GstElement *appsrc; + GstElement *capsfilter; + GstElement *parser; + GstElement *fakesink; + GstElement *codec; + GstCaps *caps; tbm_bufmgr bufmgr; int drm_fd; @@ -143,8 +144,7 @@ struct _mc_gst_core_t void* user_data[_MEDIACODEC_EVENT_TYPE_NUM]; }; -struct _GstMCBuffer -{ +struct _GstMCBuffer { GstBuffer *buffer; int buf_size; mc_gst_core_t* core; @@ -152,11 +152,10 @@ struct _GstMCBuffer bool has_imgb; }; -enum { fill_inbuf, fill_outbuf, create_caps }; +enum { fill_inbuf, fill_outbuf }; int __mc_fill_input_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff); int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt); -int __mc_create_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config); int __mc_fill_input_buffer_with_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff); int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer); @@ -165,31 +164,6 @@ int __mc_fill_packet_with_output_buffer(mc_gst_core_t *core, void *data, int siz int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt); int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *pkt); -int __mc_vdec_sw_h264_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_vdec_hw_h264_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_venc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_vdec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_vdec_sw_h263_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_vdec_hw_h263_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_vdec_h263_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_vdec_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_h264dec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_aenc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_adec_aac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_aenc_aac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_adec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_adec_aacv12_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_adec_mp3_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_adec_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_adec_amrwb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_aenc_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_adec_vorbis_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_adec_flac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); -int __mc_adec_wma_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config); - -void _mc_create_codec_map_from_ini(mc_handle_t *mc_handle, mc_codec_spec_t *spec_emul); -void _mc_create_decoder_map_from_ini(mc_handle_t *mc_handle); -void _mc_create_encoder_map_from_ini(mc_handle_t *mc_handle); mc_gst_core_t *mc_gst_core_new(); void mc_gst_core_free(mc_gst_core_t *core); diff --git a/include/media_codec_private.h b/include/media_codec_private.h index c703087..dc5d663 100755 --- a/include/media_codec_private.h +++ b/include/media_codec_private.h @@ -34,89 +34,85 @@ extern "C" { #define LOG_TAG "TIZEN_N_MEDIACODEC" -#define MEDIACODEC_CHECK_CONDITION(condition,error,msg) \ - if(condition) {} else \ - { LOGE("[%s] %s(0x%08x)",__FUNCTION__, msg,error); return error;}; \ +#define MEDIACODEC_CHECK_CONDITION(condition, error, msg) \ + if (condition) {} else \ + {LOGE("[%s] %s(0x%08x)", __FUNCTION__, msg, error); return error; }; \ #define MEDIACODEC_INSTANCE_CHECK(mediacodec) \ - MEDIACODEC_CHECK_CONDITION(mediacodec != NULL, MEDIACODEC_ERROR_INVALID_PARAMETER,"MEDIACODEC_ERROR_INVALID_PARAMETER") + MEDIACODEC_CHECK_CONDITION(mediacodec != NULL, MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER") -#define MEDIACODEC_STATE_CHECK(mediacodec,expected_state) \ - MEDIACODEC_CHECK_CONDITION(mediacodec->state == expected_state,MEDIACODEC_ERROR_INVALID_STATE,"MEDIACODEC_ERROR_INVALID_STATE") +#define MEDIACODEC_STATE_CHECK(mediacodec, expected_state) \ + MEDIACODEC_CHECK_CONDITION(mediacodec->state == expected_state, MEDIACODEC_ERROR_INVALID_STATE, "MEDIACODEC_ERROR_INVALID_STATE") #define MEDIACODEC_NULL_ARG_CHECK(arg) \ - MEDIACODEC_CHECK_CONDITION(arg != NULL,MEDIACODEC_ERROR_INVALID_PARAMETER,"MEDIACODEC_ERROR_INVALID_PARAMETER") + MEDIACODEC_CHECK_CONDITION(arg != NULL, MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER") #define MEDIACODEC_SUPPORT_CHECK(arg) \ - MEDIACODEC_CHECK_CONDITION(arg != false, MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE, "MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE") + MEDIACODEC_CHECK_CONDITION(arg != false, MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE, "MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE") /** * @brief Enumeration of media codec state * @since_tizen 2.3 */ -typedef enum -{ - MEDIACODEC_STATE_NONE = 0, /**< Media codec is not created */ - MEDIACODEC_STATE_IDLE, /**< Media codec is created, but not prepared */ - MEDIACODEC_STATE_READY, /**< Media codec is ready to process */ - MEDIACODEC_STATE_EXCUTE, /**< Media codec is executing media */ +typedef enum { + MEDIACODEC_STATE_NONE = 0, /**< Media codec is not created */ + MEDIACODEC_STATE_IDLE, /**< Media codec is created, but not prepared */ + MEDIACODEC_STATE_READY, /**< Media codec is ready to process */ + MEDIACODEC_STATE_EXCUTE, /**< Media codec is executing media */ } mediacodec_state_e; -typedef enum -{ - MEDIACODEC_SUPPORT_TYPE_OMX = 0x10, /**< This is optional flag for using openmax il */ - MEDIACODEC_SUPPORT_TYPE_GEN = 0x20 /**< This is optional flag for using general codec */ +typedef enum { + MEDIACODEC_SUPPORT_TYPE_OMX = 0x10, /**< This is optional flag for using openmax il */ + MEDIACODEC_SUPPORT_TYPE_GEN = 0x20 /**< This is optional flag for using general codec */ } mediacodec_internal_support_type_e; -typedef enum -{ - MEDIACODEC_PORT_TYPE_GENERAL, - MEDIACODEC_PORT_TYPE_OMX, - MEDIACODEC_PORT_TYPE_GST, - MEDIACODEC_PORT_TYPE_MAX, +typedef enum { + MEDIACODEC_PORT_TYPE_GENERAL, + MEDIACODEC_PORT_TYPE_OMX, + MEDIACODEC_PORT_TYPE_GST, + MEDIACODEC_PORT_TYPE_MAX, } mediacodec_port_type_e; /** * @brief Media Codec's format for configuring codec. */ typedef struct _mediacodecformat_s { - // Video - int fps; - int height; - int width; - float aspect; - bool vfr; - int level; - int profile; - - // Audio - int channels; - int samplerate; - int bitrate; - - // Codec Extra Data - void * extradata; - unsigned int extrasize; + /* Video */ + int fps; + int height; + int width; + float aspect; + bool vfr; + int level; + int profile; + + /* Audio */ + int channels; + int samplerate; + int bitrate; + + /* Codec Extra Data */ + void * extradata; + unsigned int extrasize; } mediacodec_format_s; typedef struct _mediacodec_s { - MMHandleType mc_handle; - int state; - bool is_omx; - char *m_mime; - - mediacodec_input_buffer_used_cb empty_buffer_cb; - void* empty_buffer_cb_userdata; - mediacodec_output_buffer_available_cb fill_buffer_cb; - void* fill_buffer_cb_userdata; - mediacodec_error_cb error_cb; - void* error_cb_userdata; - mediacodec_eos_cb eos_cb; - void* eos_cb_userdata; - mediacodec_buffer_status_cb buffer_status_cb; - void* buffer_status_cb_userdata; - mediacodec_supported_codec_cb supported_codec_cb; - void* supported_codec_cb_userdata; - + MMHandleType mc_handle; + int state; + bool is_omx; + char *m_mime; + + mediacodec_input_buffer_used_cb empty_buffer_cb; + void* empty_buffer_cb_userdata; + mediacodec_output_buffer_available_cb fill_buffer_cb; + void* fill_buffer_cb_userdata; + mediacodec_error_cb error_cb; + void* error_cb_userdata; + mediacodec_eos_cb eos_cb; + void* eos_cb_userdata; + mediacodec_buffer_status_cb buffer_status_cb; + void* buffer_status_cb_userdata; + mediacodec_supported_codec_cb supported_codec_cb; + void* supported_codec_cb_userdata; } mediacodec_s; bool __mediacodec_state_validate(mediacodec_h mediacodec, mediacodec_state_e threshold); diff --git a/include/media_codec_queue.h b/include/media_codec_queue.h index 5242997..cc8fe24 100755 --- a/include/media_codec_queue.h +++ b/include/media_codec_queue.h @@ -24,37 +24,29 @@ extern "C" { #endif typedef struct _async_queue { - GMutex mutex; - GCond condition; - GList *head; - GList *tail; - guint length; - gboolean enabled; + GMutex mutex; + GCond condition; + GList *head; + GList *tail; + guint length; + gboolean enabled; } async_queue_t; typedef struct _mc_aqueue { - GThread *thread; - gint running; - async_queue_t *input; - async_queue_t *output; + GThread *thread; + gint running; + async_queue_t *input; + async_queue_t *output; } mc_aqueue_t; async_queue_t *mc_async_queue_new(); - void mc_async_queue_free(async_queue_t *async_queue); - void mc_async_queue_push(async_queue_t *async_queue, gpointer data); - -gpointer mc_async_queue_pop_forced (async_queue_t * async_queue); - +gpointer mc_async_queue_pop_forced(async_queue_t *async_queue); gpointer mc_async_queue_pop(async_queue_t *async_queue); - -void mc_async_queue_disable (async_queue_t *async_queue); - -void mc_async_queue_enable (async_queue_t *async_queue); - +void mc_async_queue_disable(async_queue_t *async_queue); +void mc_async_queue_enable(async_queue_t *async_queue); void mc_async_queue_flush(async_queue_t *async_queue); - gboolean mc_async_queue_is_empty(async_queue_t *async_queue); #ifdef __cplusplus diff --git a/include/media_codec_spec_emul.h b/include/media_codec_spec_emul.h index 3ba2129..4fc7f6f 100755 --- a/include/media_codec_spec_emul.h +++ b/include/media_codec_spec_emul.h @@ -23,32 +23,29 @@ extern "C" { #include -enum { DECODER, ENCODER }; -enum { SOFTWARE, HARDWARE }; +enum {DECODER, ENCODER}; +enum {SOFTWARE, HARDWARE}; typedef struct _mc_codec_spec_t mc_codec_spec_t; typedef struct _mc_codec_map_t mc_codec_map_t; typedef struct _mc_codec_type_t mc_codec_type_t; -struct _mc_codec_spec_t -{ - mediacodec_codec_type_e codec_id; - mediacodec_support_type_e codec_type; - mediacodec_port_type_e port_type; +struct _mc_codec_spec_t { + mediacodec_codec_type_e codec_id; + mediacodec_support_type_e codec_type; + mediacodec_port_type_e port_type; }; -struct _mc_codec_type_t -{ - char *factory_name; - char *mime; - media_format_mimetype_e out_format; +struct _mc_codec_type_t { + char *factory_name; + char *mime; + media_format_mimetype_e out_format; }; -struct _mc_codec_map_t -{ - mediacodec_codec_type_e id; - bool hardware; - mc_codec_type_t type; +struct _mc_codec_map_t { + mediacodec_codec_type_e id; + bool hardware; + mc_codec_type_t type; }; diff --git a/include/media_codec_util.h b/include/media_codec_util.h index d88b889..988a54a 100755 --- a/include/media_codec_util.h +++ b/include/media_codec_util.h @@ -21,34 +21,31 @@ #include #include #include -//#include #ifdef __cplusplus extern "C" { #endif -typedef enum -{ - CODEC_RET_SUCCESS = 0, - CODEC_RET_FAIL = -1, - CODEC_RET_NOT_SUPPORT = -2, - CODEC_RET_INVALID_ARG = -3, - CODEC_RET_INVALID_CONFIG = -4, - CODEC_RET_CORRUPTED_BS = -5, - CODEC_RET_SMALL_IMG_BUF = -6, - CODEC_RET_HW_ERROR = -7, - CODEC_RET_NOT_AVAILABLE = -8, - CODEC_RET_NOT_EXPECTED = -9, - CODEC_RET_UNKNOWN_ERR = -100, +typedef enum { + CODEC_RET_SUCCESS = 0, + CODEC_RET_FAIL = -1, + CODEC_RET_NOT_SUPPORT = -2, + CODEC_RET_INVALID_ARG = -3, + CODEC_RET_INVALID_CONFIG = -4, + CODEC_RET_CORRUPTED_BS = -5, + CODEC_RET_SMALL_IMG_BUF = -6, + CODEC_RET_HW_ERROR = -7, + CODEC_RET_NOT_AVAILABLE = -8, + CODEC_RET_NOT_EXPECTED = -9, + CODEC_RET_UNKNOWN_ERR = -100, } CodecRet; typedef struct _mc_sem_t mc_sem_t; -struct _mc_sem_t -{ - GCond cond; - GMutex mutex; - int counter; +struct _mc_sem_t { + GCond cond; + GMutex mutex; + int counter; }; mc_sem_t *mc_sem_new(); @@ -59,9 +56,9 @@ void mc_sem_up(mc_sem_t *sem); void mc_hex_dump(char *desc, void *addr, int len); #define MC_FREEIF(x) \ -if ( x ) \ - g_free( x ); \ -x = NULL; + if (x) \ + g_free(x); \ + x = NULL; #ifdef __cplusplus } diff --git a/src/media_codec.c b/src/media_codec.c index 0bfcaf2..c8d6e20 100755 --- a/src/media_codec.c +++ b/src/media_codec.c @@ -490,12 +490,12 @@ int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_suppo } -int mediacodec_get_packet_pool(mediacodec_h mediacodec,media_packet_pool_h *pkt_pool) +int mediacodec_get_packet_pool(mediacodec_h mediacodec, media_packet_pool_h *pkt_pool) { MEDIACODEC_INSTANCE_CHECK(mediacodec); mediacodec_s *handle = (mediacodec_s *)mediacodec; MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY); - int ret = mc_get_packet_pool(handle->mc_handle,pkt_pool); + int ret = mc_get_packet_pool(handle->mc_handle, pkt_pool); if (ret != MEDIACODEC_ERROR_NONE) return MEDIACODEC_ERROR_INVALID_OPERATION; diff --git a/src/media_codec_port.c b/src/media_codec_port.c index 468efde..edb2d20 100755 --- a/src/media_codec_port.c +++ b/src/media_codec_port.c @@ -739,7 +739,7 @@ int mc_get_packet_pool(MMHandleType mediacodec, media_packet_pool_h *pool) break; case MEDIACODEC_PORT_TYPE_GST: - ret = mc_gst_get_packet_pool(mc_handle, pool); + ret = mc_gst_get_packet_pool(mc_handle, pool); break; default: diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c index 40e9315..9e82cb4 100755 --- a/src/media_codec_port_gst.c +++ b/src/media_codec_port_gst.c @@ -48,9 +48,9 @@ static mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name static mc_ret_e _mc_gst_destroy_pipeline(mc_gst_core_t *core); static void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data); static int __mc_output_buffer_finalize_cb(media_packet_h packet, int error_code, void *user_data); -static void _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstCaps **caps, GstMCBuffer* buff, bool codec_config); +static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer* buff, bool codec_config); static gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt); -static GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, GstCaps **caps, media_packet_h pkt, bool codec_config); +static GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h pkt, bool codec_config); static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *buff); static gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw); static media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *data, int size); @@ -59,8 +59,8 @@ static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h pkt); static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t* core, media_packet_h pkt, uint64_t size); static void gst_mediacodec_buffer_finalize(GstMCBuffer *buffer); -static int __mc_set_caps_streamheader(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer*buff, guint streamheader_size); -static int __mc_set_caps_codecdata(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer*buff, guint codecdata_size); +static int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint streamheader_size); +static int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer*buff, guint codecdata_size); static gint __gst_handle_stream_error(mc_gst_core_t *core, GError *error, GstMessage *message); static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage *message, GError *error); @@ -89,96 +89,75 @@ static void _mc_wait_for_eos(mc_gst_core_t *core); static int _mediacodec_get_mime(mc_gst_core_t *core); /* video vtable */ -int(*vdec_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer, &__mc_vdec_sw_h264_caps}; -int(*venc_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer, &__mc_venc_caps}; +int(*vdec_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer}; +int(*venc_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer}; int(*vdec_h264_sw_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* S/W H.264 Decoder Vtable */ - &__mc_fill_vdec_packet_with_output_buffer, - &__mc_vdec_sw_h264_caps}; + &__mc_fill_vdec_packet_with_output_buffer}; int(*vdec_mpeg4_sw_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* S/W MPEG4 Decoder Vtable */ - &__mc_fill_vdec_packet_with_output_buffer, - &__mc_vdec_mpeg4_caps}; + &__mc_fill_vdec_packet_with_output_buffer}; int(*vdec_h263_sw_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* S/W MPEG4 Decoder Vtable */ - &__mc_fill_vdec_packet_with_output_buffer, - &__mc_vdec_sw_h263_caps}; + &__mc_fill_vdec_packet_with_output_buffer}; int(*vdec_h264_hw_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* H/W H.264 Decoder Vtable */ - &__mc_fill_vdec_packet_with_output_buffer, - &__mc_vdec_hw_h264_caps}; + &__mc_fill_vdec_packet_with_output_buffer}; int(*vdec_mpeg4_hw_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* H/W MPEG4 Decoder Vtable */ - &__mc_fill_vdec_packet_with_output_buffer, - &__mc_vdec_mpeg4_caps}; + &__mc_fill_vdec_packet_with_output_buffer}; int(*vdec_h263_hw_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* H/W MPEG4 Decoder Vtable */ - &__mc_fill_vdec_packet_with_output_buffer, - &__mc_vdec_hw_h263_caps}; + &__mc_fill_vdec_packet_with_output_buffer}; int(*venc_mpeg4_sw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet, /* S/W MPEG4 Encoder Vtable */ - &__mc_fill_venc_packet_with_output_buffer, - &__mc_venc_caps}; + &__mc_fill_venc_packet_with_output_buffer}; int(*venc_h263_sw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet, /* S/W MPEG4 Encoder Vtable */ - &__mc_fill_venc_packet_with_output_buffer, - &__mc_venc_caps}; + &__mc_fill_venc_packet_with_output_buffer}; int(*venc_h264_hw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet, /* H/W H.264 Encoder Vtable */ - &__mc_fill_venc_packet_with_output_buffer, - &__mc_venc_caps}; + &__mc_fill_venc_packet_with_output_buffer}; int(*venc_mpeg4_hw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet, /* H/W MPEG4 Encoder Vtable */ - &__mc_fill_venc_packet_with_output_buffer, - &__mc_venc_caps}; + &__mc_fill_venc_packet_with_output_buffer}; int(*venc_h263_hw_vtable[])() = {&__mc_fill_input_buffer_with_venc_packet, /* H/W MPEG4 Encoder Vtable */ - &__mc_fill_venc_packet_with_output_buffer, - &__mc_venc_caps}; + &__mc_fill_venc_packet_with_output_buffer}; -int(*aenc_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer, &__mc_aenc_caps}; -int(*adec_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer, &__mc_adec_caps}; +int(*aenc_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer}; +int(*adec_vtable[])() = {&__mc_fill_input_buffer_with_packet, &__mc_fill_packet_with_output_buffer}; int(*aenc_aac_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* AAC LC Encoder vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_aenc_aac_caps}; + &__mc_fill_packet_with_output_buffer}; int(*adec_aac_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* AAC LC Decoder Vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_adec_aac_caps}; + &__mc_fill_packet_with_output_buffer}; int(*adec_aacv12_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* AAC HE Decoder Vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_adec_aacv12_caps}; + &__mc_fill_packet_with_output_buffer}; int(*adec_mp3_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* MP3 Decoder Vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_adec_mp3_caps}; + &__mc_fill_packet_with_output_buffer}; int(*adec_amrnb_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* AMR-NB Decoder Vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_adec_amrnb_caps}; + &__mc_fill_packet_with_output_buffer}; int(*adec_amrwb_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* AMR-WB Decoder Vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_adec_amrwb_caps}; + &__mc_fill_packet_with_output_buffer}; int(*aenc_amrnb_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* AMR-NB Encoder Vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_aenc_amrnb_caps}; + &__mc_fill_packet_with_output_buffer}; int(*adec_vorbis_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* VORBIS Decoder Vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_adec_vorbis_caps}; + &__mc_fill_packet_with_output_buffer}; int(*adec_flac_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* FLAC Decoder Vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_adec_flac_caps}; + &__mc_fill_packet_with_output_buffer}; int(*adec_wma_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* WMA Decoder Vtable */ - &__mc_fill_packet_with_output_buffer, - &__mc_adec_wma_caps}; + &__mc_fill_packet_with_output_buffer}; /* @@ -593,480 +572,6 @@ int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, in return ret; } -/* - * create_caps virtual functions - */ - -int __mc_create_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config) -{ - return core->vtable[create_caps](core, caps, buff, codec_config); -} - -int __mc_venc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple("video/x-raw", - "format", G_TYPE_STRING, core->format, - "width", G_TYPE_INT, enc_info->width, - "height", G_TYPE_INT, enc_info->height, - "framerate", GST_TYPE_FRACTION, enc_info->fps, 1, - NULL); - - if (core->is_hw) - g_object_set(GST_OBJECT(core->codec), "target-bitrate", enc_info->bitrate, NULL); - else - g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL); - - LOGD("%d, %d, %d", enc_info->width, enc_info->height, enc_info->fps); - - return MC_ERROR_NONE; -} - -int __mc_vdec_sw_h263_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - LOGD("%d, %d, ", dec_info->width, dec_info->height); - - *caps = gst_caps_new_simple(core->mime, - "width", G_TYPE_INT, dec_info->width, - "height", G_TYPE_INT, dec_info->height, - "variant", G_TYPE_STRING, "itu", - NULL); - - LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height); - - return MC_ERROR_NONE; -} - -int __mc_vdec_hw_h263_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - LOGD("%d, %d, ", dec_info->width, dec_info->height); - - *caps = gst_caps_new_simple(core->mime, - "mpegversion", G_TYPE_INT, 4, - "width", G_TYPE_INT, dec_info->width, - "height", G_TYPE_INT, dec_info->height, - "framerate", GST_TYPE_FRACTION, 30, 1, - NULL); - - LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height); - - return MC_ERROR_NONE; -} - -int __mc_vdec_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "mpegversion", G_TYPE_INT, 4, - "systemstream", G_TYPE_BOOLEAN, false, - "parsed", G_TYPE_BOOLEAN, TRUE, - "width", G_TYPE_INT, dec_info->width, - "height", G_TYPE_INT, dec_info->height, - "framerate", GST_TYPE_FRACTION, 30, 1, - NULL); - - LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height); - return MC_ERROR_NONE; -} - -int __mc_vdec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "alignment", G_TYPE_STRING, "au", - "stream-format", G_TYPE_STRING, "byte-stream", NULL); - - LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height); - return MC_ERROR_NONE; -} - -int __mc_vdec_sw_h264_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "alignment", G_TYPE_STRING, "au", - "stream-format", G_TYPE_STRING, "byte-stream", NULL); - - LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height); - return MC_ERROR_NONE; -} - -int __mc_vdec_hw_h264_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff,gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "parsed", G_TYPE_BOOLEAN, TRUE, - "alignment", G_TYPE_STRING, "au", - "stream-format", G_TYPE_STRING, "byte-stream", - "width", G_TYPE_INT, dec_info->width, - "framerate", GST_TYPE_FRACTION, 30, 1, - "height", G_TYPE_INT, dec_info->height, NULL); - - LOGD("mime : %s, widht :%d, height : %d", core->mime, dec_info->width, dec_info->height); - return MC_ERROR_NONE; -} - -int __mc_aenc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "rate", G_TYPE_INT, enc_info->samplerate, - "channels", G_TYPE_INT, enc_info->channel, - "format", G_TYPE_STRING, "F32LE", - "layout", G_TYPE_STRING, "interleaved", NULL); - - g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL); - /* - +----GstAudioEncoder - +----avenc_aac - - Element Properties: -compliance : Adherence of the encoder to the specifications -flags: readable, writable -Enum "GstFFMpegCompliance" Default: 0, "normal" -(2): verystrict - Strictly conform to older spec -(1): strict - Strictly conform to current spec -(0): normal - Normal behavior -(-1): unofficial - Allow unofficial extensions -(-2): experimental - Allow nonstandardized experimental things -*/ - g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL); - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, enc_info->samplerate, enc_info->channel); - - return MC_ERROR_NONE; -} - -int __mc_aenc_aac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "rate", G_TYPE_INT, enc_info->samplerate, - "channels", G_TYPE_INT, enc_info->channel, - "format", G_TYPE_STRING, "F32LE", - "layout", G_TYPE_STRING, "interleaved", NULL); - - g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL); - g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL); - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, enc_info->samplerate, enc_info->channel); - - return MC_ERROR_NONE; -} - -int __mc_aenc_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "rate", G_TYPE_INT, enc_info->samplerate, - "channels", G_TYPE_INT, enc_info->channel, - "format", G_TYPE_STRING, "S16LE", - "layout", G_TYPE_STRING, "interleaved", - NULL); - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, enc_info->samplerate, enc_info->channel); - - return MC_ERROR_NONE; -} - -int __mc_adec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - int ret = MC_ERROR_NONE; - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)"); - *caps = gst_caps_new_simple(core->mime, - "framed", G_TYPE_BOOLEAN, TRUE, - "mpegversion", G_TYPE_INT, 4, - "stream-format", G_TYPE_STRING, "adts", - "rate", G_TYPE_INT, dec_info->samplerate, - "channels", G_TYPE_INT, dec_info->channel, - NULL); - - if (codec_config && (!core->encoder)) { - guint codecdata_size = 16; /*AAC_CODECDATA_SIZE = 16 (in testsuit)*/ - ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size); - if (ret != MC_ERROR_NONE) { - LOGW("__mc_set_caps_codecdata failed"); - return ret; - } - } - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel); - - return ret; -} - -int __mc_adec_aac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, gboolean codec_config) -{ - int ret = MC_ERROR_NONE; - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)"); - *caps = gst_caps_new_simple(core->mime, - "framed", G_TYPE_BOOLEAN, TRUE, - "mpegversion", G_TYPE_INT, 4, - "stream-format", G_TYPE_STRING, "adts", - "rate", G_TYPE_INT, dec_info->samplerate, - "channels", G_TYPE_INT, dec_info->channel, - NULL); - - if (codec_config && (!core->encoder)) { - guint codecdata_size = 16; /*AAC_CODECDATA_SIZE = 16 (in testsuit)*/ - ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size); - if (ret != MC_ERROR_NONE) { - LOGW("__mc_set_caps_codecdata failed"); - return ret; - } - } - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel); - - return ret; -} - -int __mc_adec_aacv12_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, gboolean codec_config) -{ - int ret = MC_ERROR_NONE; - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - LOGD("CAPS for codec_id (MEDIACODEC_AAC_HE and _PS - MP4/M4A case)"); - *caps = gst_caps_new_simple(core->mime, - "mpegversion", G_TYPE_INT, 4, /*TODO : need adding version /profile*/ - "framed", G_TYPE_BOOLEAN, TRUE, - "stream-format", G_TYPE_STRING, "raw", - "channels", G_TYPE_INT, dec_info->channel, - "rate", G_TYPE_INT, dec_info->samplerate, - NULL); - - if (codec_config && (!core->encoder)) { - guint codecdata_size = 16; /*AAC_CODECDATA_SIZE = 16 (in testsuit)*/ - ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size); - if (ret != MC_ERROR_NONE) { - LOGW("__mc_set_caps_codecdata failed"); - return ret; - } - } - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel); - - return ret; -} - -int __mc_adec_mp3_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "framed", G_TYPE_BOOLEAN, TRUE, - "mpegversion", G_TYPE_INT, 1, /* To-Do : plz check */ - "mpegaudioversion", G_TYPE_INT, 1, /* To-Do : plz check */ - "layer", G_TYPE_INT, 3, /* To-Do : plz check */ - "rate", G_TYPE_INT, dec_info->samplerate, - "channels", G_TYPE_INT, dec_info->channel, - NULL); - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel); - - return MC_ERROR_NONE; -} - -int __mc_adec_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "rate", G_TYPE_INT, 8000, - "channels", G_TYPE_INT, dec_info->channel, /* FIXME - by 1 */ - NULL); - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel); - - return MC_ERROR_NONE; -} - -int __mc_adec_amrwb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - *caps = gst_caps_new_simple(core->mime, - "rate", G_TYPE_INT, 16000, - "channels", G_TYPE_INT, dec_info->channel, /* FIXME - by 1 */ - NULL); - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel); - - return MC_ERROR_NONE; -} - -int __mc_adec_vorbis_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - int ret = MC_ERROR_NONE; - - *caps = gst_caps_new_simple(core->mime, - "channels", G_TYPE_INT, dec_info->channel, - "rate", G_TYPE_INT, dec_info->samplerate, - /* FIXME - Insert 'Stream Header' */ - NULL); - - LOGD(" ----- VORBIS Need Additional Caps -----------"); - /* - * Need to extract from each Stream header ... or - * Need to get Demuxer's Caps from each Stream heade - */ - if (codec_config && (!core->encoder)) { - guint streamheader_size = 4096; /* VORBIS_CODECDATA_SIZE = 4096 */ - ret = __mc_set_caps_streamheader(core, caps, buff, streamheader_size); - if (ret != MC_ERROR_NONE) { - LOGW("__mc_set_caps_streamheader failed"); - return ret; - } - } - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel); - - return ret; -} - -int __mc_adec_flac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, gboolean codec_config) -{ - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - int ret = MC_ERROR_NONE; - - *caps = gst_caps_new_simple(core->mime, - "channels", G_TYPE_INT, dec_info->channel, - "rate", G_TYPE_INT, dec_info->samplerate, - "framed", G_TYPE_BOOLEAN, TRUE, - /* FIXME - Insert More Info */ - NULL); - - LOGD(" ----- FLAC Need Additional Caps -----------"); - /* - * Need to extract from each Stream header ... or - * Need to get Demuxer's Caps from each Stream heade - */ - if (codec_config && (!core->encoder)) { - guint streamheader_size = 4096; /* FLAC_CODECDATA_SIZE = 4096 */ - ret = __mc_set_caps_streamheader(core, caps, buff, streamheader_size); - if (ret != MC_ERROR_NONE) { - LOGW("__mc_set_caps_streamheader failed"); - return ret; - } - } - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel); - - return ret; -} - -int __mc_adec_wma_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, gboolean codec_config) -{ - int ret = MC_ERROR_NONE; - g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - - mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - - /* - * Need to extract from Stream Type Specific ... or - * Need to get Demuxer's Caps from Stream Type Specific - */ - guint16 format_tag = 0; - gint wma_version = 0; - gint block_align = 1024; /*FIXME : Need checking */ - gint bitrate = 128000; /*FIXME : Need checking */ - - LOGD(" ----- WMA Need Additional Caps -----------"); - if (core->codec_id == MEDIACODEC_WMAV1) { - format_tag = 352; /* 0x160 */ - wma_version = 1; - } else if (core->codec_id == MEDIACODEC_WMAV2) { - format_tag = 353; /* 0x161 */ - wma_version = 2; - } else if (core->codec_id == MEDIACODEC_WMAPRO) { - format_tag = 354; /* 0x162 */ - wma_version = 3; - } else if (core->codec_id == MEDIACODEC_WMALSL) { - format_tag = 355; /* 0x163 */ - wma_version = 3; - } else { - LOGE("Not support WMA format"); - } - - *caps = gst_caps_new_simple(core->mime, - "rate", G_TYPE_INT, dec_info->samplerate, - "channels", G_TYPE_INT, dec_info->channel, - "bitrate", G_TYPE_INT, bitrate, - "depth", G_TYPE_INT, dec_info->bit, - /* FIXME - Need More Info */ - "wmaversion", G_TYPE_INT, wma_version, - "format_tag", G_TYPE_INT, format_tag, - "block_align", G_TYPE_INT, block_align, - NULL); - - if (codec_config && (!core->encoder)) { - guint codecdata_size = 64; /* WMA_CODECDATA_SIZE = 64 */ - ret = __mc_set_caps_codecdata(core, caps, buff, codecdata_size); - if (ret != MC_ERROR_NONE) { - LOGW("__mc_set_caps_codecdata failed"); - return ret; - } - } - - LOGD("mime : %s, samplerate :%d, channel : %d", core->mime, dec_info->samplerate, dec_info->channel); - - return ret; -} static GstCaps *__mc_gst_caps_set_buffer_array(GstCaps * caps, const gchar * name, GstBuffer * buf, ...) { @@ -1102,7 +607,7 @@ static GstCaps *__mc_gst_caps_set_buffer_array(GstCaps * caps, const gchar * nam return caps; } -int __mc_set_caps_streamheader(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer*buff, guint streamheader_size) +int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint streamheader_size) { int ret = MEDIA_PACKET_ERROR_NONE; void *buf_data = NULL; @@ -1191,7 +696,7 @@ int __mc_set_caps_streamheader(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* LOGD("[vorbis] streamheader hsize1 (%d) + hsize2 (%d) + hsize3 (%d) = Total (%d)", hsize1, hsize2, hsize3, (hsize1 + hsize2 + hsize3)); - __mc_gst_caps_set_buffer_array(*caps, "streamheader", header1, header2, header3, NULL); + __mc_gst_caps_set_buffer_array(core->caps, "streamheader", header1, header2, header3, NULL); gst_buffer_unref(header1); gst_buffer_unref(header2); @@ -1243,7 +748,7 @@ int __mc_set_caps_streamheader(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* gst_buffer_unmap(header2, &map); LOGD("[flac] streamheader hsize1 (%d) + hsize2 (%d) = Total (%d)", hsize1, hsize2, (hsize1 + hsize2)); - __mc_gst_caps_set_buffer_array(*caps, "streamheader", header1, header2, NULL); + __mc_gst_caps_set_buffer_array(core->caps, "streamheader", header1, header2, NULL); gst_buffer_unref(header1); gst_buffer_unref(header2); } else { @@ -1259,7 +764,7 @@ int __mc_set_caps_streamheader(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* return ret; } -int __mc_set_caps_codecdata(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, guint codecdata_size) +int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint codecdata_size) { int ret = MEDIA_PACKET_ERROR_NONE; void *buf_data = NULL; @@ -1286,7 +791,7 @@ int __mc_set_caps_codecdata(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *bu gst_buffer_ref(codecdata_buffer); LOGD("setting codec_data from (packet) buf_data used codecdata_size (%d)", codecdata_size); - gst_caps_set_simple(*caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL); + gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL); gst_buffer_unref(codecdata_buffer); /* Update gstbuffer's data ptr and size for using previous codec_data..*/ @@ -1478,7 +983,7 @@ gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt) media_format_get_video_info(fmt, NULL, &width, &height, &bitrate, NULL); if ((codec_info->width != width) || (codec_info->height != height)) { - LOGD("Resolution changed : %dx%d -> %dx%d",codec_info->width, codec_info->height, width, height); + LOGD("Resolution changed : %dx%d -> %dx%d", codec_info->width, codec_info->height, width, height); codec_info->width = width; codec_info->height = height; is_updated = TRUE; @@ -1488,7 +993,7 @@ gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt) mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; if (enc_info->bitrate != bitrate) { - LOGD("Bitrate changed : %d -> %d",enc_info->bitrate, bitrate); + LOGD("Bitrate changed : %d -> %d", enc_info->bitrate, bitrate); enc_info->bitrate = bitrate; is_updated = TRUE; } @@ -1513,7 +1018,7 @@ gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt) mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; if (enc_info->bitrate != bitrate) { - LOGD("Bitrate changed : %d -> %d",enc_info->bitrate, bitrate); + LOGD("Bitrate changed : %d -> %d", enc_info->bitrate, bitrate); enc_info->bitrate = bitrate; is_updated = TRUE; } @@ -1523,24 +1028,97 @@ gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt) return is_updated; } -static void _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstCaps **caps, GstMCBuffer* buff, bool codec_config) +static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer* buff, bool codec_config) { - /*TODO remove is_hw param*/ - core->format = __mc_get_gst_input_format(pkt, core->is_hw); + MEDIACODEC_FENTER(); + + g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); + + int ret = MC_ERROR_NONE; + + if (core->video) { + if (core->encoder) { + mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; - GstPad *pad = NULL; - GstCaps *template_caps; + core->format = __mc_get_gst_input_format(pkt, core->is_hw); + gst_caps_set_simple(core->caps, + "format", G_TYPE_STRING, core->format, + "width", G_TYPE_INT, enc_info->width, + "height", G_TYPE_INT, enc_info->height, + "framerate", GST_TYPE_FRACTION, enc_info->fps, 1, + NULL); - pad = gst_element_get_static_pad(core->codec, "src"); - template_caps = gst_pad_get_pad_template_caps(pad); + if (g_object_class_find_property(G_OBJECT_GET_CLASS(core->codec), "bitrate")) + g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL); + else + g_object_set(GST_OBJECT(core->codec), "target-bitrate", enc_info->bitrate, NULL); + + } else { + mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; - __mc_create_caps(core, caps, buff, codec_config); - g_object_set(core->appsrc, "caps", *caps, NULL); + gst_caps_set_simple(core->caps, + "width", G_TYPE_INT, dec_info->width, + "height", G_TYPE_INT, dec_info->height, + NULL); + } + } else { + if (core->encoder) { + mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; + + gst_caps_set_simple(core->caps, + "rate", G_TYPE_INT, enc_info->samplerate, + "channels", G_TYPE_INT, enc_info->channel, + NULL); + g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL); + } else { + mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; + + gst_caps_set_simple(core->caps, + "rate", G_TYPE_INT, dec_info->samplerate, + "channels", G_TYPE_INT, dec_info->channel, + NULL); + + if (codec_config) { + switch (core->codec_id) { + case MEDIACODEC_AAC: + case MEDIACODEC_AAC_HE: + case MEDIACODEC_AAC_HE_PS: + ret = __mc_set_caps_codecdata(core, buff, AAC_CODECDATA_SIZE); + if (ret != MC_ERROR_NONE) { + LOGW("__mc_set_caps_codecdata failed"); + return ret; + } + break; + case MEDIACODEC_WMAV1: + case MEDIACODEC_WMAV2: + case MEDIACODEC_WMAPRO: + case MEDIACODEC_WMALSL: + ret = __mc_set_caps_codecdata(core, buff, WMA_CODECDATA_SIZE); + if (ret != MC_ERROR_NONE) { + LOGW("__mc_set_caps_codecdata failed"); + return ret; + } + break; + case MEDIACODEC_VORBIS: + case MEDIACODEC_FLAC: + ret = __mc_set_caps_streamheader(core, buff, VORBIS_CODECDATA_SIZE); + if (ret != MC_ERROR_NONE) { + LOGW("__mc_set_caps_streamheader failed"); + return ret; + } + break; + default: + LOGD("doesn't need to set codecdata"); + break; - if (gst_caps_is_subset(*caps, template_caps)) - LOGD("new caps is subset of template caps"); + } + } + } + } + g_object_set(core->appsrc, "caps", core->caps, NULL); - gst_object_unref(pad); + MEDIACODEC_FLEAVE(); + return ret; } static gpointer feed_task(gpointer data) @@ -1552,7 +1130,6 @@ static gpointer feed_task(gpointer data) media_format_h fmt = NULL; media_packet_h in_buf = NULL; GstMCBuffer *buff = NULL; - GstCaps *new_caps = NULL; bool initiative = true; MEDIACODEC_FENTER(); @@ -1581,7 +1158,7 @@ static gpointer feed_task(gpointer data) goto ERROR; } - buff = _mc_gst_media_packet_to_gstbuffer(core, &new_caps, in_buf, codec_config); + buff = _mc_gst_media_packet_to_gstbuffer(core, in_buf, codec_config); if (!buff) { LOGW("gstbuffer can't make"); goto ERROR; @@ -1593,7 +1170,11 @@ static gpointer feed_task(gpointer data) if (initiative) { GstPad *pad; - _mc_gst_update_caps(core, in_buf, &new_caps, buff, codec_config); + ret = _mc_gst_update_caps(core, in_buf, buff, codec_config); + if (ret != MC_ERROR_NONE) { + LOGE("failed to update caps"); + goto ERROR; + } pad = gst_element_get_static_pad(core->appsrc, "src"); gst_pad_push_event(pad, gst_event_new_stream_start("sejun")); @@ -1635,9 +1216,6 @@ LEAVE: } - if (new_caps) - gst_caps_unref(new_caps); - LOGI("status : in_buf : %p, codec_config : %d, eos : %d, video : %d, encoder : %d in feed_task", in_buf, codec_config, eos, core->video, core->encoder); LOGD("feed task finished %p v(%d)e(%d)", core, core->video, core->encoder); @@ -1680,51 +1258,103 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo case MEDIACODEC_AAC: /* if set to 'CODEC_CONFIG', then It is also available case of MEDIA_FORMAT_AAC_LC (RAW) */ LOGD("aac lc (adts) vtable"); - core->vtable = encoder ? aenc_aac_vtable : adec_aac_vtable; + if (encoder) { + core->vtable = aenc_aac_vtable; + core->caps = gst_caps_new_simple(core->mime, + "format", G_TYPE_STRING, "F32LE", + "layout", G_TYPE_STRING, "interleaved", NULL); + g_object_set(GST_OBJECT(core->codec), "compliance", -2, NULL); + } else { + LOGD("CAPS for codec_id (MEDIACODEC_AAC_LC - normal ADTS)"); + + core->vtable = adec_aac_vtable; + core->caps = gst_caps_new_simple(core->mime, + "framed", G_TYPE_BOOLEAN, TRUE, + "mpegversion", G_TYPE_INT, 4, + "stream-format", G_TYPE_STRING, "adts", + NULL); + } break; case MEDIACODEC_AAC_HE: case MEDIACODEC_AAC_HE_PS: LOGD("aac he v12 vtable"); - core->vtable = encoder ? aenc_aac_vtable : adec_aacv12_vtable; if (encoder) { LOGD("[MC_NOT_SUPPORTED] he-aac-v12 encoder is not supported yet!!!"); return MC_NOT_SUPPORTED; + } else { + LOGD("CAPS for codec_id (MEDIACODEC_AAC_HE and _PS - MP4/M4A case)"); + core->vtable = adec_aacv12_vtable; + core->caps = gst_caps_new_simple(core->mime, + "mpegversion", G_TYPE_INT, 4, /*TODO : need adding version /profile*/ + "framed", G_TYPE_BOOLEAN, TRUE, + "stream-format", G_TYPE_STRING, "raw", + NULL); } break; case MEDIACODEC_MP3: LOGD("mp3 vtable - Only support decoder"); - core->vtable = encoder ? aenc_vtable : adec_mp3_vtable; if (encoder) { LOGD("[MC_NOT_SUPPORTED] mp3 encoder is not supported yet!!!"); return MC_NOT_SUPPORTED; + } else { + core->vtable = adec_mp3_vtable; + core->caps = gst_caps_new_simple(core->mime, + "framed", G_TYPE_BOOLEAN, TRUE, + "mpegversion", G_TYPE_INT, 1, /* To-Do : plz check */ + "mpegaudioversion", G_TYPE_INT, 1, /* To-Do : plz check */ + "layer", G_TYPE_INT, 3, /* To-Do : plz check */ + NULL); } break; case MEDIACODEC_AMR_NB: LOGD("amrnb vtable"); - core->vtable = encoder ? aenc_amrnb_vtable : adec_amrnb_vtable; + if (encoder) { + core->vtable = aenc_amrnb_vtable; + core->caps = gst_caps_new_simple(core->mime, + "format", G_TYPE_STRING, "S16LE", + "layout", G_TYPE_STRING, "interleaved", + NULL); + + } else { + core->vtable = adec_amrnb_vtable; + core->caps = gst_caps_new_simple(core->mime, + "rate", G_TYPE_INT, 8000, + NULL); + } break; case MEDIACODEC_AMR_WB: LOGD("amrwb vtable - Only support decoder"); - core->vtable = encoder ? aenc_vtable : adec_amrwb_vtable; if (encoder) { LOGD("[MC_NOT_SUPPORTED] amr-wb encoder is not supported yet!!!"); return MC_NOT_SUPPORTED; + } else { + core->vtable = adec_amrwb_vtable; + core->caps = gst_caps_new_simple(core->mime, + "rate", G_TYPE_INT, 16000, + NULL); } break; case MEDIACODEC_VORBIS: LOGD("vorbis vtable"); - core->vtable = encoder ? aenc_vtable : adec_vorbis_vtable; if (encoder) { LOGD("[MC_NOT_SUPPORTED] vorbis encoder is not supported yet!!!"); return MC_NOT_SUPPORTED; + } else { + core->vtable = adec_vorbis_vtable; + core->caps = gst_caps_new_empty_simple("audio/x-vorbis"); } break; case MEDIACODEC_FLAC: LOGD("flac vtable"); - core->vtable = encoder ? aenc_vtable : adec_flac_vtable; if (encoder) { LOGD("[MC_NOT_SUPPORTED] flac encoder is not supported yet!!!"); return MC_NOT_SUPPORTED; + } else { + core->vtable = adec_flac_vtable; + core->caps = gst_caps_new_simple(core->mime, + "framed", G_TYPE_BOOLEAN, TRUE, + /* FIXME - Insert More Info */ + NULL); } break; case MEDIACODEC_WMAV1: @@ -1732,28 +1362,112 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo case MEDIACODEC_WMAPRO: case MEDIACODEC_WMALSL: LOGD("wma(V1 / V2 / LSL / PRO) vtable"); - core->vtable = encoder ? aenc_vtable : adec_wma_vtable; if (encoder) { LOGD("[MC_NOT_SUPPORTED] wma encoder is not supported yet!!!"); return MC_NOT_SUPPORTED; + } else { + mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; + + core->vtable = adec_wma_vtable; + + /* + * Need to extract from Stream Type Specific ... or + * Need to get Demuxer's Caps from Stream Type Specific + */ + guint16 format_tag = 0; + gint wma_version = 0; + gint block_align = 1024; /*FIXME : Need checking */ + gint bitrate = 128000; /*FIXME : Need checking */ + + LOGD(" ----- WMA Need Additional Caps -----------"); + if (core->codec_id == MEDIACODEC_WMAV1) { + format_tag = 352; /* 0x160 */ + wma_version = 1; + } else if (core->codec_id == MEDIACODEC_WMAV2) { + format_tag = 353; /* 0x161 */ + wma_version = 2; + } else if (core->codec_id == MEDIACODEC_WMAPRO) { + format_tag = 354; /* 0x162 */ + wma_version = 3; + } else if (core->codec_id == MEDIACODEC_WMALSL) { + format_tag = 355; /* 0x163 */ + wma_version = 3; + } else { + LOGE("Not support WMA format"); + } + + core->caps = gst_caps_new_simple(core->mime, + "bitrate", G_TYPE_INT, bitrate, + "depth", G_TYPE_INT, dec_info->bit, + /* FIXME - Need More Info */ + "wmaversion", G_TYPE_INT, wma_version, + "format_tag", G_TYPE_INT, format_tag, + "block_align", G_TYPE_INT, block_align, + NULL); } break; case MEDIACODEC_H263: LOGD("h263 vtable"); - core->vtable = encoder ? (is_hw ? venc_h263_hw_vtable : venc_h263_sw_vtable) : is_hw ? vdec_h263_hw_vtable : vdec_h263_sw_vtable; + if (encoder) { + core->vtable = is_hw ? venc_h263_hw_vtable : venc_h263_sw_vtable; + core->caps = gst_caps_new_empty_simple("video/x-raw"); + } else { + if (is_hw) { + core->vtable = vdec_h263_hw_vtable; + core->caps = gst_caps_new_simple(core->mime, + "mpegversion", G_TYPE_INT, 4, + "framerate", GST_TYPE_FRACTION, 30, 1, + NULL); + } else { + core->vtable = vdec_h263_sw_vtable; + core->caps = gst_caps_new_simple(core->mime, + "variant", G_TYPE_STRING, "itu", + NULL); + } + } break; case MEDIACODEC_MPEG4: LOGD("mpeg4 vtable"); - core->vtable = encoder ? (is_hw ? venc_mpeg4_hw_vtable : venc_mpeg4_sw_vtable) : is_hw ? vdec_mpeg4_hw_vtable : vdec_mpeg4_sw_vtable; - + if (encoder) { + core->vtable = is_hw ? venc_mpeg4_hw_vtable : venc_mpeg4_sw_vtable; + core->caps = gst_caps_new_empty_simple("video/x-raw"); + } else { + core->vtable = is_hw ? vdec_mpeg4_hw_vtable : vdec_mpeg4_sw_vtable; + core->caps = gst_caps_new_simple(core->mime, + "mpegversion", G_TYPE_INT, 4, + "systemstream", G_TYPE_BOOLEAN, false, + "parsed", G_TYPE_BOOLEAN, TRUE, + "framerate", GST_TYPE_FRACTION, 30, 1, + NULL); + } break; case MEDIACODEC_H264: LOGD("h264 vtable"); - core->vtable = encoder ? (is_hw ? venc_h264_hw_vtable : venc_vtable) : is_hw ? vdec_h264_hw_vtable : vdec_h264_sw_vtable; + if (encoder) { + core->vtable = is_hw ? venc_h264_hw_vtable : venc_vtable; + core->caps = gst_caps_new_empty_simple("video/x-raw"); + } else { + if (is_hw) { + core->vtable = vdec_h264_hw_vtable; + core->caps = gst_caps_new_simple(core->mime, + "parsed", G_TYPE_BOOLEAN, TRUE, + "alignment", G_TYPE_STRING, "au", + "stream-format", G_TYPE_STRING, "byte-stream", + "framerate", GST_TYPE_FRACTION, 30, 1, + NULL); + } else { + core->vtable = vdec_h264_sw_vtable; + core->caps = gst_caps_new_simple(core->mime, + "alignment", G_TYPE_STRING, "au", + "stream-format", G_TYPE_STRING, "byte-stream", NULL); + } + } break; default: break; } + /* set caps */ + g_object_set(core->appsrc, "caps", core->caps, NULL); return MC_ERROR_NONE; } @@ -1842,12 +1556,6 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle) return ret; } - /* link vtable */ - if ((ret = _mc_link_vtable(new_core, id, encoder, hardware)) != MC_ERROR_NONE) { - LOGE("vtable link failed"); - return ret; - } - for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER ; i++) { LOGD("copy cb function [%d]", i); if (mc_handle->user_cb[i]) { @@ -1860,7 +1568,16 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle) mc_handle->core = new_core; /* create basic core elements */ - ret = _mc_gst_create_pipeline(mc_handle->core, factory_name); + if ((ret = _mc_gst_create_pipeline(mc_handle->core, factory_name) != MC_ERROR_NONE)) { + LOGE("failed to create pipeline"); + return ret; + } + + /* link vtable */ + if ((ret = _mc_link_vtable(mc_handle->core, id, encoder, hardware)) != MC_ERROR_NONE) { + LOGE("vtable link failed"); + return ret; + } LOGD("initialized... %d", ret); return ret; @@ -2195,6 +1912,7 @@ mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name) /* set state PLAYING */ MEDIACODEC_ELEMENT_SET_STATE(GST_ELEMENT_CAST(core->pipeline), GST_STATE_PLAYING); + } core->prepare_count++; g_mutex_unlock(&core->prepare_lock); @@ -2255,6 +1973,10 @@ mc_ret_e _mc_gst_destroy_pipeline(mc_gst_core_t *core) MEDIACODEC_ELEMENT_SET_STATE(core->pipeline, GST_STATE_NULL); gst_object_unref(GST_OBJECT(core->pipeline)); + if (core->caps) { + gst_caps_unref(core->caps); + core->caps = NULL; + } } } @@ -2408,7 +2130,7 @@ gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw) return format; } -GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t* core, GstCaps **caps, media_packet_h pkt, bool codec_config) +GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t* core, media_packet_h pkt, bool codec_config) { int ret = MEDIA_PACKET_ERROR_NONE; GstMCBuffer *mc_buffer = NULL; diff --git a/test/media_codec_test.c b/test/media_codec_test.c index 15f10bb..698a24d 100755 --- a/test/media_codec_test.c +++ b/test/media_codec_test.c @@ -129,8 +129,8 @@ struct _App { int codecid; int flag; - bool is_video[MAX_HANDLE]; - bool is_encoder[MAX_HANDLE]; + bool is_video; + bool is_encoder; bool hardware; bool enable_dump; int frame; @@ -821,6 +821,7 @@ int _mediacodec_set_codec(App *app, int codecid, int flag, bool *hardware) media_format_mimetype_e mime = 0; encoder = GET_IS_ENCODER(flag) ? 1 : 0; *hardware = GET_IS_HW(flag) ? 1 : 0; + app->is_encoder = encoder; switch (codecid) { case MEDIACODEC_H264: @@ -1027,7 +1028,6 @@ static gboolean read_data(App *app) #ifdef USE_POOL if (media_packet_pool_acquire_packet(pkt_pool, &pkt, -1) != MEDIA_PACKET_ERROR_NONE) { fprintf(stderr, "media_packet_pool_aquire_packet failed\n"); - //return TRUE; return FALSE; } #else @@ -1253,8 +1253,7 @@ static void _mediacodec_prepare(App *app, bool frame_all) /* get packet pool instance */ - ret = mediacodec_get_packet_pool(app->mc_handle[0], &pkt_pool); - + ret = mediacodec_get_packet_pool(app->mc_handle[0], &pkt_pool); if (ret != MEDIA_PACKET_ERROR_NONE) { g_print("mediacodec_get_packet_pool failed\n"); return; @@ -1357,7 +1356,7 @@ void _interpret_main_menu(char *cmd, App *app) else if (strncmp(cmd, "dt", 2) == 0) _mediacodec_destroy(app); else if (strncmp(cmd, "dp", 2) == 0) { - if(!app->enable_dump) { + if (!app->enable_dump) { app->enable_dump = TRUE; g_print("dump enabled\n"); } else { @@ -1648,7 +1647,6 @@ int main(int argc, char *argv[]) displaymenu(); app->loop = g_main_loop_new(NULL, TRUE); app->timer = g_timer_new(); - //app->frame_count = 0; g_main_loop_run(app->loop); @@ -1749,35 +1747,36 @@ static void decoder_output_dump(App *app, media_packet_h pkt) * This is needed as MediaCodec encoder generates a packet of raw AAC data. * Note the packetLen must count in the ADTS header itself. **/ -void add_adts_header_for_aacenc(App *app, char *buffer, int packetLen) { - int profile = 2; //AAC LC (0x01) - int freqIdx = 3; //48KHz (0x03) - int chanCfg = 2; //CPE (0x02) - - if (app->samplerate == 96000) freqIdx = 0; - else if (app->samplerate == 88200) freqIdx = 1; - else if (app->samplerate == 64000) freqIdx = 2; - else if (app->samplerate == 48000) freqIdx = 3; - else if (app->samplerate == 44100) freqIdx = 4; - else if (app->samplerate == 32000) freqIdx = 5; - else if (app->samplerate == 24000) freqIdx = 6; - else if (app->samplerate == 22050) freqIdx = 7; - else if (app->samplerate == 16000) freqIdx = 8; - else if (app->samplerate == 12000) freqIdx = 9; - else if (app->samplerate == 11025) freqIdx = 10; - else if (app->samplerate == 8000) freqIdx = 11; - - if ((app->channel == 1) || (app->channel == 2)) - chanCfg = app->channel; - - // fill in ADTS data - buffer[0] = (char)0xFF; - buffer[1] = (char)0xF1; - buffer[2] = (char)(((profile-1)<<6) + (freqIdx<<2) +(chanCfg>>2)); - buffer[3] = (char)(((chanCfg&3)<<6) + (packetLen>>11)); - buffer[4] = (char)((packetLen&0x7FF) >> 3); - buffer[5] = (char)(((packetLen&7)<<5) + 0x1F); - buffer[6] = (char)0xFC; +void add_adts_header_for_aacenc(App *app, char *buffer, int packetLen) +{ + int profile = 2; /* AAC LC (0x01) */ + int freqIdx = 3; /* 48KHz (0x03) */ + int chanCfg = 2; /* CPE (0x02) */ + + if (app->samplerate == 96000) freqIdx = 0; + else if (app->samplerate == 88200) freqIdx = 1; + else if (app->samplerate == 64000) freqIdx = 2; + else if (app->samplerate == 48000) freqIdx = 3; + else if (app->samplerate == 44100) freqIdx = 4; + else if (app->samplerate == 32000) freqIdx = 5; + else if (app->samplerate == 24000) freqIdx = 6; + else if (app->samplerate == 22050) freqIdx = 7; + else if (app->samplerate == 16000) freqIdx = 8; + else if (app->samplerate == 12000) freqIdx = 9; + else if (app->samplerate == 11025) freqIdx = 10; + else if (app->samplerate == 8000) freqIdx = 11; + + if ((app->channel == 1) || (app->channel == 2)) + chanCfg = app->channel; + + /* fill in ADTS data */ + buffer[0] = (char)0xFF; + buffer[1] = (char)0xF1; + buffer[2] = (char)(((profile-1)<<6) + (freqIdx<<2) +(chanCfg>>2)); + buffer[3] = (char)(((chanCfg&3)<<6) + (packetLen>>11)); + buffer[4] = (char)((packetLen&0x7FF) >> 3); + buffer[5] = (char)(((packetLen&7)<<5) + 0x1F); + buffer[6] = (char)0xFC; } static void output_dump(App *app, media_packet_h pkt) @@ -1796,13 +1795,13 @@ static void output_dump(App *app, media_packet_h pkt) media_packet_get_buffer_size(pkt, &buf_size); g_print("output data : %p, size %d\n", temp, (int)buf_size); - if (buf_size > 0 && app->codecid == MEDIACODEC_AAC_LC) { + if (app->is_encoder && buf_size > 0 && app->codecid == MEDIACODEC_AAC_LC) { add_adts_header_for_aacenc(app, adts, (buf_size + ADTS_HEADER_SIZE)); fwrite(&adts, 1, ADTS_HEADER_SIZE, fp); g_print("adts appended\n"); - } else if (buf_size > 0 && app->codecid == MEDIACODEC_AMR_NB && write_amr_header == 1) { + } else if (app->is_encoder && buf_size > 0 && app->codecid == MEDIACODEC_AMR_NB && write_amr_header == 1) { /* This is used only AMR encoder case for adding AMR masic header in only first frame */ - g_print("%s - AMR_header write in first frame\n",__func__); + g_print("%s - AMR_header write in first frame\n", __func__); fwrite(&AMR_header[0], 1, sizeof(AMR_header) - 1, fp); /* AMR-NB magic number */ write_amr_header = 0; }