<domain name="_" />
</request>
<assign>
- <filesystem path="/usr/bin/player_test" label="_" exec_label="none" />
+ <filesystem path="/usr/bin/media_codec_test" label="_" exec_label="none" />
</assign>
</manifest>
* @brief Enumeration of media codec support type
* @since_tizen 2.3
* @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_HW.
+ * #MEDIACODEC_DECODER. If user doesn't set optional flag, default flags will be set to #MEDIACODEC_SUPPORT_TYPE_SW.
*/
typedef enum
{
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 2.4)*/
- MEDIACODEC_ERROR_RESOURCE_OVERLOADED = TIZEN_ERROR_MEDIACODEC | 0x0e, /**< Exceed the instance limt (Since 2.4)*/
+ MEDIACODEC_ERROR_RESOURCE_OVERLOADED = TIZEN_ERROR_MEDIACODEC | 0x0e, /**< Exceed the instance limits (Since 2.4)*/
} mediacodec_error_e;
/**
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,
+
+ 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,
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, unsigned char *nal );
-int _mc_check_bytestream ( media_packet_h pkt, unsigned char *nal, int byte_length, 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);
+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
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* 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.
+*/
+
+#ifndef __TIZEN_MEDIA_CODEC_INI_H__
+#define __TIZEN_MEDIA_CODEC_INI_H__
+
+#include <glib.h>
+#include <mm_types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MEDIA_CODEC_INI_DEFAULT_PATH "/usr/etc/mmfw_media_codec.ini"
+#define MEDIA_CODEC_INI_MAX_STRLEN 256
+#define DEFAULT_PORT "GST_PORT"
+#define MEDIA_CODEC_MAX_CODEC_TYPE 100
+#define MEDIA_CODEC_MAX_CODEC_ROLE 4
+
+#define MEDICODEC_INI_MAX_ELEMENT 10
+#define MEDIA_CODEC_MAX_VIDEO_CODEC 100
+#define MEDIA_CODEC_MAX_AUDIO_CODEC 100
+
+
+typedef enum {
+ GST_PORT = 0,
+ FFMPEG_PORT,
+ CUSTOM_PORT,
+} port_mode;
+
+typedef struct {
+ gchar name[MEDIA_CODEC_INI_MAX_STRLEN];
+ gchar mime[MEDIA_CODEC_INI_MAX_STRLEN];
+ gchar format[MEDIA_CODEC_INI_MAX_STRLEN];
+} codec_info_t;
+
+typedef struct {
+ gint codec_id;
+ codec_info_t codec_info[MEDIA_CODEC_MAX_CODEC_ROLE];
+} codec_t;
+
+
+/* @ mark means the item has tested */
+typedef struct __mc_ini {
+ port_mode port_type;
+ /* general */
+ gchar port_name[MEDIA_CODEC_INI_MAX_STRLEN];
+ codec_t codec[MEDIA_CODEC_MAX_CODEC_TYPE];
+} mc_ini_t;
+
+/*Default sink ini values*/
+/* General*/
+
+/* NOTE : following content should be same with above default values */
+/* FIXIT : need smarter way to generate default ini file. */
+/* FIXIT : finally, it should be an external file */
+#define MEDIA_CODEC_DEFAULT_INI \
+ "\
+[general] \n\
+\n\
+;Add general config parameters here\n\
+\n\
+\n\
+\n\
+[port_in_use] \n\
+\n\
+;media_codec_port = GST_PORT \n\
+;media_codec_port = FFMPEG_PORT \n\
+;media_codec_port = CUSTOM_PORT \n\
+media_codec_port = GST_PORT \n\
+\n\
+[gst_port] \n\
+\n\
+;Add gst port specific config paramters here\n\
+\n\
+\n\
+[custom_port] \n\
+\n\
+;Add custom port specific config paramters here\n\
+\n\
+\n\
+\n\
+"
+
+int mc_ini_load(mc_ini_t *ini);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /*__TIZEN_MEDIA_CODEC_INI_H__*/
#include <media_codec_queue.h>
#include <media_codec_bitstream.h>
#include <media_codec_spec_emul.h>
+#include <media_codec_ini.h>
/*===========================================================================================
MC_OUTPUT_BUFFER_EMPTY = -16,
MC_OUTPUT_BUFFER_OVERFLOW = -17, /**< codec output buffer is overflow */
MC_MEMORY_ALLOCED = -18, /**< codec has got memory and can decode one frame */
+ MC_COURRPTED_INI = -19,
} mc_ret_e;
/*---------------------------------------------------------------------------
typedef enum _mc_codec_port_type_e
{
- CODEC_PORT_TYPE_GENERAL,
- CODEC_PORT_TYPE_OMX,
- CODEC_PORT_TYPE_GST,
- CODEC_PORT_TYPE_MAX,
+ 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
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;
};
/*===========================================================================================
int mc_set_eos_cb(MMHandleType mediacodec, mediacodec_eos_cb callback, void* user_data);
int mc_unset_eos_cb(MMHandleType mediacodec);
-int mc_set_need_data_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void* user_data);
-int mc_unset_need_data_cb(MMHandleType mediacodec);
+int mc_set_buffer_status_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void* user_data);
+int mc_unset_buffer_status_cb(MMHandleType mediacodec);
#ifdef __cplusplus
BUF_SHARE_METHOD_FLUSH_BUFFER
} buf_share_method_t;
-#ifdef Z130H
+#ifdef TIZEN_PROFILE_LITE
struct ion_mmu_data {
- int fd_buffer;
- unsigned long iova_addr;
- size_t iova_size;
+ int master_id;
+ int fd_buffer;
+ unsigned long iova_addr;
+ size_t iova_size;
};
#endif
GstElement* fakesink;
GstElement* codec;
MMVideoBuffer *psimgb;
+ tbm_bufmgr bufmgr;
+ int drm_fd;
GMainContext *thread_default;
gulong signal_handoff;
GMutex eos_mutex;
GMutex eos_wait_mutex;
- GMutex drain_mutex;
GMutex prepare_lock;
GCond eos_cond;
GCond eos_waiting_cond;
bool need_feed;
bool need_codec_data;
bool need_sync_flag;
- int prepare_count;
- int num_live_buffers;
- int idr_count;
- int sps_size;
- int pps_size;
+ unsigned int prepare_count;
+ unsigned int num_live_buffers;
+ unsigned int queued_count;
+ unsigned int dequeued_count;
mediacodec_codec_type_e codec_id;
enum { fill_inbuf, fill_outbuf, create_caps };
//int __mc_link_elements(mc_gst_core_t *core);
-int __mc_fill_input_buffer(mc_gst_core_t *core, void *buf_data, int buf_size, GstMCBuffer *buff);
+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);
+int __mc_create_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
//int __mc_venc_link(mc_gst_core_t *core);
//int __mc_general_link(mc_gst_core_t *core);
-int __mc_fill_inbuf_with_bo(mc_gst_core_t *core, void *buf_data, int buf_size, GstMCBuffer *buff);
-int __mc_fill_inbuf_with_packet(mc_gst_core_t *core, void *buf_data, int buf_size, GstMCBuffer *buff);
-
-int __mc_fill_outbuf_with_bo(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt);
-int __mc_fill_outbuf_with_packet(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt);
-int __mc_fill_outbuf_with_h264_packet(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt);
-int __mc_fill_packet_with_mm_video_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt);
-
-int __mc_venc_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_vdec_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_h264dec_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_sprddec_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_sprdenc_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_aenc_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_adec_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_adec_aacv12_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_adec_mp3_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_adec_amrnb_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_adec_amrwb_caps(mc_gst_core_t *core, GstCaps **caps);
-int __mc_aenc_amrnb_caps(mc_gst_core_t *core, GstCaps **caps);
-
+int __mc_fill_inbuf_with_mm_video_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff);
+int __mc_fill_inbuf_with_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff);
+int __mc_fill_inbuf_with_venc_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer);
+
+int __mc_fill_packet_with_outbuf(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt);
+int __mc_fill_venc_packet_with_outbuf(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt);
+int __mc_fill_video_packet_with_mm_video_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt);
+int __mc_fill_vdec_packet_with_outbuf(mc_gst_core_t *core, void *data, int size, media_packet_h *pkt);
+
+int __mc_vdec_h264_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_venc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_vdec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_vdec_h263_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_vdec_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_h264dec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_sprddec_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_sprddec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_sprdenc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_sprdenc_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_aenc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_adec_aac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_aenc_aac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_adec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_adec_aacv12_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_adec_mp3_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_adec_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_adec_amrwb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_aenc_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_adec_vorbis_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_adec_flac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+int __mc_adec_wma_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+bool _mc_is_voss (unsigned char *p, 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);
+
+
+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);
mc_ret_e mc_gst_flush_buffers(mc_handle_t *mc_handle);
-int _mc_check_out_bytestream (mc_gst_core_t *core, unsigned char *nal, int byte_length);
#ifdef __cplusplus
}
#endif
mc_codec_type_t type;
};
-static const mc_codec_spec_t spec_emul[] =
-{
- {MEDIACODEC_H264, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST},
- {MEDIACODEC_H264, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW, MEDIACODEC_PORT_TYPE_GST},
- {MEDIACODEC_H264, MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW, MEDIACODEC_PORT_TYPE_GST},
- {MEDIACODEC_H263, MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST},
- {MEDIACODEC_MPEG4, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST},
- {MEDIACODEC_MPEG4, MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST},
- {MEDIACODEC_AAC_LC, MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST},
- {MEDIACODEC_AAC_LC, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST},
- /* Extension for supporting codec @since_tizen 2.4 */
- {MEDIACODEC_AAC_HE, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST}, /* added for 2.4 extension */
- {MEDIACODEC_AAC_HE_PS, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST}, /* added for 2.4 extension */
- {MEDIACODEC_MP3, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST}, /* added for 2.4 extension */
- {MEDIACODEC_AMR_NB, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST}, /* added for 2.4 extension */
- {MEDIACODEC_AMR_WB, MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST}, /* added for 2.4 extension */
- {MEDIACODEC_AMR_NB, MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW, MEDIACODEC_PORT_TYPE_GST} /* added for 2.4 extension */
-};
-static const mc_codec_map_t encoder_map[] =
-{
-#ifdef ENABLE_FFMPEG_CODEC
- //{MEDIACODEC_H264, HARDWARE, {"omxh264enc", "video/x-raw", MEDIA_FORMAT_H264_HP}},
- {MEDIACODEC_H264, HARDWARE, {"sprdenc_h264", "video/x-raw", MEDIA_FORMAT_H264_HP}},
- {MEDIACODEC_H263, SOFTWARE, {"avenc_h263p", "video/x-raw-yuv", MEDIA_FORMAT_H263P}},
- {MEDIACODEC_MPEG4, SOFTWARE, {"avenc_mpeg4", "video/x-raw-yuv", MEDIA_FORMAT_MPEG4_SP}},
- {MEDIACODEC_AAC_LC, SOFTWARE, {"avenc_aac", "audio/x-raw", MEDIA_FORMAT_AAC_LC}},
- {MEDIACODEC_AMR_NB, SOFTWARE, {"amrnbenc", "audio/x-raw", MEDIA_FORMAT_AMR_NB}} /* for 2.4 temporary - use ffmpeg */
-#else
- {MEDIACODEC_H264, HARDWARE, {"sprdenc_h264", "video/x-raw", MEDIA_FORMAT_H264_HP}},
- {MEDIACODEC_H263, SOFTWARE, {"maru_h263penc", "video/x-raw-yuv", MEDIA_FORMAT_H263P}},
- {MEDIACODEC_MPEG4, SOFTWARE, {"maru_mpeg4", "video/x-raw-yuv", MEDIA_FORMAT_MPEG4_SP}},
- {MEDIACODEC_AAC_LC, SOFTWARE, {"avenc_aac", "audio/x-raw", MEDIA_FORMAT_AAC_LC}}, /* for 2.4 temporary - use ffmpeg instead of maru_aacenc */
- {MEDIACODEC_AMR_NB, SOFTWARE, {"amrnbenc", "audio/x-raw", MEDIA_FORMAT_AMR_NB}} /* for 2.4 temporary - use ffmpeg instead of ?? */
-#endif
-};
-
-static const mc_codec_map_t decoder_map[] =
-{
-#ifdef ENABLE_FFMPEG_CODEC
- {MEDIACODEC_H264, SOFTWARE, {"avdec_h264", "video/x-h264", MEDIA_FORMAT_I420}},
- {MEDIACODEC_H264, HARDWARE, {"sprddec_h264", "video/x-h264", MEDIA_FORMAT_NV12}},
- //{MEDIACODEC_H264, SOFTWARE, {"omxh264dec", "video/x-h264", MEDIA_FORMAT_I420}},
- {MEDIACODEC_MPEG4, SOFTWARE, {"avdec_mpeg4", "video/mpeg", MEDIA_FORMAT_I420}},
- {MEDIACODEC_AAC_LC, SOFTWARE, {"avdec_aac", "audio/mpeg", MEDIA_FORMAT_PCM}},
- {MEDIACODEC_AAC_HE, SOFTWARE, {"avdec_aac", "audio/mpeg", MEDIA_FORMAT_PCM}}, /* added for 2.4 extension */
- {MEDIACODEC_AAC_HE_PS, SOFTWARE, {"avdec_aac", "audio/mpeg", MEDIA_FORMAT_PCM}}, /* added for 2.4 extension */
- {MEDIACODEC_MP3, SOFTWARE, {"avdec_mp3", "audio/mpeg", MEDIA_FORMAT_PCM}}, /* added for 2.4 extension */
- {MEDIACODEC_AMR_NB, SOFTWARE, {"avdec_amrnb", "audio/AMR", MEDIA_FORMAT_PCM}}, /* added for 2.4 extension */
- {MEDIACODEC_AMR_WB, SOFTWARE, {"avdec_amrwb", "audio/AMR-WB", MEDIA_FORMAT_PCM}} /* added for 2.4 extension */
-#else
- {MEDIACODEC_H264, SOFTWARE, {"avdec_h264", "video/x-h264", MEDIA_FORMAT_I420}},
- {MEDIACODEC_H264, HARDWARE, {"omxh264dec", "video/x-h264", MEDIA_FORMAT_NV12}},
- {MEDIACODEC_MPEG4, SOFTWARE, {"maru_mpeg4", "video/mpeg", MEDIA_FORMAT_I420}},
- {MEDIACODEC_AAC_LC, SOFTWARE, {"avdec_aac", "audio/mpeg", MEDIA_FORMAT_PCM}}, /* for 2.4 temporary - use ffmpeg instead of maru_aacdec */
- {MEDIACODEC_AAC_HE, SOFTWARE, {"avdec_aac", "audio/mpeg", MEDIA_FORMAT_PCM}}, /* for 2.4 temporary - use ffmpeg instead of maru_aacdec */
- {MEDIACODEC_AAC_HE_PS, SOFTWARE, {"avdec_aac", "audio/mpeg", MEDIA_FORMAT_PCM}}, /* for 2.4 temporary - use ffmpeg instead of maru_aacdec */
- {MEDIACODEC_MP3, SOFTWARE, {"avdec_mp3", "audio/mpeg", MEDIA_FORMAT_PCM}},
- {MEDIACODEC_AMR_NB, SOFTWARE, {"avdec_amrnb", "audio/AMR", MEDIA_FORMAT_PCM}},
- {MEDIACODEC_AMR_WB, SOFTWARE, {"avdec_amrwb", "audio/AMR-WB", MEDIA_FORMAT_PCM}}
-#endif
-};
#ifdef __cplusplus
}
#endif
g_free( x ); \
x = NULL;
-
-
-
#ifdef __cplusplus
}
#endif
BuildRequires: pkgconfig(gstreamer-plugins-base-1.0)
BuildRequires: pkgconfig(gstreamer-app-1.0)
BuildRequires: pkgconfig(capi-system-info)
-%if "%{?tizen_target_name}"=="Z130H"
+BuildRequires: pkgconfig(iniparser)
+%if "%{tizen_target_name}" == "Z130H" || "%{?tizen_target_name}" == "Z300H"
#!BuildIgnore: kernel-headers
BuildConflicts: linux-glibc-devel
BuildRequires: kernel-headers-tizen-dev
%build
-%if "%{?tizen_target_name}"=="Z130H"
-export CFLAGS="$CFLAGS -DZ130H"
+%if "%{tizen_target_name}" == "Z130H" || "%{?tizen_target_name}" == "Z300H"
+export CFLAGS="$CFLAGS -DTIZEN_PROFILE_LITE"
%endif
%if 0%{?sec_build_binary_debug_enable}
export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE"
%endif
MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
-%cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
+%cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
make %{?jobs:-j%jobs}
rm -rf %{buildroot}
mkdir -p %{buildroot}/usr/share/license
mkdir -p %{buildroot}/usr/bin
-mkdir -p %{buildroot}/opt/usr/devel
-cp test/media_codec_test %{buildroot}/opt/usr/devel
+cp test/media_codec_test %{buildroot}/usr/bin
cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name}
%make_install
%manifest capi-media-codec.manifest
%{_libdir}/libcapi-media-codec.so.*
%{_datadir}/license/%{name}
-/opt/usr/devel/*
+/usr/bin/*
#%{_bindir}/*
%files devel
static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data);
static gboolean __mediacodec_eos_cb(void *user_data);
static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data);
-static int __mediacodec_check_system_info_feature_supported();
static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data);
/*
* Internal Implementation
*/
-int __convert_error_code(int code, char* func_name)
+int __convert_error_code(int code, char *func_name)
{
int ret = MEDIACODEC_ERROR_INVALID_OPERATION;
- char* msg = "MEDIACOODEC_INVALID_OPERATION";
- switch(code)
- {
+ char *msg = "MEDIACOODEC_INVALID_OPERATION";
+
+ switch (code) {
case MC_ERROR_NONE:
ret = MEDIACODEC_ERROR_NONE;
msg = "MEDIACODEC_ERROR_NONE";
return ret;
}
-bool __mediacodec_state_validate(mediacodec_h mediacodec, mediacodec_state_e threshold)
-{
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
-
- if(handle->state < threshold)
- return FALSE;
- return TRUE;
-}
-
-static int __mediacodec_check_system_info_feature_supported()
-{
- bool bValue = false;
- int nRetVal = false;
-
- nRetVal = system_info_get_platform_bool("http://tizen.org/feature/mediacodec", &bValue);
-
- if ( nRetVal != SYSTEM_INFO_ERROR_NONE )
- {
- LOGE("[%s] SYSTEM_INFO_ERROR : ", __FUNCTION__);
- return false;
- }
-
- if ( false == bValue )
- {
- LOGI("system_info_get_platform_bool returned Unsupported feature capability\n");
- }
- else
- {
- LOGI("system_info_get_platform_bool returned Supported status feature\n");
- }
-
- return bValue;
-}
-
/*
* Public Implementation
*/
mediacodec_s *handle;
int ret;
- LOGD ("mediacodec_create..\n");
+ LOGD("mediacodec_create..");
- handle = (mediacodec_s*)malloc( sizeof(mediacodec_s));
- if (handle != NULL)
- {
+ handle = (mediacodec_s *)malloc(sizeof(mediacodec_s));
+ if (handle != NULL) {
memset(handle, 0 , sizeof(mediacodec_s));
- }
- else
- {
+ } else {
LOGE("MEDIACODEC_ERROR_OUT_OF_MEMORY(0x%08x)", MEDIACODEC_ERROR_OUT_OF_MEMORY);
return MEDIACODEC_ERROR_OUT_OF_MEMORY;
}
ret = mc_create(&handle->mc_handle);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
LOGE("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
handle->state = MEDIACODEC_STATE_NONE;
free(handle);
handle = NULL;
return MEDIACODEC_ERROR_INVALID_OPERATION;
- }
- else
- {
- *mediacodec = (mediacodec_h) handle;
+ } else {
+ *mediacodec = (mediacodec_h)handle;
handle->state = MEDIACODEC_STATE_IDLE;
LOGD("new handle : %p", *mediacodec);
}
int mediacodec_destroy(mediacodec_h mediacodec)
{
- LOGD ("[%s] Start, handle to destroy : %p", __FUNCTION__, mediacodec);
+ LOGD("[%s] Start, handle to destroy : %p", __FUNCTION__, mediacodec);
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
int ret = mc_destroy(handle->mc_handle);
if (ret != MEDIACODEC_ERROR_NONE) {
LOGD("MEDIACODEC_ERROR_INVALID_OPERATION(0x%08x)", MEDIACODEC_ERROR_INVALID_OPERATION);
return MEDIACODEC_ERROR_INVALID_OPERATION;
- }
- else
- {
+ } else {
handle->state = MEDIACODEC_STATE_NONE;
free(handle);
handle = NULL;
int mediacodec_set_codec(mediacodec_h mediacodec, mediacodec_codec_type_e codec_id, mediacodec_support_type_e flags)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
int ret = mc_set_codec(handle->mc_handle, codec_id, flags);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
handle->state = MEDIACODEC_STATE_IDLE;
return MEDIACODEC_ERROR_NONE;
}
int mediacodec_set_vdec_info(mediacodec_h mediacodec, int width, int height)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
int ret = mc_set_vdec_info(handle->mc_handle, width, height);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
handle->state = MEDIACODEC_STATE_IDLE;
return MEDIACODEC_ERROR_NONE;
}
int mediacodec_set_venc_info(mediacodec_h mediacodec, int width, int height, int fps, int target_bits)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
int ret = mc_set_venc_info(handle->mc_handle, width, height, fps, target_bits);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
handle->state = MEDIACODEC_STATE_IDLE;
return MEDIACODEC_ERROR_NONE;
}
int mediacodec_set_adec_info(mediacodec_h mediacodec, int samplerate, int channel, int bit)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
int ret = mc_set_adec_info(handle->mc_handle, samplerate, channel, bit);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
handle->state = MEDIACODEC_STATE_IDLE;
return MEDIACODEC_ERROR_NONE;
}
int mediacodec_set_aenc_info(mediacodec_h mediacodec, int samplerate, int channel, int bit, int bitrate)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
int ret = mc_set_aenc_info(handle->mc_handle, samplerate, channel, bit, bitrate);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
handle->state = MEDIACODEC_STATE_IDLE;
return MEDIACODEC_ERROR_NONE;
}
int mediacodec_prepare(mediacodec_h mediacodec)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
int ret = mc_prepare(handle->mc_handle);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
handle->state = MEDIACODEC_STATE_READY;
return MEDIACODEC_ERROR_NONE;
}
int mediacodec_unprepare(mediacodec_h mediacodec)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
int ret = mc_unprepare(handle->mc_handle);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
handle->state = MEDIACODEC_STATE_IDLE;
return MEDIACODEC_ERROR_NONE;
}
int mediacodec_process_input(mediacodec_h mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
int ret = mc_process_input(handle->mc_handle, inbuf, timeOutUs);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
return MEDIACODEC_ERROR_NONE;
}
}
int mediacodec_get_output(mediacodec_h mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_READY);
int ret = mc_get_output(handle->mc_handle, outbuf, timeOutUs);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
return MEDIACODEC_ERROR_NONE;
}
}
-int mediacodec_flush_buffers (mediacodec_h mediacodec)
+int mediacodec_flush_buffers(mediacodec_h mediacodec)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
int ret = mc_flush_buffers(handle->mc_handle);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
handle->state = MEDIACODEC_STATE_IDLE;
return MEDIACODEC_ERROR_NONE;
}
int mediacodec_get_supported_type(mediacodec_h mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
int ret = mc_get_supported_type(handle->mc_handle, codec_type, encoder, support_type);
- if (ret != MEDIACODEC_ERROR_NONE)
- {
- return __convert_error_code(ret,(char*)__FUNCTION__);
- }
- else
- {
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
handle->state = MEDIACODEC_STATE_IDLE;
return MEDIACODEC_ERROR_NONE;
}
}
-int mediacodec_set_input_buffer_used_cb(mediacodec_h mediacodec, mediacodec_input_buffer_used_cb callback, void* user_data)
+int mediacodec_set_input_buffer_used_cb(mediacodec_h mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
handle->empty_buffer_cb = callback;
int mediacodec_unset_input_buffer_used_cb(mediacodec_h mediacodec)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
handle->empty_buffer_cb = NULL;
handle->empty_buffer_cb_userdata = NULL;
}
-int mediacodec_set_output_buffer_available_cb(mediacodec_h mediacodec, mediacodec_output_buffer_available_cb callback, void* user_data)
+int mediacodec_set_output_buffer_available_cb(mediacodec_h mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
handle->fill_buffer_cb = callback;
int mediacodec_unset_output_buffer_available_cb(mediacodec_h mediacodec)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
handle->fill_buffer_cb = NULL;
handle->fill_buffer_cb_userdata = NULL;
return MEDIACODEC_ERROR_NONE;
}
-int mediacodec_set_error_cb(mediacodec_h mediacodec, mediacodec_error_cb callback, void* user_data)
+int mediacodec_set_error_cb(mediacodec_h mediacodec, mediacodec_error_cb callback, void *user_data)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
handle->error_cb = callback;
int mediacodec_unset_error_cb(mediacodec_h mediacodec)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
handle->error_cb = NULL;
handle->error_cb_userdata = NULL;
return MEDIACODEC_ERROR_NONE;
}
-int mediacodec_set_eos_cb(mediacodec_h mediacodec, mediacodec_eos_cb callback, void* user_data)
+int mediacodec_set_eos_cb(mediacodec_h mediacodec, mediacodec_eos_cb callback, void *user_data)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
handle->eos_cb = callback;
int mediacodec_unset_eos_cb(mediacodec_h mediacodec)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
handle->eos_cb = NULL;
handle->eos_cb_userdata = NULL;
return MEDIACODEC_ERROR_NONE;
}
-int mediacodec_set_buffer_status_cb(mediacodec_h mediacodec, mediacodec_buffer_status_cb callback, void* user_data)
+int mediacodec_set_buffer_status_cb(mediacodec_h mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
handle->buffer_status_cb = callback;
int mediacodec_unset_buffer_status_cb(mediacodec_h mediacodec)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
handle->buffer_status_cb = NULL;
handle->buffer_status_cb_userdata = NULL;
int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
{
MEDIACODEC_INSTANCE_CHECK(mediacodec);
- mediacodec_s * handle = (mediacodec_s *) mediacodec;
- MEDIACODEC_STATE_CHECK(handle, MEDIACODEC_STATE_IDLE);
+ mediacodec_s *handle = (mediacodec_s *)mediacodec;
handle->supported_codec_cb = callback;
handle->supported_codec_cb_userdata = user_data;
LOGD("set supported_codec_cb(%p)", callback);
- _mediacodec_foreach_supported_codec(handle->mc_handle, callback, handle);
+ int ret = _mediacodec_foreach_supported_codec(handle->mc_handle, callback, handle);
+
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ return __convert_error_code(ret, (char *)__FUNCTION__);
+ } else {
+ return MEDIACODEC_ERROR_NONE;
+ }
return MEDIACODEC_ERROR_NONE;
static gboolean __mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
{
- if(user_data == NULL || pkt == NULL)
+ if (user_data == NULL || pkt == NULL)
return 0;
- mediacodec_s * handle = (mediacodec_s *) user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if ( handle->empty_buffer_cb )
- {
+ if (handle->empty_buffer_cb) {
((mediacodec_input_buffer_used_cb)handle->empty_buffer_cb)(pkt, handle->empty_buffer_cb_userdata);
}
static gboolean __mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data)
{
- if(user_data == NULL || pkt == NULL)
+ if (user_data == NULL || pkt == NULL)
return 0;
- mediacodec_s * handle = (mediacodec_s *) user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if ( handle->fill_buffer_cb )
- {
+ if (handle->fill_buffer_cb) {
((mediacodec_output_buffer_available_cb)handle->fill_buffer_cb)(pkt, handle->fill_buffer_cb_userdata);
}
static gboolean __mediacodec_error_cb(mediacodec_error_e error, void *user_data)
{
- if(user_data == NULL)
+ if (user_data == NULL)
return 0;
- mediacodec_s * handle = (mediacodec_s *) user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if ( handle->error_cb )
- {
+ if (handle->error_cb) {
((mediacodec_error_cb)handle->error_cb)(error, handle->error_cb_userdata);
}
static gboolean __mediacodec_eos_cb(void *user_data)
{
- if(user_data == NULL)
+ if (user_data == NULL)
return 0;
- mediacodec_s * handle = (mediacodec_s *) user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if ( handle->eos_cb )
- {
+ if (handle->eos_cb) {
((mediacodec_eos_cb)handle->eos_cb)(handle->eos_cb_userdata);
}
static gboolean __mediacodec_supported_codec_cb(mediacodec_codec_type_e codec_type, void *user_data)
{
- if(user_data == NULL)
+ if (user_data == NULL)
return 0;
- mediacodec_s * handle = (mediacodec_s *) user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if ( handle->supported_codec_cb )
- {
+ if (handle->supported_codec_cb) {
return ((mediacodec_supported_codec_cb)handle->supported_codec_cb)(codec_type, handle->supported_codec_cb_userdata);
}
return false;
static gboolean __mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
{
- if(user_data == NULL)
+ if (user_data == NULL)
return 0;
- mediacodec_s * handle = (mediacodec_s *) user_data;
+ mediacodec_s *handle = (mediacodec_s *)user_data;
- if ( handle->buffer_status_cb )
- {
+ if (handle->buffer_status_cb) {
((mediacodec_buffer_status_cb)handle->buffer_status_cb)(status, handle->buffer_status_cb_userdata);
}
stream->bitcnt = 32;
stream->bytePos = 0;
stream->dataBitPos = 0;
+ stream->buffer = 0;
}
short mc_show_bits(mc_bitstream_t *stream, unsigned char nbits, unsigned int *pulOutData)
unsigned int dataBytePos;
unsigned int i;
- if (nbits > (32 - bitcnt))
- {
+ if (nbits > (32 - bitcnt)) {
dataBytePos = dataBitPos >> 3;
bitcnt = dataBitPos & 7;
- if (dataBytePos > stream->numBytes - 4)
- {
+ if (dataBytePos > stream->numBytes - 4) {
stream->buffer = 0;
- for (i = 0; i < stream->numBytes - dataBytePos; i++)
- {
+ for (i = 0; i < stream->numBytes - dataBytePos; i++) {
stream->buffer |= stream->data[dataBytePos + i];
stream->buffer <<= 8;
}
stream->buffer <<= 8 * (3 - i);
- }
- else
- {
+ } else {
bits = &stream->data[dataBytePos];
stream->buffer = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];
}
return 0;
}
-short mc_read_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)
{
unsigned char *bits;
unsigned int dataBitPos = stream->dataBitPos;
unsigned int bitcnt = stream->bitcnt;
unsigned int dataBytePos;
- if ((dataBitPos + nbits) > (stream->numBytes << 3))
- {
+ if ((dataBitPos + nbits) > (stream->numBytes << 3)) {
*pulOutData = 0;
return -1;
}
- if (nbits > (32 - bitcnt))
- {
+ if (nbits > (32 - bitcnt)) {
dataBytePos = dataBitPos >> 3;
bitcnt = dataBitPos & 7;
bits = &stream->data[dataBytePos];
return 0;
}
-short mc_byte_align( mc_bitstream_t *stream )
+short mc_byte_align(mc_bitstream_t *stream)
{
unsigned char *bits;
unsigned int dataBitPos = stream->dataBitPos;
unsigned int dataBytePos;
unsigned int leftBits;
-
leftBits = 8 - (dataBitPos & 0x7);
- if (leftBits == 8)
- {
+ if (leftBits == 8) {
if ((dataBitPos + 8) > (unsigned int)(stream->numBytes << 3))
return (-1);
dataBitPos += 8;
bitcnt += 8;
- }
- else
- {
+ } else {
dataBytePos = dataBitPos >> 3;
dataBitPos += leftBits;
bitcnt += leftBits;
}
-
-
-
- if (bitcnt > 32)
- {
+ if (bitcnt > 32) {
dataBytePos = dataBitPos >> 3;
bits = &stream->data[dataBytePos];
stream->buffer = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];
return 0;
}
-unsigned int __mc_bytestream_to_nal( unsigned char* data, int size, unsigned char *nal )
+unsigned int __mc_bytestream_to_nal(unsigned char *data, int size)
{
- int nal_length = 0;
unsigned char val, zero_count;
unsigned char *pNal = data;
- int i = 0;
int index = 0;
zero_count = 0;
val = pNal[index++];
- while (!val)
- {
- if ((zero_count == 2 || zero_count == 3) && val == 1)
- break;
+ while (!val) {
zero_count++;
-
val = pNal[index++];
-
}
- nal[nal_length++] = 0;
- nal[nal_length++] = 0;
- nal[nal_length++] = 0;
- nal[nal_length++] = 1;
zero_count = 0;
- while (1)
- {
+ while (1) {
if (index >= size)
- return nal_length;
+ return (index - 1);
val = pNal[index++];
if (!val)
zero_count++;
else {
- if ((zero_count == 2 || zero_count == 3 || zero_count == 4) && (val == 1))
+ if ((zero_count >= 2) && (val == 1))
break;
else {
- for (i = 0; i<zero_count; i++)
- nal[nal_length++] = 0;
- nal[nal_length++] = val;
zero_count = 0;
}
}
-
}
- return nal_length;
+ if (zero_count > 3)
+ zero_count = 3;
+
+ return (index - zero_count - 1);
}
int __mc_decode_sps(mc_bitstream_t *pstream, int *width, int *height)
{
int ret = MC_ERROR_NONE;
unsigned int tmp = 0;
- unsigned int syntax = 0;
int profile_idc = 0;
-
mc_read_bits(pstream, 8, &tmp);
mc_read_bits(pstream, 1, &tmp);
mc_read_bits(pstream, 1, &tmp);
if (profile_idc > 51)
ret = MC_INVALID_IN_BUF;
- //TODO parse width, height, etc...
+ /*TODO parse width, height, etc...*/
return ret;
}
-int _mc_check_bytestream (media_packet_h pkt, unsigned char *nal, int byte_length, int *width, int *height)
+int _mc_check_h264_bytestream(unsigned char *nal, int byte_length, bool port, bool *codec_config, bool *sync_flag, bool *slice)
{
int ret = MC_ERROR_NONE;
int stacked_length = 0;
int nal_length = 0;
unsigned int syntax = 0;
- unsigned char sps[100];
- unsigned char pps[100];
- int sps_size = 0;
- int pps_size = 0;
- int idr = 0;
- unsigned char tmp[1000000];
+ unsigned int state = 0;
+ int count = 0;
+ int nal_unit_type = 0;
mc_bitstream_t pstream;
- while (1)
- {
- nal_length = __mc_bytestream_to_nal( nal + stacked_length, byte_length - stacked_length, tmp);
-
- mc_init_bits (&pstream, nal + stacked_length, byte_length - stacked_length );
- mc_read_bits (&pstream, 32, &syntax);
- mc_read_bits (&pstream, 8, &syntax);
-
- switch ( syntax & 0x1F )
- {
- case NAL_SEQUENCE_PARAMETER_SET:
- LOGD("SPS is found");
- if( (ret = __mc_decode_sps ( &pstream, NULL, NULL )) != MC_ERROR_NONE)
- return ret;
- sps_size = nal_length;
- break;
- case NAL_PICTURE_PARAMETER_SET:
- LOGD("PPS is found");
- pps_size = nal_length;
- break;
- case NAL_SLICE_IDR:
- LOGD ("IDR is found");
- idr++;
+ nal_unit_type = nal[2] == 1 ? (nal[3] & 0x1F) : (nal[4] & 0x1F);
+
+ if (nal_unit_type == 0x7 || nal_unit_type == 0x8 || nal_unit_type == 0x9) {
+
+ while (1) {
+ nal_length = __mc_bytestream_to_nal(nal + stacked_length, byte_length - stacked_length);
+
+ mc_init_bits(&pstream, nal + stacked_length, byte_length - stacked_length);
+ mc_read_bits(&pstream, 32, &syntax);
+ mc_read_bits(&pstream, 8, &syntax);
+
+ switch (syntax & 0x1F) {
+ case NAL_SEQUENCE_PARAMETER_SET:
+ LOGD("nal_unit_type : SPS");
+ if ((ret = __mc_decode_sps(&pstream, NULL, NULL)) != MC_ERROR_NONE)
+ return ret;
+ state |= MC_EXIST_SPS;
+ break;
+ case NAL_PICTURE_PARAMETER_SET:
+ LOGD("nal_unit_type : PPS");
+ state |= MC_EXIST_PPS;
+ break;
+ case NAL_SLICE_IDR:
+ LOGD("nal_unit_type : IDR");
+ state |= MC_EXIST_IDR;
+ break;
+ default:
+ state |= MC_EXIST_SLICE;
+ LOGD("nal_unit_type : %x", syntax & 0x1F);
+ break;
+ }
+
+ LOGD("stacked_length : %d, nal_length : %d, byte_length : %d", stacked_length, nal_length, byte_length);
+
+ stacked_length += nal_length;
+ count++;
+
+ if ((stacked_length >= byte_length) || count > 5)
break;
- default:
- LOGD ("%x nal_unit_type is detected");
+ }
+ } else if (nal_unit_type == 0x5) {
+ state |= MC_EXIST_IDR;
+ LOGD("nal_unit_type is IDR");
+ } else if (nal_unit_type == 0x01 || nal_unit_type == 0x02 || nal_unit_type == 0x03 || nal_unit_type == 0x04) {
+ state |= MC_EXIST_SLICE;
+ LOGD("nal_unit_type : %x", nal_unit_type);
+ } else {
+ LOGD("Non VCL");
+ }
+
+ LOGD("for debug state :%d, %d", state, MC_VALID_FIRST_SLICE);
+
+ /* input port */
+ if (!port && !CHECK_VALID_PACKET(state, MC_VALID_FIRST_SLICE))
+ return MC_INVALID_IN_BUF;
+
+ /* output port */
+ if (port) {
+ *codec_config = CHECK_VALID_PACKET(state, MC_VALID_HEADER) ? 1 : 0;
+ *sync_flag = CHECK_VALID_PACKET(state, MC_EXIST_IDR) ? 1 : 0;
+ *slice = CHECK_VALID_PACKET(state, MC_EXIST_SLICE) ? 1 : 0;
+ }
+
+ return ret;
+}
+
+int _mc_check_valid_h263_frame(unsigned char *p, int size)
+{
+ unsigned char *end = p + size - 3;
+ int count = 0;
+
+ do {
+ /* Found the start of the frame, now try to find the end */
+ if ((p[0] == 0x00) && (p[1] == 0x00) && ((p[2]&0xFC) == 0x80))
+ count++;
+ p++;
+ } while (count == 1 && p < end);
+
+ if (count != 1)
+ return MC_INVALID_IN_BUF; /* frame boundary violated */
+
+ return MC_ERROR_NONE;
+}
+
+bool _mc_is_voss(unsigned char *buf, int size, int *codec_size)
+{
+ unsigned char *p = buf;
+ unsigned char *end = p + size - 3;
+ if (size < 4)
+ return false;
+
+ if (!((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB0)))
+ return false;
+
+ if (codec_size) {
+ for (; p < end ; p++) {
+ if ((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB6)) {
+ *codec_size = p-buf;
break;
+ }
}
+ }
- stacked_length += nal_length;
+ return true;
+}
- if ( stacked_length >= byte_length )
- break;
+bool _mc_is_ivop(unsigned char *p, int size, int pos)
+{
+ if (size < (pos + 5))
+ return false;
+
+ p = p + pos;
+
+ if ((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB6)) {
+ /* VOP_CODING_TYPE (binary) Coding method
+ // 00 intra-coded (I)
+ // 01 predictive-coded (P)
+ // 10 bidirectionally-predictive-coded (B)
+ // 11 sprite (S)
+ */
+ if ((p[4] & 0xC0) == 0x0) /*I-VOP */
+ return true;
}
+ return false;
+}
+
+bool _mc_is_vop(unsigned char *p, int size, int pos)
+{
+ if (size < (pos + 4))
+ return false;
+
+ p = p + pos;
+
+ if ((p[0] == 0x00) && (p[1] == 0x00) && (p[2] == 0x01) && (p[3] == 0xB6))
+ return true;
- if ( sps_size > 0 && pps_size > 0 ) {
- memcpy(tmp, sps, sps_size);
- memcpy(tmp + sps_size, pps, pps_size);
- media_packet_set_codec_data( pkt, tmp, sps_size + pps_size);
+ return false;
+}
+
+int _mc_check_mpeg4_out_bytestream(unsigned char *buf, int buf_length, bool* need_codec_data, bool *need_sync_flag)
+{
+ int codec_data_size = 0;
+ g_return_val_if_fail(need_codec_data != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(need_sync_flag != NULL, MC_PARAM_ERROR);
+
+ *need_codec_data = FALSE;
+ *need_sync_flag = FALSE;
+
+ if (_mc_is_voss(buf, buf_length, &codec_data_size))
+ *need_codec_data = TRUE;
+ if (_mc_is_ivop(buf, buf_length, codec_data_size))
+ *need_sync_flag = TRUE;
+
+ return codec_data_size;
+}
+
+bool _mc_check_h263_out_bytestream(unsigned char *p, int buf_length, bool* need_sync_flag)
+{
+ g_return_val_if_fail(need_sync_flag != NULL, MC_PARAM_ERROR);
+
+ *need_sync_flag = FALSE;
+
+ /* PSC not present */
+ if ((p[0] != 0x00) || (p[1] != 0x00) || ((p[2]&0xFC) != 0x80)) {
+ return false;
}
- else {
- LOGE("doesn't contain codec_data(sps[%d],pps[%d],idr[%d])", sps, pps, idr);
- ret = MC_INVALID_IN_BUF;
+
+ /* PTYPE Field, Bit 9: Picture Coding Type, "0" INTRA (I-picture), "1" INTER (P-picture) */
+ if (!(p[4] & 0x2)) {
+ *need_sync_flag = TRUE;
}
- return ret;
+ return TRUE;
}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+
+#ifndef __MEDIA_CODEC_INI_C__
+#define __MEDIA_CODEC_INI_C__
+
+/* includes here */
+#include <glib.h>
+#include <stdlib.h>
+#include <glib/gstdio.h>
+#include <mm_debug.h>
+#include <mm_error.h>
+#include "iniparser.h"
+#include <media_codec_ini.h>
+#include <media_codec_port.h>
+
+#define DEFAULT_VALUE ""
+
+#define DEFAULT_HW_DECODER_NAME ""
+#define DEFAULT_HW_DECODER_MIME ""
+#define DEFAULT_HW_DECODER_FORMAT ""
+
+#define DEFAULT_HW_ENCODER_NAME ""
+#define DEFAULT_HW_ENCODER_MIME ""
+#define DEFAULT_HW_ENCODER_FORMAT ""
+
+#define DEFAULT_SW_DECODER_NAME ""
+#define DEFAULT_SW_DECODER_MIME ""
+#define DEFAULT_SW_DECODER_FORMAT ""
+
+#define DEFAULT_SW_ENCODER_NAME ""
+#define DEFAULT_SW_ENCODER_MIME ""
+#define DEFAULT_SW_ENCODER_FORMAT ""
+
+typedef struct {
+ gchar cname[MEDIA_CODEC_INI_MAX_STRLEN];
+ mediacodec_codec_type_e ctype;
+}codec_list_t;
+
+static codec_list_t general_codec_list[]={
+ {"h261", MEDIACODEC_H261},
+ {"h263", MEDIACODEC_H263},
+ {"h264", MEDIACODEC_H264},
+ {"mjpeg", MEDIACODEC_MJPEG},
+ {"mpeg1", MEDIACODEC_MPEG1},
+ {"mpeg2", MEDIACODEC_MPEG2},
+ {"mpeg4", MEDIACODEC_MPEG4},
+ {"hevc", MEDIACODEC_HEVC},
+ {"vp8", MEDIACODEC_VP8},
+ {"vp9", MEDIACODEC_VP9},
+ {"vc1", MEDIACODEC_VC1},
+ {"aac_lc", MEDIACODEC_AAC_LC},
+ {"aac_he", MEDIACODEC_AAC_HE},
+ {"aac_he_ps", MEDIACODEC_AAC_HE_PS},
+ {"mp3", MEDIACODEC_MP3},
+ {"amr_nb", MEDIACODEC_AMR_NB},
+ {"amr_wb", MEDIACODEC_AMR_WB},
+ {"vorbis", MEDIACODEC_VORBIS},
+ {"flac", MEDIACODEC_FLAC},
+ {"wmav1", MEDIACODEC_WMAV1},
+ {"wmav2", MEDIACODEC_WMAV2},
+ {"wmapro", MEDIACODEC_WMAPRO},
+};
+
+/* internal functions, macros here */
+#ifdef MEDIA_CODEC_DEFAULT_INI
+static gboolean _generate_default_ini(void);
+#endif
+
+static void _mc_ini_check_ini_status(void);
+
+/* macro */
+#define MEDIA_CODEC_INI_GET_STRING( x_dict, x_item, x_ini, x_default ) \
+ do \
+{ \
+ gchar* str = iniparser_getstring(x_dict, x_ini, x_default); \
+ \
+ if ( str && \
+ ( strlen( str ) > 0 ) && \
+ ( strlen( str ) < MEDIA_CODEC_INI_MAX_STRLEN ) ) \
+ { \
+ strcpy ( x_item, str ); \
+ } \
+ else \
+ { \
+ strcpy ( x_item, x_default ); \
+ } \
+}while(0)
+
+#define MEDIA_CODEC_INI_GET_STRING_FROM_LIST( x_dict, x_list, x_ini, x_default ) \
+ do \
+{ \
+ char *token = NULL; \
+ char *usr_ptr = NULL; \
+ int index = 0; \
+ const char *delimiters = " ,"; \
+ gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
+ MEDIA_CODEC_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
+ token = strtok_r( temp_arr, delimiters, &usr_ptr ); \
+ while (token) \
+ { \
+ if (index == 0) \
+ strncpy(x_list.name,token, MEDIA_CODEC_INI_MAX_STRLEN-1 );\
+ else if (index == 1) \
+ strncpy(x_list.mime,token, MEDIA_CODEC_INI_MAX_STRLEN-1 );\
+ else if (index == 2) \
+ strncpy(x_list.format,token, MEDIA_CODEC_INI_MAX_STRLEN-1 );\
+ index++;\
+ token = strtok_r( NULL, delimiters, &usr_ptr ); \
+ } \
+}while(0)
+
+#define MEDIA_CODEC_INI_GET_COLOR( x_dict, x_item, x_ini, x_default ) \
+ do \
+{ \
+ gchar* str = iniparser_getstring(x_dict, x_ini, x_default); \
+ \
+ if ( str && \
+ ( strlen( str ) > 0 ) && \
+ ( strlen( str ) < MEDIA_CODEC_INI_MAX_STRLEN ) ) \
+ { \
+ x_item = (guint) strtoul(str, NULL, 16); \
+ } \
+ else \
+ { \
+ x_item = (guint) strtoul(x_default, NULL, 16); \
+ } \
+}while(0)
+
+/* x_ini is the list of index to set TRUE at x_list[index] */
+#define MEDIA_CODEC_INI_GET_BOOLEAN_FROM_LIST( x_dict, x_list, x_list_max, x_ini, x_default ) \
+ do \
+{ \
+ int index = 0; \
+ const char *delimiters = " ,"; \
+ char *usr_ptr = NULL; \
+ char *token = NULL; \
+ gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
+ MEDIA_CODEC_INI_GET_STRING( x_dict, temp_arr, x_ini, x_default); \
+ token = strtok_r( temp_arr, delimiters, &usr_ptr ); \
+ while (token) \
+ { \
+ index = atoi(token); \
+ if (index < 0 || index > x_list_max -1) \
+ { \
+ LOGW("%d is not valid index\n", index); \
+ } \
+ else \
+ { \
+ x_list[index] = TRUE; \
+ } \
+ token = strtok_r( NULL, delimiters, &usr_ptr ); \
+ } \
+}while(0)
+
+/* x_ini is the list of value to be set at x_list[index] */
+#define MEDIA_CODEC_INI_GET_INT_FROM_LIST( x_dict, x_list, x_list_max, x_ini, x_default ) \
+ do \
+{ \
+ int index = 0; \
+ int value = 0; \
+ const char *delimiters = " ,"; \
+ char *usr_ptr = NULL; \
+ char *token = NULL; \
+ gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
+ MEDIA_CODEC_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
+ token = strtok_r( temp_arr, delimiters, &usr_ptr ); \
+ while (token) \
+ { \
+ if ( index > x_list_max -1) \
+ { \
+ LOGE("%d is not valid index\n", index); \
+ break; \
+ } \
+ else \
+ { \
+ value = atoi(token); \
+ x_list[index] = value; \
+ index++; \
+ } \
+ token = strtok_r( NULL, delimiters, &usr_ptr ); \
+ } \
+}while(0)
+
+#define MEDIA_CODEC_GET_DEFAULT_LIST( x_list, x_default ) \
+ do \
+{ \
+ strncpy( x_list, x_default, MEDIA_CODEC_INI_MAX_STRLEN - 1);\
+}while(0)
+#define MEDIA_CODEC_PRINT_LIST( x_list, x_message ) \
+ do \
+{ \
+ codec_info_t codec_list= x_list;\
+ printf("%s =", x_message);\
+ printf("%s %s %s\n", codec_list.name, codec_list.mime, codec_list.format);\
+}while(0)
+
+media_format_mimetype_e _mc_convert_media_format_str_to_int(char *sformat )
+{
+
+ media_format_mimetype_e iformat = MEDIA_FORMAT_I420;
+ if (!strcmp(sformat,"I420")) {
+ iformat = MEDIA_FORMAT_I420;
+ goto endf;
+ } else if (!strcmp(sformat,"NV12")) {
+ iformat = MEDIA_FORMAT_NV12;
+ goto endf;
+ } else if (!strcmp(sformat,"NV12T")) {
+ iformat = MEDIA_FORMAT_NV12T;
+ goto endf;
+ } else if (!strcmp(sformat,"YV12")) {
+ iformat = MEDIA_FORMAT_YV12;
+ goto endf;
+ } else if (!strcmp(sformat,"NV21")) {
+ iformat = MEDIA_FORMAT_NV21;
+ goto endf;
+ } else if (!strcmp(sformat,"NV16")) {
+ iformat = MEDIA_FORMAT_NV16;
+ } else if (!strcmp(sformat,"YUYV")) {
+ iformat = MEDIA_FORMAT_YUYV;
+ goto endf;
+ } else if (!strcmp(sformat,"UYVY")) {
+ iformat = MEDIA_FORMAT_UYVY;
+ goto endf;
+ } else if (!strcmp(sformat,"422P")) {
+ iformat = MEDIA_FORMAT_422P;
+ goto endf;
+ } else if (!strcmp(sformat,"RGB565")) {
+ iformat = MEDIA_FORMAT_RGB565;
+ goto endf;
+ } else if (!strcmp(sformat,"RGB888")) {
+ iformat = MEDIA_FORMAT_RGB888;
+ goto endf;
+ } else if (!strcmp(sformat,"RGBA")) {
+ iformat = MEDIA_FORMAT_RGBA;
+ goto endf;
+ } else if (!strcmp(sformat,"ARGB")) {
+ iformat = MEDIA_FORMAT_ARGB;
+ goto endf;
+ } else if (!strcmp(sformat,"PCM")) {
+ iformat = MEDIA_FORMAT_PCM;
+ goto endf;
+ } else if (!strcmp(sformat,"H261")) {
+ iformat = MEDIA_FORMAT_H261;
+ goto endf;
+ } else if (!strcmp(sformat,"H263")) {
+ iformat = MEDIA_FORMAT_H263;
+ goto endf;
+ } else if (!strcmp(sformat,"H263P")) {
+ iformat = MEDIA_FORMAT_H263P;
+ goto endf;
+ } else if (!strcmp(sformat,"H264_SP")) {
+ iformat = MEDIA_FORMAT_H264_SP;
+ goto endf;
+ } else if (!strcmp(sformat,"H264_MP")) {
+ iformat = MEDIA_FORMAT_H264_MP;
+ goto endf;
+ } else if (!strcmp(sformat,"H264_HP")) {
+ iformat = MEDIA_FORMAT_H264_HP;
+ goto endf;
+ } else if (!strcmp(sformat,"MPEG4_SP")) {
+ iformat = MEDIA_FORMAT_MPEG4_SP;
+ goto endf;
+ } else if (!strcmp(sformat,"MPEG4_ASP")) {
+ iformat = MEDIA_FORMAT_MPEG4_ASP;
+ goto endf;
+ } else if (!strcmp(sformat,"AMR_NB")) {
+ iformat = MEDIA_FORMAT_AMR_NB;
+ goto endf;
+ } else if (!strcmp(sformat,"AMR_WB")) {
+ iformat = MEDIA_FORMAT_AMR_WB;
+ goto endf;
+ } else if (!strcmp(sformat,"AAC_LC")) {
+ iformat = MEDIA_FORMAT_AAC_LC;
+ goto endf;
+ } else if (!strcmp(sformat,"AAC_HE")) {
+ iformat = MEDIA_FORMAT_AAC_HE;
+ goto endf;
+ } else if (!strcmp(sformat,"AAC_HE_PS")) {
+ iformat = MEDIA_FORMAT_AAC_HE_PS;
+ goto endf;
+ } else if (!strcmp(sformat,"MP3")) {
+ iformat = MEDIA_FORMAT_MP3;
+ goto endf;
+ } else if (!strcmp(sformat,"VORBIS")) {
+ iformat = MEDIA_FORMAT_VORBIS;
+ goto endf;
+ } else if (!strcmp(sformat,"FLAC")) {
+ iformat = MEDIA_FORMAT_FLAC;
+ goto endf;
+ } else if (!strcmp(sformat,"WMAV1")) {
+ iformat = MEDIA_FORMAT_WMAV1;
+ goto endf;
+ } else if (!strcmp(sformat,"WMAV2")) {
+ iformat = MEDIA_FORMAT_WMAV2;
+ goto endf;
+ } else if (!strcmp(sformat,"WMAPRO")) {
+ iformat = MEDIA_FORMAT_WMAPRO;
+ goto endf;
+ }
+
+endf:
+ LOGD("sformat : %x", iformat);
+ return iformat;
+}
+
+int mc_ini_load(mc_ini_t *ini)
+{
+ gchar cname[256];
+ int i = 0;
+ dictionary *dict = NULL;
+
+ static const int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
+
+ _mc_ini_check_ini_status();
+
+ /* first, try to load existing ini file */
+ dict = iniparser_load(MEDIA_CODEC_INI_DEFAULT_PATH);
+
+ /* if no file exists. create one with set of default values */
+ if (!dict) {
+#ifdef MEDIA_CODEC_DEFAULT_INI
+ LOGD("No inifile found. codec will create default inifile.\n");
+ if (FALSE == _generate_default_ini()) {
+ LOGW("Creating default inifile failed. Media Codec will use default values.\n");
+ } else {
+ /* load default ini */
+ dict = iniparser_load(MEDIA_CODEC_INI_DEFAULT_PATH);
+ }
+#else
+ LOGD("No ini file found. \n");
+ return LOGERROR_FILE_NOT_FOUND;
+#endif
+ }
+
+ /* get ini values */
+ memset(ini, 0, sizeof(mc_ini_t));
+
+ if (dict) {/* if dict is available */
+ /* general */
+ MEDIA_CODEC_INI_GET_STRING( dict, ini->port_name, "port_in_use:media_codec_port",DEFAULT_PORT);
+ /* codec */
+ for (i = 0; i < codec_list; i++) {
+ memset(cname, 0x00, 256);
+ strcpy(cname, general_codec_list[i].cname);
+ int len = strlen(cname);
+ ini->codec[i].codec_id = general_codec_list[i].ctype;
+ sprintf(cname+len, "%s", ":hw_decoder");
+ MEDIA_CODEC_INI_GET_STRING_FROM_LIST( dict, ini->codec[i].codec_info[0], cname, DEFAULT_VALUE);
+ sprintf(cname+len, "%s", ":hw_encoder");
+ MEDIA_CODEC_INI_GET_STRING_FROM_LIST( dict, ini->codec[i].codec_info[1], cname, DEFAULT_VALUE);
+ sprintf(cname+len, "%s", ":sw_decoder");
+ MEDIA_CODEC_INI_GET_STRING_FROM_LIST( dict, ini->codec[i].codec_info[2], cname, DEFAULT_VALUE);
+ sprintf(cname+len, "%s", ":sw_encoder");
+ MEDIA_CODEC_INI_GET_STRING_FROM_LIST( dict, ini->codec[i].codec_info[3], cname, DEFAULT_VALUE);
+ }
+ } else {/* if dict is not available just fill the structure with default value */
+
+ LOGW("failed to load ini. using hardcoded default\n");
+ /* general */
+ strncpy( ini->port_name, DEFAULT_PORT, MEDIA_CODEC_INI_MAX_STRLEN - 1);
+ for (i = 0; i < codec_list; i++) {
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[0].name, DEFAULT_HW_DECODER_NAME);
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[0].mime, DEFAULT_HW_DECODER_MIME);
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[0].format, DEFAULT_HW_DECODER_FORMAT);
+
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[1].name, DEFAULT_HW_ENCODER_NAME);
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[1].mime, DEFAULT_HW_ENCODER_MIME);
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[1].format, DEFAULT_HW_ENCODER_FORMAT);
+
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[2].name, DEFAULT_SW_DECODER_NAME);
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[2].mime, DEFAULT_SW_DECODER_MIME);
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[2].format, DEFAULT_SW_DECODER_FORMAT);
+
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[3].name, DEFAULT_SW_ENCODER_NAME);
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[3].mime, DEFAULT_SW_ENCODER_MIME);
+ MEDIA_CODEC_GET_DEFAULT_LIST( ini->codec[i].codec_info[3].format, DEFAULT_SW_ENCODER_FORMAT);
+ }
+ }
+
+ if (0 == strcmp(ini->port_name, "GST_PORT"))
+ ini->port_type = GST_PORT;
+ else {
+ LOGE("Invalid port is set to [%s] [%d]\n", ini->port_name,ini->port_type);
+ goto ERROR;
+ }
+ LOGD("The port is set to [%s] [%d]\n", ini->port_name, ini->port_type);
+
+ for (i = 0; i < codec_list; i++) {
+ memset(cname, 0x00, 256);
+ strcpy(cname, general_codec_list[i].cname);
+ int len = strlen(cname);
+ sprintf(cname+len, "%s", ":hw_decoder");
+ MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[0],cname);
+ sprintf(cname+len, "%s", ":hw_encoder");
+ MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[1],cname);
+ sprintf(cname+len, "%s", ":sw_decoder");
+ MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[2],cname);
+ sprintf(cname+len, "%s", ":sw_encoder");
+ MEDIA_CODEC_PRINT_LIST(ini->codec[i].codec_info[3],cname);
+ }
+
+ /* free dict as we got our own structure */
+ iniparser_freedict(dict);
+
+ /* dump structure */
+ LOGD("codec settings -----------------------------------\n");
+
+ /* general */
+ LOGD("port_name: %s\n", ini->port_name);
+ LOGD("port_type : %d\n", ini->port_type);
+
+ return MC_ERROR_NONE;
+ERROR:
+ return MC_COURRPTED_INI;
+
+}
+
+static void _mc_ini_check_ini_status(void)
+{
+ struct stat ini_buff;
+
+ if (g_stat(MEDIA_CODEC_INI_DEFAULT_PATH, &ini_buff) < 0) {
+ LOGW("failed to get codec ini status\n");
+ } else {
+ if (ini_buff.st_size < 5) {
+ LOGW("codec.ini file size=%d, Corrupted! So, Removed\n", (int)ini_buff.st_size);
+
+ if (g_remove(MEDIA_CODEC_INI_DEFAULT_PATH) == -1) {
+ LOGE("failed to delete corrupted ini");
+ }
+ }
+ }
+}
+
+#ifdef MEDIA_CODEC_DEFAULT_INI
+static gboolean _generate_default_ini(void)
+{
+ FILE *fp = NULL;
+ gchar *default_ini = MEDIA_CODEC_DEFAULT_INI;
+
+ /* create new file */
+ fp = fopen(MEDIA_CODEC_INI_DEFAULT_PATH, "wt");
+
+ if (!fp) {
+ return FALSE;
+ }
+
+ /* writing default ini file */
+ if (strlen(default_ini) !=
+ fwrite(default_ini, 1, strlen(default_ini), fp)) {
+ fclose(fp);
+ return FALSE;
+ }
+
+ fclose(fp);
+ return TRUE;
+}
+#endif
+
+void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec)
+{
+ int indx = 0, count = 0;
+ int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
+ for (indx = 0; indx < codec_list; indx++) {
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) {
+ mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
+ mediacodec->decoder_map[count].hardware = 1; /* hardware */
+ mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[0].name;
+ mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[0].mime;
+ mediacodec->decoder_map[count].type.out_format= _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[0].format);
+ count++;
+ }
+
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) {
+ mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
+ mediacodec->decoder_map[count].hardware = 0; /* software */
+ mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[2].name;
+ mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[2].mime;
+ mediacodec->decoder_map[count].type.out_format= _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[2].format);
+ count++;
+ }
+ }
+ mediacodec->num_supported_decoder = count;
+ return;
+
+}
+
+void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec)
+{
+ int indx = 0, count = 0;
+ int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
+
+ for (indx=0;indx < codec_list; indx++) {
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) {
+ mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
+ mediacodec->encoder_map[count].hardware = 1;
+ mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[1].name;
+ mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[1].mime;
+ mediacodec->encoder_map[count].type.out_format= _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[1].format);
+ count++;
+ }
+
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) {
+ mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id;
+ mediacodec->encoder_map[count].hardware = 0;
+ mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[3].name;
+ mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[3].mime;
+ mediacodec->encoder_map[count].type.out_format= _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[3].format);
+ count++;
+ }
+ }
+ mediacodec->num_supported_encoder = count;
+ return;
+
+}
+void _mc_create_codec_map_from_ini(mc_handle_t *mediacodec, mc_codec_spec_t *spec_emul)
+{
+ int indx = 0, count = 0;
+ int codec_list = sizeof(general_codec_list) / sizeof(general_codec_list[0]);
+ for (indx=0;indx <codec_list;indx++) {
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) {
+ spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
+ spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW;
+ spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
+ count++;
+ }
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) {
+ spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
+ spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW;
+ spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
+ count++;
+ }
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) {
+ spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
+ spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW;
+ spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
+ count++;
+ }
+ if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) {
+ spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id;
+ spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW;
+ spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST;
+ count++;
+ }
+ }
+
+ mediacodec->num_supported_codecs = count;
+ return;
+}
+
+#endif /* #ifdef _MEDIA_CODEC_INI_C_ */
#include <media_codec_private.h>
#include <media_codec_port.h>
#include <media_codec_port_gst.h>
-
#include <media_codec_spec_emul.h>
-static int sort(gpointer p1, gpointer p2)
-{
- int a, b;
-
- a = GPOINTER_TO_INT(p1);
- b = GPOINTER_TO_INT(p2);
-
- return (a > b ? 1 : a == b ? 0 : 1);
-}
+static mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE];
int mc_create(MMHandleType *mediacodec)
{
- mc_handle_t* new_mediacodec = NULL;
+ mc_handle_t *new_mediacodec = NULL;
int ret = MC_ERROR_NONE;
int i;
int support_list = sizeof(spec_emul) / sizeof(spec_emul[0]);
- GList *list = NULL;
/* alloc mediacodec structure */
- new_mediacodec = (mc_handle_t*)g_malloc(sizeof(mc_handle_t));
- if ( ! new_mediacodec )
- {
- LOGE("Cannot allocate memory for player\n");
+ new_mediacodec = (mc_handle_t *)g_malloc(sizeof(mc_handle_t));
+
+ if (!new_mediacodec) {
+ LOGE("Cannot allocate memory for mediacodec");
ret = MC_ERROR;
goto ERROR;
}
memset(new_mediacodec, 0, sizeof(mc_handle_t));
+ memset(spec_emul, 0, sizeof(mc_codec_spec_t)*MEDIA_CODEC_MAX_CODEC_TYPE);
new_mediacodec->is_encoder = false;
new_mediacodec->is_video = false;
new_mediacodec->ports[0] = NULL;
new_mediacodec->ports[1] = NULL;
+ new_mediacodec->num_supported_codecs = 0;
+ new_mediacodec->num_supported_decoder = 0;
+ new_mediacodec->num_supported_encoder = 0;
+
new_mediacodec->core = NULL;
- for(i=0; i<support_list; i++)
- {
- new_mediacodec->supported_codecs = g_list_append(new_mediacodec->supported_codecs, GINT_TO_POINTER(spec_emul[i].codec_id));
- }
- new_mediacodec->supported_codecs = g_list_sort(new_mediacodec->supported_codecs, sort);
+ /* load ini files */
+ ret = mc_ini_load(&new_mediacodec->ini);
+ if(ret != MC_ERROR_NONE)
+ goto ERROR;
+ _mc_create_codec_map_from_ini(new_mediacodec, spec_emul);
- gpointer p1;
- for(i=0; i<support_list; i++)
- {
- p1 = g_list_nth_data(list, i);
- LOGD("list_sort :%d(%x)",i, GPOINTER_TO_INT(p1));
+ for (i = 0; i < new_mediacodec->num_supported_codecs; i++) {
+ new_mediacodec->supported_codecs =
+ g_list_append(new_mediacodec->supported_codecs, GINT_TO_POINTER(spec_emul[i].codec_id));
}
+ /* create decoder map from ini */
+ _mc_create_decoder_map_from_ini(new_mediacodec);
+ /* create encoder map from ini */
+ _mc_create_encoder_map_from_ini(new_mediacodec);
g_mutex_init(&new_mediacodec->cmd_lock);
*mediacodec = (MMHandleType)new_mediacodec;
return ret;
ERROR:
- if ( new_mediacodec )
- {
- free(new_mediacodec);
- new_mediacodec = NULL;
- }
return MC_INVALID_ARG;
}
int mc_destroy(MMHandleType mediacodec)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- MEDIACODEC_CMD_LOCK( mediacodec );
+ MEDIACODEC_CMD_LOCK(mediacodec);
LOGD("mediacodec : %p", mediacodec);
- if(mc_handle->core != NULL)
- {
- if(mc_gst_unprepare(mc_handle) != MC_ERROR_NONE)
- {
+ if (mc_handle->core != NULL) {
+ if (mc_gst_unprepare(mc_handle) != MC_ERROR_NONE) {
LOGE("mc_gst_unprepare() failed");
return MC_ERROR;
}
mc_handle->is_prepared = false;
g_list_free(mc_handle->supported_codecs);
- MEDIACODEC_CMD_UNLOCK( mediacodec );
+ MEDIACODEC_CMD_UNLOCK(mediacodec);
/* free mediacodec structure */
- if(mc_handle) {
- g_free( (void*)mc_handle );
+ if (mc_handle) {
+ g_free((void *)mc_handle);
mc_handle = NULL;
}
+
return ret;
}
int mc_set_codec(MMHandleType mediacodec, mediacodec_codec_type_e codec_id, mediacodec_support_type_e flags)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
- static const int support_list = sizeof(spec_emul) / sizeof(spec_emul[0]);
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
int i;
- if (!mc_handle)
- {
- LOGE("fail invaild param\n");
+ if (!mc_handle) {
+ LOGE("fail invaild param");
return MC_INVALID_ARG;
}
/* Mandatory setting */
- if ( !GET_IS_ENCODER(flags) && !GET_IS_DECODER(flags) )
- {
- LOGE("should be encoder or decoder\n");
+ if (!GET_IS_ENCODER(flags) && !GET_IS_DECODER(flags)) {
+ LOGE("should be encoder or decoder");
return MC_PARAM_ERROR;
}
- for(i = 0; i < support_list; i++)
- {
- if((codec_id == spec_emul[i].codec_id) && (flags == spec_emul[i].codec_type))
- {
+
+ for (i = 0; i < mc_handle->num_supported_codecs; i++) {
+ if ((codec_id == spec_emul[i].codec_id) && (flags == spec_emul[i].codec_type)) {
break;
}
}
+ LOGD("support_list : %d, i : %d", mc_handle->num_supported_codecs, i);
- LOGD("support_list : %d, i : %d", support_list, i);
-
- if(i == support_list)
+ if (i == mc_handle->num_supported_codecs)
return MC_NOT_SUPPORTED;
mc_handle->port_type = spec_emul[i].port_type;
int mc_set_vdec_info(MMHandleType mediacodec, int width, int height)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t* mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
return MC_PARAM_ERROR;
MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && !mc_handle->is_encoder,
- MEDIACODEC_ERROR_INVALID_PARAMETER,"MEDIACODEC_ERROR_INVALID_PARAMETER");
+ MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
mc_handle->info.decoder.width = width;
mc_handle->info.decoder.height = height;
mc_handle->is_prepared = true;
- switch ( mc_handle->codec_id )
- {
+ switch (mc_handle->codec_id) {
case MEDIACODEC_H264:
mc_sniff_bitstream = mc_sniff_h264_bitstream;
LOGD("mc_sniff_h264_bitstream");
int mc_set_venc_info(MMHandleType mediacodec, int width, int height, int fps, int target_bits)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
return MC_PARAM_ERROR;
MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && mc_handle->is_video && mc_handle->is_encoder,
- MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
+ MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
mc_handle->info.encoder.width = width;
mc_handle->info.encoder.height = height;
mc_handle->info.encoder.fps = fps;
mc_handle->info.encoder.bitrate = target_bits;
-
mc_handle->is_prepared = true;
-
mc_sniff_bitstream = mc_sniff_yuv;
+
return ret;
}
int mc_set_adec_info(MMHandleType mediacodec, int samplerate, int channel, int bit)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
return MC_PARAM_ERROR;
MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && !mc_handle->is_encoder,
- MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
+ MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
mc_handle->info.decoder.samplerate = samplerate;
mc_handle->info.decoder.channel = channel;
mc_handle->info.decoder.bit = bit;
-
mc_handle->is_prepared = true;
return ret;
}
-int mc_set_aenc_info(MMHandleType mediacodec, int samplerate, int channel, int bit, int bitrate)
+int mc_set_aenc_info(MMHandleType mediacodec, int samplerate, int channel, int bit, int bitrate)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t * mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
return MC_PARAM_ERROR;
MEDIACODEC_CHECK_CONDITION(mc_handle->codec_id && !mc_handle->is_video && mc_handle->is_encoder,
- MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
+ MEDIACODEC_ERROR_INVALID_PARAMETER, "MEDIACODEC_ERROR_INVALID_PARAMETER");
mc_handle->info.encoder.samplerate = samplerate;
mc_handle->info.encoder.channel = channel;
int mc_prepare(MMHandleType mediacodec)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- if(!mc_handle->is_prepared)
+ if (!mc_handle->is_prepared)
return MC_NOT_INITIALIZED;
- MEDIACODEC_CMD_LOCK( mediacodec );
+ MEDIACODEC_CMD_LOCK(mediacodec);
/* setting core details */
- switch ( mc_handle->port_type )
- {
+ switch (mc_handle->port_type) {
case MEDIACODEC_PORT_TYPE_GENERAL:
{
}
break;
}
- MEDIACODEC_CMD_UNLOCK( mediacodec );
+ MEDIACODEC_CMD_UNLOCK(mediacodec);
return ret;
}
int mc_unprepare(MMHandleType mediacodec)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- MEDIACODEC_CMD_LOCK( mediacodec );
+ MEDIACODEC_CMD_LOCK(mediacodec);
/* deinit core details */
- switch ( mc_handle->port_type )
- {
+ switch (mc_handle->port_type) {
case MEDIACODEC_PORT_TYPE_GENERAL:
{
}
break;
}
- MEDIACODEC_CMD_UNLOCK( mediacodec );
+ MEDIACODEC_CMD_UNLOCK(mediacodec);
return ret;
}
-int mc_process_input(MMHandleType mediacodec, media_packet_h inbuf, uint64_t timeOutUs )
+int mc_process_input(MMHandleType mediacodec, media_packet_h inbuf, uint64_t timeOutUs)
{
int ret = MC_ERROR_NONE;
- uint64_t buf_size = 0;
- void *buf_data = NULL;
- bool eos = false;
-
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
if (!mc_handle) {
- LOGE("fail invaild param\n");
+ LOGE("fail invaild param");
return MC_INVALID_ARG;
}
-#if 1
- if ( mc_handle->is_video) {
- if ((ret = mc_sniff_bitstream(mc_handle, inbuf)) != MC_ERROR_NONE ) {
- return MC_INVALID_IN_BUF;
- }
- }
-#else
- ret = media_packet_get_buffer_size(inbuf, &buf_size);
- if (ret != MEDIA_PACKET_ERROR_NONE)
- {
- LOGE("invaild input buffer");
- return MC_INVALID_IN_BUF;
- }
- ret = media_packet_get_buffer_data_ptr(inbuf, &buf_data);
- if (ret != MEDIA_PACKET_ERROR_NONE)
- {
- LOGE("invaild input buffer");
- return MC_INVALID_IN_BUF;
- }
-
- ret = media_packet_is_end_of_stream(inbuf, &eos);
- if (ret != MEDIA_PACKET_ERROR_NONE)
- {
- LOGE("invaild input buffer");
- return MC_INVALID_IN_BUF;
- }
-
- if(!eos)
- {
- if((buf_data == NULL) || (buf_size == 0))
- {
- LOGE("invaild input buffer");
+ if (mc_handle->is_video) {
+ if ((ret = mc_sniff_bitstream(mc_handle, inbuf)) != MC_ERROR_NONE) {
return MC_INVALID_IN_BUF;
}
}
-#endif
- MEDIACODEC_CMD_LOCK( mediacodec );
- switch ( mc_handle->port_type )
- {
+ MEDIACODEC_CMD_LOCK(mediacodec);
+
+ switch (mc_handle->port_type) {
case MEDIACODEC_PORT_TYPE_GENERAL:
break;
break;
}
- MEDIACODEC_CMD_UNLOCK( mediacodec );
+ MEDIACODEC_CMD_UNLOCK(mediacodec);
return ret;
}
int mc_get_output(MMHandleType mediacodec, media_packet_h *outbuf, uint64_t timeOutUs)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- MEDIACODEC_CMD_LOCK( mediacodec );
+ MEDIACODEC_CMD_LOCK(mediacodec);
/* setting core details */
- switch ( mc_handle->port_type )
- {
+ switch (mc_handle->port_type) {
case MEDIACODEC_PORT_TYPE_GENERAL:
break;
break;
}
- MEDIACODEC_CMD_UNLOCK( mediacodec );
+ MEDIACODEC_CMD_UNLOCK(mediacodec);
return ret;
}
int mc_flush_buffers(MMHandleType mediacodec)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- MEDIACODEC_CMD_LOCK( mediacodec );
+ MEDIACODEC_CMD_LOCK(mediacodec);
/* setting core details */
- switch ( mc_handle->port_type )
- {
+ switch (mc_handle->port_type) {
case MEDIACODEC_PORT_TYPE_GENERAL:
break;
break;
}
- MEDIACODEC_CMD_UNLOCK( mediacodec );
+ MEDIACODEC_CMD_UNLOCK(mediacodec);
return ret;
}
int mc_get_supported_type(MMHandleType mediacodec, mediacodec_codec_type_e codec_type, bool encoder, int *support_type)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
- static const mc_codec_map_t *codec_map;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
+ mc_codec_map_t *codec_map;
+ int num_supported_codec = 0;
int i;
*support_type = 0;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
+ codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
+ num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
- const int codec_list = encoder ? (sizeof(encoder_map) / sizeof(encoder_map[0])) : (sizeof(decoder_map) / sizeof(decoder_map[0]));
-
- codec_map = encoder ? encoder_map : decoder_map;
-
-
- for(i = 0; i < codec_list; i++)
+ for (i = 0; i < num_supported_codec; i++)
{
- if(codec_type == codec_map[i].id)
+ if (codec_map[i].id == codec_type)
{
- if(codec_map[i].hardware)
- *support_type |=MEDIACODEC_SUPPORT_TYPE_HW;
+ if (codec_map[i].hardware)
+ *support_type |= MEDIACODEC_SUPPORT_TYPE_HW;
else
- *support_type |=MEDIACODEC_SUPPORT_TYPE_SW;
+ *support_type |= MEDIACODEC_SUPPORT_TYPE_SW;
+ break;
}
}
return ret;
}
-int mc_set_empty_buffer_cb(MMHandleType mediacodec, mediacodec_input_buffer_used_cb callback, void* user_data)
+int mc_set_empty_buffer_cb(MMHandleType mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- if(mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
- {
- LOGE("Already set mediacodec_empty_buffer_cb\n");
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
+ LOGE("Already set mediacodec_empty_buffer_cb");
return MC_PARAM_ERROR;
- }
- else
- {
- if (!callback)
- {
+ } else {
+ if (!callback) {
return MC_INVALID_ARG;
}
- LOGD("Set empty buffer callback(cb = %p, data = %p)\n", callback, user_data);
+ LOGD("Set empty buffer callback(cb = %p, data = %p)", callback, user_data);
mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = (mc_empty_buffer_cb) callback;
mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER] = user_data;
+
return MC_ERROR_NONE;
}
int mc_unset_empty_buffer_cb(MMHandleType mediacodec)
{
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
return MC_ERROR_NONE;
}
-int mc_set_fill_buffer_cb(MMHandleType mediacodec, mediacodec_output_buffer_available_cb callback, void* user_data)
+int mc_set_fill_buffer_cb(MMHandleType mediacodec, mediacodec_output_buffer_available_cb callback, void *user_data)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- if(mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER])
- {
- LOGE("Already set mediacodec_fill_buffer_cb\n");
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
+ LOGE("Already set mediacodec_fill_buffer_cb");
return MC_PARAM_ERROR;
- }
- else
- {
+ } else {
if (!callback) {
return MC_INVALID_ARG;
}
- LOGD("Set fill buffer callback(cb = %p, data = %p)\n", callback, user_data);
+ LOGD("Set fill buffer callback(cb = %p, data = %p)", callback, user_data);
mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = (mc_fill_buffer_cb) callback;
mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] = user_data;
int mc_unset_fill_buffer_cb(MMHandleType mediacodec)
{
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
return MC_ERROR_NONE;
}
-int mc_set_error_cb(MMHandleType mediacodec, mediacodec_error_cb callback, void* user_data)
+int mc_set_error_cb(MMHandleType mediacodec, mediacodec_error_cb callback, void *user_data)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- if(mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
- {
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
LOGE("Already set mediacodec_fill_buffer_cb\n");
return MC_PARAM_ERROR;
- }
- else
- {
+ } else {
if (!callback) {
return MC_INVALID_ARG;
}
int mc_unset_error_cb(MMHandleType mediacodec)
{
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
- LOGE("fail invaild param\n");
+ if (!mc_handle) {
+ LOGE("fail invaild param");
return MC_INVALID_ARG;
}
return MC_ERROR_NONE;
}
-int mc_set_eos_cb(MMHandleType mediacodec, mediacodec_eos_cb callback, void* user_data)
+int mc_set_eos_cb(MMHandleType mediacodec, mediacodec_eos_cb callback, void *user_data)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *) mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- if(mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS])
- {
- LOGE("Already set mediacodec_fill_buffer_cb\n");
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
+ LOGE("Already set mediacodec_fill_buffer_cb");
return MC_PARAM_ERROR;
- }
- else
- {
+ } else {
if (!callback) {
return MC_INVALID_ARG;
}
int mc_unset_eos_cb(MMHandleType mediacodec)
{
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
return MC_ERROR_NONE;
}
-int mc_set_buffer_status_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void* user_data)
+int mc_set_buffer_status_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void *user_data)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- if(mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
- {
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
LOGE("Already set mediacodec_need_data_cb\n");
return MC_PARAM_ERROR;
- }
- else
- {
+ } else {
if (!callback) {
return MC_INVALID_ARG;
}
int mc_unset_buffer_status_cb(MMHandleType mediacodec)
{
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
return MC_ERROR_NONE;
}
-int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void* user_data)
+int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- if(mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC])
- {
+ if (mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC]) {
LOGE("Already set mediacodec_supported_codec_cb\n");
return MC_PARAM_ERROR;
- }
- else
- {
+ } else {
if (!callback) {
return MC_INVALID_ARG;
}
- LOGD("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
+ LOGD("Set event handler callback(cb = %p, data = %p)", callback, user_data);
mc_handle->user_cb[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = (mc_supported_codec_cb) callback;
mc_handle->user_data[_MEDIACODEC_EVENT_TYPE_SUPPORTED_CODEC] = user_data;
return MC_ERROR_NONE;
}
- return MC_ERROR_NONE;
+ return ret;
}
-int _mediacodec_foreach_supported_codec(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void* user_data)
+int _mediacodec_foreach_supported_codec(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void *user_data)
{
int ret = MC_ERROR_NONE;
- mc_handle_t* mc_handle = (mc_handle_t*) mediacodec;
+ mc_handle_t *mc_handle = (mc_handle_t *)mediacodec;
int codecs_num;
gpointer tmp;
- if (!mc_handle)
- {
+ if (!mc_handle) {
LOGE("fail invaild param\n");
return MC_INVALID_ARG;
}
- if(mc_handle->supported_codecs)
- {
+ if (mc_handle->supported_codecs) {
codecs_num = g_list_length(mc_handle->supported_codecs);
LOGD("supported_codecs : %d", codecs_num);
- while(codecs_num)
- {
- tmp = g_list_nth_data(mc_handle->supported_codecs, codecs_num -1);
- if(tmp)
- {
- if(!callback(GPOINTER_TO_INT(tmp), user_data))
- {
+ while (codecs_num) {
+ tmp = g_list_nth_data(mc_handle->supported_codecs, codecs_num - 1);
+ if (tmp) {
+ if (!callback(GPOINTER_TO_INT(tmp), user_data)) {
ret = MEDIACODEC_ERROR_INTERNAL;
goto CALLBACK_ERROR;
}
codecs_num--;
}
- if(!callback(-1, user_data))
- {
+ if (!callback(-1, user_data)) {
ret = MEDIACODEC_ERROR_INTERNAL;
goto CALLBACK_ERROR;
}
int ret = MC_ERROR_NONE;
void *buf_data = NULL;
void *codec_data = NULL;
- int codec_data_size = 0;
+ unsigned int codec_data_size = 0;
uint64_t buf_size = 0;
bool eos = false;
bool codec_config = false;
LOGD("codec_data_size : %d, buf_size : %d, codec_config : %d, eos : %d",
codec_data_size, (int)buf_size, codec_config, eos);
- if ( codec_config ) {
- if ( codec_data_size == 0 )
- ret = _mc_check_bytestream (pkt, buf_data, (int)buf_size, NULL, NULL);
+ if (codec_config) {
+ if (codec_data_size == 0)
+ ret = _mc_check_h264_bytestream(buf_data, (int)buf_size, 0, NULL, NULL, NULL);
}
return ret;
int mc_sniff_mpeg4_bitstream(mc_handle_t *handle, media_packet_h pkt)
{
- int ret = MC_ERROR_NONE;
- return ret;
+ uint64_t buf_size = 0;
+ unsigned char *buf_data = NULL;
+ void *codec_data = NULL;
+ int codec_data_size = 0, voss_size = 0;
+ bool eos = false;
+ bool codec_config = false;
+ bool sync_frame = false;
+
+ media_packet_get_buffer_size(pkt, &buf_size);
+ media_packet_get_buffer_data_ptr(pkt, (void *)&buf_data);
+ media_packet_get_codec_data(pkt, &codec_data, &codec_data_size);
+ media_packet_is_end_of_stream(pkt, &eos);
+ media_packet_is_codec_config(pkt, &codec_config);
+ media_packet_is_sync_frame(pkt, &sync_frame);
+
+ LOGD("codec_data_size : %d, buff_size : %d, codec_config : %d, sync_frame : %d, eos : %d",
+ codec_data_size, (int)buf_size, codec_config, sync_frame, eos);
+
+ if (eos)
+ return MC_ERROR_NONE;
+
+ if (codec_config) {
+ if (codec_data) {
+ if (!_mc_is_voss(codec_data, codec_data_size, NULL))/*voss not in codec data */
+ return MC_INVALID_IN_BUF;
+ }
+ /* Codec data + I-frame in buffer */
+ if (_mc_is_voss(buf_data, buf_size, &voss_size)) {
+ if (_mc_is_ivop(buf_data, buf_size, voss_size)) /* IVOP after codec_data */
+ return MC_ERROR_NONE;
+ } else {
+ if (_mc_is_ivop(buf_data, buf_size, 0)) /* IVOP at the start */
+ return MC_ERROR_NONE;
+ }
+ } else if (_mc_is_vop(buf_data, buf_size, 0))
+ return MC_ERROR_NONE;
+
+ return MC_INVALID_IN_BUF;
}
int mc_sniff_h263_bitstream(mc_handle_t *handle, media_packet_h pkt)
{
- int ret = MC_ERROR_NONE;
- return ret;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
+ bool eos = false;
+
+ media_packet_get_buffer_size(pkt, &buf_size);
+ media_packet_get_buffer_data_ptr(pkt, &buf_data);
+ media_packet_is_end_of_stream(pkt, &eos);
+
+ if (eos)
+ return MC_ERROR_NONE;
+
+ return _mc_check_valid_h263_frame((unsigned char *)buf_data, (int)buf_size);
}
int mc_sniff_yuv(mc_handle_t *handle, media_packet_h pkt)
media_packet_get_buffer_size(pkt, &buf_size);
media_packet_get_video_number_of_planes(pkt, &plane_num);
- for ( index = 0; index < plane_num; index++) {
+ for (index = 0; index < plane_num; index++) {
media_packet_get_video_stride_width(pkt, index, &padded_width);
media_packet_get_video_stride_height(pkt, index, &padded_height);
allocated_buffer += padded_width * padded_height;
LOGD("%d plane size : %d", padded_width * padded_height);
}
- if ( buf_size > allocated_buffer ) {
+ if (buf_size > allocated_buffer) {
LOGE("Buffer exceeds maximum size [buf_size: %d, allocated_size :%d", (int)buf_size, allocated_buffer);
ret = MC_INVALID_IN_BUF;
}
#include <gst/gstelement.h>
#include <gst/app/gstappsrc.h>
-#ifdef Z130H
+#ifdef TIZEN_PROFILE_LITE
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/ion.h>
#endif
-#define GST_MC_EVENT_CODEC_DATA "GstEventCodecData"
+#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
/*
* Internal Implementation
*/
static gboolean __mc_gst_init_gstreamer();
static int _mc_output_media_packet_new(mc_gst_core_t *core, bool video, bool encoder, media_format_mimetype_e out_mime);
-static mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t* core, gchar *factory_name);
+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 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);
-static GstMCBuffer* _mc_gst_media_packet_to_gstbuffer(mc_gst_core_t* core, GstCaps **caps, media_packet_h pkt, bool codec_config);
+static void _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstCaps **caps, GstMCBuffer* buff, bool codec_config);
+static GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, GstCaps **caps, 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_gstbuffer_to_media_packet(mc_gst_core_t* core, GstBuffer* buffer);
+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);
static gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data);
-static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus * bus, GstMessage *msg, gpointer data);
-static MMVideoBuffer* __mc_gst_make_tbm_buffer(mc_gst_core_t* core, media_packet_h pkt);
-static GstPadProbeReturn event_probe_cb(GstObject *pad, GstPadProbeInfo *info, gpointer user_data);
-static GType __mc_gst_buffer_get_type(void);
-static void __mc_gst_buffer_class_init(gpointer g_class, gpointer class_data);
+static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data);
+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 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 );
-static gint __gst_handle_resource_error(mc_gst_core_t* core, int code );
-static gint __gst_handle_library_error(mc_gst_core_t* core, int code);
-static gint __gst_handle_core_error(mc_gst_core_t* core, int code );
+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);
+static gint __gst_handle_resource_error(mc_gst_core_t *core, int code);
+static gint __gst_handle_library_error(mc_gst_core_t *core, int code);
+static gint __gst_handle_core_error(mc_gst_core_t *core, int code);
static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboolean is_encoder, gboolean is_hw);
-#ifdef Z130H
-static int __tbm_get_physical_addr_bo(tbm_bo_handle tbm_bo_handle_fd_t, int* phy_addr, int* phy_size);
+#ifdef TIZEN_PROFILE_LITE
+static int __tbm_get_physical_addr_bo(tbm_bo_handle tbm_bo_handle_fd_t, int *phy_addr, int *phy_size);
#endif
-static void _mc_gst_flush_buffers( mc_gst_core_t *core );
+static void _mc_gst_flush_buffers(mc_gst_core_t *core);
static void _mc_gst_set_flush_input(mc_gst_core_t *core);
static void _mc_gst_set_flush_output(mc_gst_core_t *core);
unsigned char *nv12t_src, int yuv420_width, int yuv420_height,
int left, int top, int right, int buttom);
-/*for test */
-static int count;
-static int input_count;
-#define GST_TYPE_MC_BUFFER (__mc_gst_buffer_get_type())
-
-/* SPRD Decoder */
-int(*vdec_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_outbuf_with_packet, &__mc_vdec_caps};
-#ifdef Z130H
-/* SPRD H.264 Decoder */
-int(*vdec_h264_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_packet_with_mm_video_buffer, &__mc_sprddec_caps};
-/* SPRD H.264 Encoder */
-int(*venc_vtable[])() = {&__mc_fill_inbuf_with_bo, &__mc_fill_outbuf_with_packet, &__mc_sprdenc_caps};
-#else
-/* M0 H.264 Decoder */
-int(*vdec_h264_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_packet_with_mm_video_buffer, &__mc_h264dec_caps};
-/* M0 H.264 Encoder */
-int(*venc_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_outbuf_with_h264_packet, &__mc_venc_caps};
-#endif
-/* AAC_LC Encoder */
-int(*aenc_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_outbuf_with_packet, &__mc_aenc_caps};
-/* AAC_LC Deocder */
-int(*adec_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_outbuf_with_packet, &__mc_adec_caps};
-int(*adec_aacv12_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_outbuf_with_packet, &__mc_adec_aacv12_caps};
-/* MP3 Deocder */
-int(*adec_mp3_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_outbuf_with_packet, &__mc_adec_mp3_caps};
-/* AMR-NB Deocder */
-int(*adec_amrnb_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_outbuf_with_packet, &__mc_adec_amrnb_caps};
-/* AMR-WB Deocder */
-int(*adec_amrwb_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_outbuf_with_packet, &__mc_adec_amrwb_caps};
-/* AMR-NB Deocder */
-int(*aenc_amrnb_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_outbuf_with_packet, &__mc_aenc_amrnb_caps};
+static void _mc_send_eos_signal(mc_gst_core_t *core);
+static void _mc_wait_for_eos(mc_gst_core_t *core);
+
+/* video vtable */
+int(*vdec_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_vdec_packet_with_outbuf, &__mc_vdec_caps};
+int(*venc_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_venc_packet_with_outbuf, &__mc_venc_caps};
+
+
+int(*vdec_h264_sw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* FFMPEG H.264 Decoder Vtable */
+ &__mc_fill_vdec_packet_with_outbuf,
+ &__mc_vdec_caps};
+int(*vdec_h264_hw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* SPRD H.264 Decoder Vtable */
+ &__mc_fill_video_packet_with_mm_video_buffer,
+ &__mc_h264dec_caps};
+int(*venc_h264_hw_vtable[])() = {&__mc_fill_inbuf_with_mm_video_buffer, /* SPRD H.264 Encoder Vtable */
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_venc_caps};
+int(*vdec_mpeg4_sw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* FFMPEG MPEG4 Decoder Vtable */
+ &__mc_fill_vdec_packet_with_outbuf,
+ &__mc_vdec_mpeg4_caps};
+int(*vdec_mpeg4_hw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* SPRD MPEG4 Decoder Vtable */
+ &__mc_fill_video_packet_with_mm_video_buffer,
+ &__mc_sprddec_mpeg4_caps};
+int(*venc_mpeg4_sw_vtable[])() = {&__mc_fill_inbuf_with_venc_packet, /* SPRD MPEG4 Encoder Vtable */
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_venc_caps};
+int(*venc_mpeg4_hw_vtable[])() = {&__mc_fill_inbuf_with_mm_video_buffer, /* SPRD MPEG4 Encoder Vtable */
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_sprdenc_mpeg4_caps};
+int(*vdec_h263_sw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* FFMPEG MPEG4 Decoder Vtable */
+ &__mc_fill_vdec_packet_with_outbuf,
+ &__mc_vdec_h263_caps};
+int(*vdec_h263_hw_vtable[])() = {&__mc_fill_inbuf_with_packet, /* SPRD MPEG4 Decoder Vtable */
+ &__mc_fill_video_packet_with_mm_video_buffer,
+ &__mc_sprddec_mpeg4_caps};
+int(*venc_h263_sw_vtable[])() = {&__mc_fill_inbuf_with_venc_packet, /* SPRD MPEG4 Encoder Vtable */
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_venc_caps};
+int(*venc_h263_hw_vtable[])() = {&__mc_fill_inbuf_with_mm_video_buffer, /* SPRD MPEG4 Encoder Vtable */
+ &__mc_fill_venc_packet_with_outbuf,
+ &__mc_sprdenc_mpeg4_caps};
+
+/* audio vtable */
+int(*aenc_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_packet_with_outbuf, &__mc_aenc_caps};
+int(*adec_vtable[])() = {&__mc_fill_inbuf_with_packet, &__mc_fill_packet_with_outbuf, &__mc_adec_caps};
+
+int(*aenc_aac_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AAC LC Encoder vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_aenc_aac_caps};
+int(*adec_aac_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AAC LC Decoder Vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_aac_caps};
+int(*adec_aacv12_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AAC HE Decoder Vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_aacv12_caps};
+int(*adec_mp3_vtable[])() = {&__mc_fill_inbuf_with_packet, /* MP3 Decoder Vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_mp3_caps};
+int(*adec_amrnb_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AMR-NB Decoder Vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_amrnb_caps};
+int(*adec_amrwb_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AMR-WB Decoder Vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_amrwb_caps};
+int(*aenc_amrnb_vtable[])() = {&__mc_fill_inbuf_with_packet, /* AMR-NB Encoder Vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_aenc_amrnb_caps};
+int(*adec_vorbis_vtable[])() = {&__mc_fill_inbuf_with_packet, /* VORBIS Decoder Vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_vorbis_caps};
+int(*adec_flac_vtable[])() = {&__mc_fill_inbuf_with_packet, /* FLAC Decoder Vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_flac_caps};
+int(*adec_wma_vtable[])() = {&__mc_fill_inbuf_with_packet, /* WMA Decoder Vtable */
+ &__mc_fill_packet_with_outbuf,
+ &__mc_adec_wma_caps};
/*
- * mc_gst_object functions
+ * fill_inbuf virtual functions
*/
-int __mc_fill_input_buffer(mc_gst_core_t *core, void *buf_data, int buf_size, GstMCBuffer *buff)
+int __mc_fill_input_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff)
{
- return core->vtable[fill_inbuf](core, buf_data, buf_size, buff);
+ return core->vtable[fill_inbuf](core, pkt, buff);
}
-int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
-{
- return core->vtable[fill_outbuf](core, data, size, out_pkt);
-}
-
-int __mc_create_caps(mc_gst_core_t *core, GstCaps **caps)
-{
- return core->vtable[create_caps](core, caps);
-}
-
-int __mc_fill_inbuf_with_bo(mc_gst_core_t *core, void *buf_data, int buf_size, GstMCBuffer *mc_buffer)
+int __mc_fill_inbuf_with_mm_video_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer)
{
int ret = MC_ERROR_NONE;
- MMVideoBuffer *imgb = NULL;
- guint n;
+ MMVideoBuffer *mm_vbuffer = NULL;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
- mc_buffer->has_imgb = true;
+ ret = media_packet_get_buffer_size(pkt, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return MC_ERROR;
+ }
+ ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return MC_ERROR;
+ }
- imgb = __mc_gst_make_tbm_buffer(core, mc_buffer->pkt);
+ mm_vbuffer = __mc_gst_make_tbm_buffer(core, mc_buffer->pkt);
- if( imgb != NULL ) {
+ if (mm_vbuffer != NULL) {
gst_buffer_prepend_memory(mc_buffer->buffer,
- gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, imgb, sizeof(*imgb), 0,
- sizeof(*imgb), mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
- LOGD("scmn_imgb is appended, %d, %d", sizeof(*imgb), gst_buffer_n_memory(mc_buffer->buffer));
+ gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, mm_vbuffer, sizeof(*mm_vbuffer), 0,
+ sizeof(*mm_vbuffer), mm_vbuffer, free));
+ LOGD("scmn_mm_vbuffer is appended, %d, %d", sizeof(*mm_vbuffer), gst_buffer_n_memory(mc_buffer->buffer));
}
- if( buf_data != NULL) {
+ if (buf_data != NULL) {
gst_buffer_prepend_memory(mc_buffer->buffer,
gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0,
buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
return ret;
}
-int __mc_fill_inbuf_with_packet(mc_gst_core_t *core, void *buf_data, int buf_size, GstMCBuffer *mc_buffer)
+int __mc_fill_inbuf_with_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer)
{
int ret = MC_ERROR_NONE;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
- mc_buffer->has_imgb = false;
+ ret = media_packet_get_buffer_size(pkt, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return MC_ERROR;
+ }
- if( buf_data != NULL) {
+ ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return MC_ERROR;
+ }
+
+ if (buf_data != NULL) {
gst_buffer_append_memory(mc_buffer->buffer,
gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0,
buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
return ret;
}
-int __mc_fill_outbuf_with_bo(mc_gst_core_t *core, void *data, int size, media_packet_h* out_pkt)
+int __mc_fill_inbuf_with_venc_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer)
{
- int i = 0;;
- int bo_num = 0;
+ int ret = MC_ERROR_NONE;
+ void *uv_ptr = NULL;
+ void *y_ptr = NULL;
+ int buf_size = 0;
+ int stride_width;
+ int stride_height;
+ int width;
+ int height;
+ uint32_t plane_num;
+ int i;
+ int j;
+ int stride = 0;
+
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
+
+ width = enc_info->width;
+ height = enc_info->height;
+
+ ret = media_packet_get_number_of_video_planes(pkt, &plane_num);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_get_number_of_video_planes failed");
+ return MC_ERROR;
+ }
+
+ ret = media_packet_get_video_plane_data_ptr(pkt, 0, &y_ptr);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_get_video_plane_data_ptr failed");
+ return MC_ERROR;
+ }
+
+ ret = media_packet_get_video_stride_width(pkt, 0, &stride_width);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_get_video_stride_width failed");
+ return MC_ERROR;
+ }
+
+ ret = media_packet_get_video_stride_height(pkt, 0, &stride_height);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_get_video_stride_width failed");
+ return MC_ERROR;
+ }
+
+ if (width == stride_width) {
+ mc_buffer->buf_size += stride_width * stride_height;
+
+ for (i = 1; i < plane_num; i++) {
+ media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr);
+ media_packet_get_video_stride_width(pkt, i, &stride_width);
+ media_packet_get_video_stride_height(pkt, i, &stride_height);
+
+ buf_size = stride_width * stride_height;
+
+ memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size);
+ LOGD("width is same with stride");
+ LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size);
+ mc_buffer->buf_size += buf_size;
+
+ }
+ } else {
+
+ for (j = 0; j < height; j++) {
+ memcpy(y_ptr + mc_buffer->buf_size, y_ptr + stride, width);
+ mc_buffer->buf_size += width;
+ stride += stride_width;
+ }
+
+ stride = 0;
+
+ for (i = 1; i < plane_num; i++) {
+ media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr);
+ media_packet_get_video_stride_width(pkt, i, &stride_width);
+ media_packet_get_video_stride_height(pkt, i, &stride_height);
+
+ for (j = 0; j < height>>1; j++) {
+ memcpy(y_ptr + mc_buffer->buf_size, uv_ptr + stride, width>>1);
+ mc_buffer->buf_size += width>>1;
+ stride += stride_width;
+ }
+
+ memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size);
+ LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size);
+ mc_buffer->buf_size += buf_size;
+ }
+ }
+
+ if (y_ptr != NULL) {
+ gst_buffer_append_memory(mc_buffer->buffer,
+ gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, y_ptr, mc_buffer->buf_size, 0,
+ mc_buffer->buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize));
+ LOGD("%d plane data apended : width : %d, height : %d, size : %d",
+ i, stride_width, stride_height, mc_buffer->buf_size);
+ }
+
+ return ret;
+}
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
- MMVideoBuffer *imgb = NULL;
+/*
+ * fill_outbuf virtual functions
+*/
+
+int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
+{
+ return core->vtable[fill_outbuf](core, data, size, out_pkt);
+}
+
+int __mc_fill_vdec_packet_with_outbuf(mc_gst_core_t *core, void *data, int size, media_packet_h *pkt)
+{
+ int i;
+ int stride_width;
+ int stride_height;
+ uint32_t width;
+ uint32_t height;
+ uint32_t plane_num;
+ uint32_t buf_size;
+ uint32_t plane_size;
+ int ret = MC_ERROR_NONE;
+ void *pkt_data = NULL;
tbm_surface_h tsurf = NULL;
- mc_decoder_info_t *codec_info = (mc_decoder_info_t *)core->codec_info;
-#ifdef TBM_API_CHANGE
tbm_surface_info_s tsurf_info;
+ tbm_bo bo[MM_VIDEO_BUFFER_PLANE_MAX];
+ tbm_bo_handle thandle;
+
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
+
+ mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info;
+
+ width = dec_info->width;
+ height = dec_info->height;
+ stride_width = ALIGN(width, 4);
+ stride_height = ALIGN(height, 4);
+ buf_size = stride_width * stride_height * 3 / 2;
+
+ if (buf_size > size)
+ return MC_ERROR;
+
memset(&tsurf_info, 0x0, sizeof(tbm_surface_info_s));
-#endif
- /* create tbm surface */
- for (i = 0; i < MM_VIDEO_BUFFER_PLANE_MAX; i++)
- {
- if (imgb->handle.bo[i])
- {
- bo_num++;
-#ifdef TBM_API_CHANGE
- tsurf_info.planes[i].stride = imgb->stride_width[i];
-#endif
+ bo[0] = tbm_bo_alloc(core->bufmgr, buf_size, TBM_BO_WC);
+ if (!bo[0]) {
+ LOGE("bo allocation failed");
+ }
+
+ tsurf_info.width = dec_info->width;
+ tsurf_info.height = dec_info->height;
+ tsurf_info.format = TBM_FORMAT_YVU420;
+ tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_YVU420);
+ tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_YVU420);
+ tsurf_info.size = 0;
+
+ for (i = 0; i < tsurf_info.num_planes; i++) {
+ if (i == 0) {
+ tsurf_info.planes[i].stride = stride_width;
+ tsurf_info.planes[i].size = stride_width * stride_height;
+ tsurf_info.planes[i].offset = 0;
+ tsurf_info.size = tsurf_info.planes[i].size;
+ } else {
+ tsurf_info.planes[i].stride = stride_width>>1;
+ tsurf_info.planes[i].size = (stride_width>>1) * (stride_height>>1);
+ tsurf_info.planes[i].offset = (tsurf_info.planes[i-1].offset + tsurf_info.planes[i - 1].size);
+ tsurf_info.size += tsurf_info.planes[i].size;
}
}
- if (bo_num > 0)
- {
-#ifdef TBM_API_CHANGE
- tsurf_info.width = codec_info->width;
- tsurf_info.height = codec_info->height;
- tsurf_info.format = TBM_FORMAT_NV12; // bo_format
- tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV12);
- tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_NV12);
- tsurf_info.size = 0;
- for(i = 0; i < tsurf_info.num_planes; i++) {
- tsurf_info.planes[i].stride = imgb->stride_width[i];
- tsurf_info.planes[i].size = imgb->stride_width[i] * imgb->stride_height[i];
- if(i < bo_num)
- tsurf_info.planes[i].offset = 0;
- else
- tsurf_info.planes[i].offset = tsurf_info.planes[i - 1].size;
- tsurf_info.size += tsurf_info.planes[i].size;
- }
+ thandle = tbm_bo_map(bo[0], TBM_DEVICE_CPU, TBM_OPTION_WRITE);
+ memcpy(thandle.ptr, data, tsurf_info.size);
+ tbm_bo_unmap(bo[0]);
- tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, (tbm_bo *)imgb->handle.bo, bo_num);
- LOGD("[NEW API] tbm surface %p", tsurf);
-#else
- tsurf = tbm_surface_internal_create_with_bos(codec_info->width, codec_info->height, TBM_FORMAT_NV12, (tbm_bo *)imgb->handle.bo, bo_num);
- LOGD("[OLD API] tbm surface %p", tsurf);
-#endif
+ tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, bo, 1);
+
+ if (tsurf) {
+ media_packet_create_from_tbm_surface(core->output_fmt, tsurf,
+ (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, pkt);
}
- if (tsurf)
- {
- media_packet_create_from_tbm_surface(core->output_fmt, tsurf, (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, out_pkt);
- LOGD("!!!! create_gst_buffer = %p", *out_pkt);
+ ret = media_packet_get_number_of_video_planes(*pkt, &plane_num);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_get_number_of_video_planes failed");
+ return MC_ERROR;
}
return MC_ERROR_NONE;
}
-
-int __mc_fill_packet_with_mm_video_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
+int __mc_fill_video_packet_with_mm_video_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
{
- void* pkt_data = NULL;
- MMVideoBuffer *imgb = NULL;
- GstMapInfo map = GST_MAP_INFO_INIT;
+ void *pkt_data = NULL;
+ MMVideoBuffer *mm_vbuffer = NULL;
int i;
int bo_num = 0;
- mc_decoder_info_t *codec_info = (mc_decoder_info_t *)core->codec_info;
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- imgb = (MMVideoBuffer *)data;
+ mc_decoder_info_t *codec_info = (mc_decoder_info_t *)core->codec_info;
+ mm_vbuffer = (MMVideoBuffer *)data;
- LOGD("buf_share_method %d", imgb->type);
+ LOGD("buf_share_method %d", mm_vbuffer->type);
LOGD("a[0] : %p, a[1] : %p, p[0] : %p, p[1] : %p",
- imgb->data[0], imgb->data[1], imgb->handle.paddr[0], imgb->handle.paddr[1]);
+ mm_vbuffer->data[0], mm_vbuffer->data[1], mm_vbuffer->handle.paddr[0], mm_vbuffer->handle.paddr[1]);
LOGD("s[0]:%d, e[0]:%d, w[0]:%d, h[0]:%d",
- imgb->stride_width[0],imgb->stride_height[0],imgb->width[0], imgb->height[0]);
-
- media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
+ mm_vbuffer->stride_width[0], mm_vbuffer->stride_height[0], mm_vbuffer->width[0], mm_vbuffer->height[0]);
- if ( imgb->type == MM_VIDEO_BUFFER_TYPE_PHYSICAL_ADDRESS ) {
- media_packet_set_buffer_size(*out_pkt, imgb->width[0]*imgb->height[0]*3/2);
+ if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_PHYSICAL_ADDRESS) {
+ media_packet_set_buffer_size(*out_pkt, mm_vbuffer->width[0]*mm_vbuffer->height[0]*3/2);
media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
- __csc_tiled_to_linear_crop(pkt_data, imgb->data[0],
- imgb->stride_width[0], imgb->stride_height[0], 0,0,0,0);
- __csc_tiled_to_linear_crop(pkt_data+imgb->stride_width[0]*imgb->stride_height[0],
- imgb->data[1], imgb->stride_width[0], imgb->stride_height[0]/2, 0,0,0,0);
- }
- else if ( imgb->type == MM_VIDEO_BUFFER_TYPE_DMABUF_FD ) {
+ __csc_tiled_to_linear_crop(pkt_data, mm_vbuffer->data[0],
+ mm_vbuffer->stride_width[0], mm_vbuffer->stride_height[0], 0, 0, 0, 0);
+ __csc_tiled_to_linear_crop(pkt_data+mm_vbuffer->stride_width[0]*mm_vbuffer->stride_height[0],
+ mm_vbuffer->data[1], mm_vbuffer->stride_width[0], mm_vbuffer->stride_height[0]/2, 0, 0, 0, 0);
+ } else if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_DMABUF_FD) {
LOGD("FD type");
- }
- else if ( imgb->type == MM_VIDEO_BUFFER_TYPE_TBM_BO ) {
+ } else if (mm_vbuffer->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) {
tbm_surface_h tsurf = NULL;
-
-#ifdef TBM_API_CHANGE
tbm_surface_info_s tsurf_info;
memset(&tsurf_info, 0x0, sizeof(tbm_surface_info_s));
-#endif
/* create tbm surface */
for (i = 0; i < MM_VIDEO_BUFFER_PLANE_MAX; i++) {
- if (imgb->handle.bo[i]) {
+ if (mm_vbuffer->handle.bo[i]) {
bo_num++;
-#ifdef TBM_API_CHANGE
- tsurf_info.planes[i].stride = imgb->stride_width[i];
-#endif
+ tsurf_info.planes[i].stride = mm_vbuffer->stride_width[i];
}
}
- if ( bo_num > 0 ) {
-#ifdef TBM_API_CHANGE
+ if (bo_num > 0) {
tsurf_info.width = codec_info->width;
tsurf_info.height = codec_info->height;
- tsurf_info.format = TBM_FORMAT_NV12; // bo_format
+ tsurf_info.format = TBM_FORMAT_NV12; /* bo_format */
tsurf_info.bpp = tbm_surface_internal_get_bpp(TBM_FORMAT_NV12);
tsurf_info.num_planes = tbm_surface_internal_get_num_planes(TBM_FORMAT_NV12);
tsurf_info.size = 0;
- for ( i = 0; i < tsurf_info.num_planes; i++ ) {
- tsurf_info.planes[i].stride = imgb->stride_width[i];
- tsurf_info.planes[i].size = imgb->stride_width[i] * imgb->stride_height[i];
+ for (i = 0; i < tsurf_info.num_planes; i++) {
+ tsurf_info.planes[i].stride = mm_vbuffer->stride_width[i];
+ tsurf_info.planes[i].size = mm_vbuffer->stride_width[i] * mm_vbuffer->stride_height[i];
- if ( i < bo_num )
+ if (i < bo_num)
tsurf_info.planes[i].offset = 0;
else
- tsurf_info.planes[i].offset = tsurf_info.planes[i - 1].size;
+ tsurf_info.planes[i].offset = tsurf_info.planes[i-1].offset + tsurf_info.planes[i - 1].size;
tsurf_info.size += tsurf_info.planes[i].size;
}
-
- tsurf = tbm_surface_internal_create_with_bos ( &tsurf_info, (tbm_bo *)imgb->handle.bo, bo_num );
- LOGD("[NEW API] tbm surface %p", tsurf);
-#else
- tsurf = tbm_surface_internal_create_with_bos ( codec_info->width, codec_info->height,
- TBM_FORMAT_NV12, (tbm_bo *)imgb->handle.bo, bo_num );
- LOGD ( "[OLD API] tbm surface %p", tsurf );
-#endif
+ LOGD("%d plane stride : %d, size : %d",tsurf_info.planes[i].stride, tsurf_info.planes[i].size);
+ tsurf = tbm_surface_internal_create_with_bos(&tsurf_info, (tbm_bo *)mm_vbuffer->handle.bo, bo_num);
}
- if ( tsurf ) {
- media_packet_create_from_tbm_surface ( core->output_fmt, tsurf,
- ( media_packet_finalize_cb )__mc_output_buffer_finalize_cb, core, out_pkt );
+ if (tsurf) {
+ media_packet_create_from_tbm_surface(core->output_fmt, tsurf,
+ (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, out_pkt);
}
}
-DONE:
-
return MC_ERROR_NONE;
}
-int __mc_fill_outbuf_with_packet(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
+int __mc_fill_packet_with_outbuf(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
{
- void* pkt_data = NULL;
-
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
-
+ void *pkt_data = NULL;
+ int ret = MC_ERROR_NONE;
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
+ ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_create_alloc failed");
+ return MC_ERROR;
+ }
media_packet_set_buffer_size(*out_pkt, size);
media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
return MC_ERROR_NONE;
}
-int __mc_fill_outbuf_with_h264_packet(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
+int __mc_fill_venc_packet_with_outbuf(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt)
{
- void* pkt_data = NULL;
- int mask = 0xfffffff0;
+ void *pkt_data = NULL;
+ bool codec_config = FALSE;
+ bool sync_flag = FALSE;
+ bool slice = FALSE;
+ int codec_data_size = 0;
+ int ret = MC_ERROR_NONE;
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- if ( (core->out_mime & mask) == MEDIA_FORMAT_H264_SP)
- {
- _mc_check_out_bytestream(core, (unsigned char*)data, size);
+ switch (core->out_mime) {
+ case MEDIA_FORMAT_H264_SP:
+ case MEDIA_FORMAT_H264_MP:
+ case MEDIA_FORMAT_H264_HP:
+ ret = _mc_check_h264_bytestream((unsigned char *)data, size, 1, &codec_config, &sync_flag, &slice);
+ break;
+ case MEDIA_FORMAT_MPEG4_SP:
+ case MEDIA_FORMAT_MPEG4_ASP:
+ codec_data_size = _mc_check_mpeg4_out_bytestream((unsigned char *)data, size, &codec_config, &sync_flag);
+ break;
+ case MEDIA_FORMAT_H263:
+ case MEDIA_FORMAT_H263P:
+ if (!_mc_check_h263_out_bytestream((unsigned char *)data, size, &sync_flag))
+ return MC_INVALID_IN_BUF;
+ break;
+ default:
+ return MC_INVALID_IN_BUF;
}
+ LOGD("codec_config : %d, sync_flag : %d, slice : %d", codec_config, sync_flag, slice);
- if ( core->sps_size > 0 && core->pps_size > 0 ) {
+ ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("media_packet_create_alloc failed");
+ return MC_ERROR;
+ }
- media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt);
- media_packet_set_buffer_size(*out_pkt, size);
- media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
- memcpy(pkt_data, data, size);
+ media_packet_set_buffer_size(*out_pkt, size);
+ media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data);
+ memcpy(pkt_data, data, size);
- if ( core->need_codec_data ) {
- media_packet_set_codec_data(*out_pkt, core->codec_data, core->codec_data_size);
- }
+ core->need_sync_flag = sync_flag ? 1 : 0;
+ core->need_codec_data = codec_config ? 1 : 0;
- }
+ return ret;
+}
- return MC_ERROR_NONE;
+/*
+ * 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)
+int __mc_venc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t*)core->codec_info;
+ 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, "I420",
- "width", G_TYPE_INT, enc_info->width,
- "height", G_TYPE_INT, enc_info->height,
- "framerate", GST_TYPE_FRACTION, enc_info->fps, 1,
- NULL);
+ "format", G_TYPE_STRING, "I420",
+ "width", G_TYPE_INT, enc_info->width,
+ "height", G_TYPE_INT, enc_info->height,
+ "framerate", GST_TYPE_FRACTION, enc_info->fps, 1,
+ NULL);
LOGD("%d, %d, %d", enc_info->width, enc_info->height, enc_info->fps);
return MC_ERROR_NONE;
}
-int __mc_sprdenc_caps(mc_gst_core_t *core, GstCaps **caps)
+int __mc_sprdenc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t*)core->codec_info;
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
*caps = gst_caps_new_simple(core->mime,
"format", G_TYPE_STRING, "SN12",
"height", G_TYPE_INT, enc_info->height,
"framerate", GST_TYPE_FRACTION, enc_info->fps, 1, NULL);
- g_object_set (GST_OBJECT(core->codec), "byte-stream", TRUE, NULL);
- g_object_set (GST_OBJECT(core->codec), "bitrate", enc_info->bitrate*1000, NULL);
+ g_object_set(GST_OBJECT(core->codec), "byte-stream", TRUE, NULL);
+ g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate*1000, NULL);
LOGD("%s, %d, %d, %d", core->format, enc_info->width, enc_info->height, enc_info->fps);
return MC_ERROR_NONE;
}
-int __mc_h264dec_caps(mc_gst_core_t *core, GstCaps **caps)
+int __mc_sprdenc_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ 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, "SN12",
+ "width", G_TYPE_INT, enc_info->width,
+ "height", G_TYPE_INT, enc_info->height,
+ "framerate", GST_TYPE_FRACTION, enc_info->fps, 1, NULL);
+
+ g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate*1000, NULL);
+
+ LOGD("%s, %d, %d, %d", core->format, enc_info->width, enc_info->height, enc_info->fps);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t*)core->codec_info;
+
+ return MC_ERROR_NONE;
+}
+
+int __mc_h264dec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool 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,
- "parsed", G_TYPE_BOOLEAN, TRUE,
- "alignment", G_TYPE_STRING, "au",
- "stream-format", G_TYPE_STRING, "byte-stream",
- "width", G_TYPE_INT, dec_info->width,
- "height", G_TYPE_INT, dec_info->height, NULL);
+ "parsed", G_TYPE_BOOLEAN, TRUE,
+ "alignment", G_TYPE_STRING, "au",
+ "stream-format", G_TYPE_STRING, "byte-stream",
+ "width", G_TYPE_INT, dec_info->width,
+ "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_sprddec_caps(mc_gst_core_t *core, GstCaps **caps)
+int __mc_sprddec_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t*)core->codec_info;
+ 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_sprddec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool 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,
return MC_ERROR_NONE;
}
-int __mc_vdec_caps(mc_gst_core_t *core, GstCaps **caps)
+int __mc_vdec_h263_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool 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,
+ "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_mpeg4_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool 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, 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, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t*)core->codec_info;
+ 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);
+ "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_aenc_caps(mc_gst_core_t *core, GstCaps **caps)
+int __mc_vdec_h264_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t*)core->codec_info;
+ 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_aenc_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool 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);
+ "layout", G_TYPE_STRING, "interleaved", NULL);
/*
+----GstAudioEncoder
(-1): unofficial - Allow unofficial extensions
(-2): experimental - Allow nonstandardized experimental things
*/
- g_object_set (GST_OBJECT(core->codec), "compliance", -2, NULL);
+ 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, bool 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);
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)
+int __mc_aenc_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_encoder_info_t *enc_info = (mc_encoder_info_t*)core->codec_info;
+ 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,
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)
+int __mc_adec_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ 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;
+ 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,
"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 MC_ERROR_NONE;
+
+ return ret;
}
-int __mc_adec_aacv12_caps(mc_gst_core_t *core, GstCaps **caps)
+int __mc_adec_aac_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ 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;
+ 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, bool 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
+ "mpegversion", G_TYPE_INT, 4, /*TODO : need adding version /profile*/
"framed", G_TYPE_BOOLEAN, TRUE,
"stream-format", G_TYPE_STRING, "raw",
- "rate", G_TYPE_INT, dec_info->samplerate,
"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 MC_ERROR_NONE;
+ return ret;
}
-int __mc_adec_mp3_caps(mc_gst_core_t *core, GstCaps **caps)
+int __mc_adec_mp3_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t*)core->codec_info;
+ 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,
return MC_ERROR_NONE;
}
-int __mc_adec_amrnb_caps(mc_gst_core_t *core, GstCaps **caps)
+int __mc_adec_amrnb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t*)core->codec_info;
+ 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,
return MC_ERROR_NONE;
}
-int __mc_adec_amrwb_caps(mc_gst_core_t *core, GstCaps **caps)
+int __mc_adec_amrwb_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool codec_config)
{
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- mc_decoder_info_t *dec_info = (mc_decoder_info_t*)core->codec_info;
+ 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,
return MC_ERROR_NONE;
}
+int __mc_adec_vorbis_caps(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, bool 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, bool 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, bool 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_WMAPRO) {
+ 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;
+}
+
+/**
+ * _gst_caps_set_buffer_array:
+ * @caps: a #GstCaps
+ * @field: field in caps to set
+ * @buf: header buffers
+ *
+ * Adds given buffers to an array of buffers set as the given @field
+ * on the given @caps. List of buffer arguments must be NULL-terminated.
+ *
+ * Returns: input caps with a streamheader field added, or NULL if some error
+ */
+static GstCaps *__mc_gst_caps_set_buffer_array(GstCaps * caps, const gchar * field, GstBuffer * buf, ...)
+{
+ GstStructure *structure = NULL;
+ va_list va;
+ GValue array = { 0 };
+ GValue value = { 0 };
+
+ g_return_val_if_fail(caps != NULL, NULL);
+ g_return_val_if_fail(gst_caps_is_fixed(caps), NULL);
+ g_return_val_if_fail(field != NULL, NULL);
+
+ caps = gst_caps_make_writable(caps);
+ structure = gst_caps_get_structure(caps, 0);
+
+ g_value_init(&array, GST_TYPE_ARRAY);
+
+ va_start(va, buf);
+ /* put buffers in a fixed list */
+ while (buf) {
+ g_value_init(&value, GST_TYPE_BUFFER);
+ gst_value_set_buffer(&value, buf);
+ gst_value_array_append_value(&array, &value);
+ g_value_unset(&value);
+
+ buf = va_arg(va, GstBuffer *);
+ }
+ va_end(va);
+
+ gst_structure_take_value(structure, field, &array);
+
+ return caps;
+}
+
+
+int __mc_set_caps_streamheader(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer*buff, guint streamheader_size)
+{
+ int ret = MEDIA_PACKET_ERROR_NONE;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
+ GstBuffer *header1, *header2, *header3;
+ guint hsize1, hsize2, hsize3;
+ GstBuffer *tmp_header;
+ guint8 *tmp_buf = NULL;
+ GstMapInfo map;
+
+ ret = media_packet_get_buffer_size(buff->pkt, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return ret;
+ }
+
+ ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return ret;
+ }
+
+ LOGD("Set caps for streamheader in mime : %s and codec_id (0x%x)", core->mime, core->codec_id);
+
+ if (core->codec_id == MEDIACODEC_VORBIS) {
+ /*
+ * hsize1 : Identification Header (packet type 1) - fixed 30 byte
+ * hsize2 : Comment Header (packet type 3) - variable byte (need calculate)
+ * hsize3 : Setup Header (packet type 5) - variable byte (Used remained bytes)
+ */
+
+ /* First of all, Need to fins and calculate size of hsize2 */
+ tmp_header = gst_buffer_new_and_alloc(streamheader_size);
+ gst_buffer_fill(tmp_header, 0, buf_data, streamheader_size);
+ gst_buffer_map(tmp_header, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ tmp_buf += (30 + 7); /* hsize1 + '0x03' + 'vorbis'*/
+ hsize2 = (7 + 4);
+ hsize2 += GST_READ_UINT32_LE(tmp_buf);
+ hsize2 += (4 + 1);
+ LOGD("Find streamheader hsize2(%d)", hsize2);
+ gst_buffer_unmap(tmp_header, &map);
+ gst_buffer_unref(tmp_header);
+
+ /* hsize1 : Identification Header (packet type 1) - fixed 30 byte */
+ hsize1 = 30;
+ header1 = gst_buffer_new_and_alloc(hsize1);
+ gst_buffer_fill(header1, 0, buf_data, hsize1);
+ gst_buffer_map(header1, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x01' + 'vorbis' */
+ if (*tmp_buf != 0x01) {
+ LOGE("[ERROR] Invalid Caps of Stream header1");
+ gst_buffer_unmap(header1, &map);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ gst_buffer_unmap(header1, &map);
+
+ /* hsize2 : Comment Header (packet type 3) - variable byte */
+ header2 = gst_buffer_new_and_alloc(hsize2);
+ gst_buffer_fill(header2, 0, (buf_data + (hsize1)), hsize2);
+ gst_buffer_map(header2, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x03' + 'vorbis' */
+ if (*tmp_buf != 0x03) {
+ LOGE("[ERROR] Invalid Caps of Stream header2");
+ gst_buffer_unmap(header2, &map);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ gst_buffer_unmap(header2, &map);
+
+ /* hsize3 : Setup Header (packet type 5) - variable byte */
+ hsize3 = streamheader_size - (hsize1 + hsize2);
+ header3 = gst_buffer_new_and_alloc(hsize3);
+ gst_buffer_fill(header3, 0, (buf_data + (hsize1 + hsize2)), hsize3);
+ gst_buffer_map(header3, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x05' + 'vorbis' */
+ if (*tmp_buf != 0x05) {
+ LOGE("[ERROR] Invalid Caps of Stream header3");
+ gst_buffer_unmap(header3, &map);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ gst_buffer_unmap(header3, &map);
+
+ 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);
+
+ gst_buffer_unref(header1);
+ gst_buffer_unref(header2);
+ gst_buffer_unref(header3);
+ } else if (core->codec_id == MEDIACODEC_FLAC) {
+ /*
+ * hsize1 : Stream Info (type 0) - fixed 51 byte
+ * hsize2 : Stream Comment (type 4) - variable byte (need calculate)
+ */
+
+ /* First of all, Need to fins and calculate size of hsize2 */
+ tmp_header = gst_buffer_new_and_alloc(streamheader_size);
+ gst_buffer_fill(tmp_header, 0, buf_data, streamheader_size);
+ gst_buffer_map(tmp_header, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ hsize2 = 4 + ((tmp_buf[52] << 16) | (tmp_buf[53] << 8) | (tmp_buf[54]));
+ LOGD("Find streamheader hsize2(%d)", hsize2);
+ gst_buffer_unmap(tmp_header, &map);
+ gst_buffer_unref(tmp_header);
+
+ /* hsize1 : Stream Info (type 0) - fixed 51 byte */
+ hsize1 = 51;
+ header1 = gst_buffer_new_and_alloc(hsize1);
+ gst_buffer_fill(header1, 0, buf_data, hsize1);
+ gst_buffer_map(header1, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x7f' + 'FLAC' */
+ if (*tmp_buf != 0x07f) {
+ LOGE("[ERROR] Invalid Caps of Stream header1 (Info)");
+ gst_buffer_unmap(header1, &map);
+ gst_buffer_unref(header1);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ gst_buffer_unmap(header1, &map);
+
+ /* hsize2 : Stream Comment (type 4) - variable byte (need calculate) */
+ header2 = gst_buffer_new_and_alloc(hsize2);
+ gst_buffer_fill(header2, 0, (buf_data + (hsize1)), hsize2);
+ gst_buffer_map(header2, &map, GST_MAP_READ);
+ tmp_buf = map.data;
+ /* '0x84' */
+ if (*tmp_buf != 0x84) {
+ LOGE("[ERROR] Invalid Caps of Stream header2 (Comment)");
+ gst_buffer_unmap(header2, &map);
+ gst_buffer_unref(header1);
+ gst_buffer_unref(header2);
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+ }
+ 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);
+ gst_buffer_unref(header1);
+ gst_buffer_unref(header2);
+ } else {
+ LOGE("Not support case of Stream header Caps");
+ }
+
+ /* Update gstbuffer's data ptr and size for using previous streamheader.*/
+ LOGD("BEFORE : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
+ gst_buffer_remove_memory_range(buff->buffer, streamheader_size, -1);
+ gst_buffer_set_size(buff->buffer, buf_size - streamheader_size);
+ LOGD("AFTER : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
+
+ return ret;
+}
+
+
+
+int __mc_set_caps_codecdata(mc_gst_core_t *core, GstCaps **caps, GstMCBuffer *buff, guint codecdata_size)
+{
+ int ret = MEDIA_PACKET_ERROR_NONE;
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
+ GstBuffer *codecdata_buffer;
+
+ ret = media_packet_get_buffer_size(buff->pkt, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return ret;
+ }
+
+ ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return ret;
+ }
+
+ LOGD("Set caps for codec_data in mime : %s and codec_id (0x%x)", core->mime, core->codec_id);
+
+ /* Add the codec_data attribute to caps, if we have it */
+ codecdata_buffer = gst_buffer_new_and_alloc(codecdata_size);
+ gst_buffer_fill(codecdata_buffer, 0, buf_data, codecdata_size);
+
+ 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_buffer_unref(codecdata_buffer);
+
+ /* Update gstbuffer's data ptr and size for using previous codec_data..*/
+ LOGD("BEFORE : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
+ gst_buffer_remove_memory_range(buff->buffer, codecdata_size, -1);
+ gst_buffer_set_size(buff->buffer, buf_size - codecdata_size);
+ LOGD("AFTER : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer));
+
+ return ret;
+}
+
+
int _mc_output_media_packet_new(mc_gst_core_t *core, bool video, bool encoder, media_format_mimetype_e out_mime)
{
- if(media_format_create(&core->output_fmt) != MEDIA_FORMAT_ERROR_NONE)
- {
+ if (media_format_create(&core->output_fmt) != MEDIA_FORMAT_ERROR_NONE) {
LOGE("media format create failed");
return MC_ERROR;
}
- if(encoder)
- {
+ if (encoder) {
mc_encoder_info_t *info;
- info = (mc_encoder_info_t*)core->codec_info;
+ info = (mc_encoder_info_t *)core->codec_info;
- if (video)
- {
+ if (video) {
media_format_set_video_mime(core->output_fmt, out_mime);
media_format_set_video_width(core->output_fmt, info->width);
media_format_set_video_height(core->output_fmt, info->height);
media_format_set_video_avg_bps(core->output_fmt, info->bitrate);
- }
- else
- {
+ } else {
media_format_set_audio_mime(core->output_fmt, out_mime);
media_format_set_audio_channel(core->output_fmt, info->channel);
media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
media_format_set_audio_bit(core->output_fmt, info->bit);
media_format_set_audio_avg_bps(core->output_fmt, info->bitrate);
}
- }
- else
- {
+ } else {
mc_decoder_info_t *info;
- info = (mc_decoder_info_t*)core->codec_info;
+ info = (mc_decoder_info_t *)core->codec_info;
- if (video)
- {
+ if (video) {
media_format_set_video_mime(core->output_fmt, out_mime);
media_format_set_video_width(core->output_fmt, info->width);
media_format_set_video_height(core->output_fmt, info->height);
- }
- else
- {
+ } else {
media_format_set_audio_mime(core->output_fmt, out_mime);
media_format_set_audio_channel(core->output_fmt, info->channel);
media_format_set_audio_samplerate(core->output_fmt, info->samplerate);
core->available_queue->input = mc_async_queue_new();
g_mutex_init(&core->eos_mutex);
- g_mutex_init(&core->drain_mutex);
g_cond_init(&core->eos_cond);
g_mutex_init(&core->prepare_lock);
core->need_codec_data = false;
core->need_sync_flag = false;
core->prepare_count = 0;
- core->idr_count = 0;
- core->sps_size = 0;
- core->pps_size = 0;
+ core->queued_count = 0;
+ core->dequeued_count = 0;
- if (!g_thread_supported()) {
- g_thread_init(NULL);
- LOGD("thread init");
- }
g_atomic_int_set(&core->available_queue->running, 1);
core->available_queue->thread = g_thread_new("feed thread", &feed_task, core);
+ core->bufmgr = NULL;
+ core->drm_fd = -1;
LOGD("gst_core(%p) is created", core);
MEDIACODEC_FLEAVE();
g_atomic_int_set(&async_queue->running, 0);
g_thread_join(async_queue->thread);
- g_mutex_clear(&core->drain_mutex);
g_mutex_clear(&core->eos_mutex);
g_mutex_clear(&core->prepare_lock);
g_cond_clear(&core->eos_cond);
LOGD("gst_port(%p) is freed", port);
g_free(port);
- MEDIACODEC_FLEAVE();
-
- return;
-}
-
-static void print_pad_capabilities(GstElement *element, gchar *pad_name)
-{
- GstPad *pad = NULL;
- GstCaps *caps = NULL;
- gchar *format_str = NULL;
- gchar *format_tmp = NULL;
- GstStructure *structure;
- int i;
-
- pad = gst_element_get_static_pad(element, "src");
-
- if (pad == NULL) {
- LOGE("null pad");
- }
+ MEDIACODEC_FLEAVE();
- caps = gst_pad_get_pad_template_caps(pad);
+ return;
}
-static void _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstCaps **caps)
+static void _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstCaps **caps, GstMCBuffer* buff, bool codec_config)
{
- //TODO remove is_hw param
+ /*TODO remove is_hw param*/
core->format = __mc_get_gst_input_format(pkt, core->is_hw);
GstPad *pad = NULL;
pad = gst_element_get_static_pad(core->codec, "src");
template_caps = gst_pad_get_pad_template_caps(pad);
- __mc_create_caps(core, caps);
+ __mc_create_caps(core, caps, buff, codec_config);
g_object_set(core->appsrc, "caps", *caps, NULL);
if (gst_caps_is_subset(*caps, template_caps)) {
}
}
-static GstPadProbeReturn
-event_probe_cb(GstObject *pad, GstPadProbeInfo *info, gpointer user_data)
-{
- mc_gst_core_t *core = (mc_gst_core_t*)user_data;
- GstEvent *event = GST_PAD_PROBE_INFO_EVENT(info);
-
- switch (GST_EVENT_TYPE (event)) {
- case GST_EVENT_STREAM_START:
- core->codec_config = true;
- LOGD("codec_config is set %d, %d", input_count, count);
- break;
- default:
- break;
- }
- return GST_PAD_PROBE_OK;
-}
-
static gpointer feed_task(gpointer data)
{
- mc_gst_core_t *core = (mc_gst_core_t*)data;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
int ret = MC_ERROR_NONE;
bool codec_config = FALSE;
bool eos = FALSE;
media_packet_h in_buf = NULL;
- GstMCBuffer* buff = NULL;
+ GstMCBuffer *buff = NULL;
GstCaps *new_caps = NULL;
bool initiative = true;
- uint64_t wait_until = g_get_monotonic_time() + G_TIME_SPAN_SECOND / 2;
MEDIACODEC_FENTER();
- while(g_atomic_int_get(&core->available_queue->running))
- {
+ while (g_atomic_int_get(&core->available_queue->running)) {
LOGD("waiting for next input....");
in_buf = _mc_get_input_buffer(core);
- if(!in_buf)
+ if (!in_buf)
goto LEAVE;
- if(media_packet_is_codec_config(in_buf, &codec_config) != MEDIA_PACKET_ERROR_NONE)
- {
+ if (media_packet_is_codec_config(in_buf, &codec_config) != MEDIA_PACKET_ERROR_NONE) {
LOGE("media_packet_is_codec_config failed");
goto ERROR;
}
- if(media_packet_is_end_of_stream(in_buf, &eos) != MEDIA_PACKET_ERROR_NONE)
- {
+ if (media_packet_is_end_of_stream(in_buf, &eos) != MEDIA_PACKET_ERROR_NONE) {
LOGE("media_packet_is_end_of_stream failed");
goto ERROR;
}
- if(codec_config)
+ buff = _mc_gst_media_packet_to_gstbuffer(core, &new_caps, in_buf, codec_config);
+ if (!buff) {
+ LOGW("gstbuffer can't make");
+ goto ERROR;
+ }
+
+ if (codec_config)
initiative = true;
if (initiative) {
GstPad *pad;
- _mc_gst_update_caps(core, in_buf, &new_caps);
+ _mc_gst_update_caps(core, in_buf, &new_caps, buff, codec_config);
pad = gst_element_get_static_pad(core->appsrc, "src");
- gst_pad_push_event (pad, gst_event_new_stream_start("sejun"));
+ gst_pad_push_event(pad, gst_event_new_stream_start("sejun"));
gst_object_unref(pad);
LOGD("caps updated");
}
- buff = _mc_gst_media_packet_to_gstbuffer(core, &new_caps, in_buf, codec_config);
- if (!buff) {
- LOGW("gstbuffer can't make");
- goto ERROR;
- }
- LOGD("gstbuffer refcount %d", GST_MINI_OBJECT_REFCOUNT_VALUE(buff));
-
- g_mutex_lock(&core->drain_mutex);
/* inject buffer */
ret = _mc_gst_gstbuffer_to_appsrc(core, buff);
- if(ret != GST_FLOW_OK)
- {
+ if (ret != GST_FLOW_OK) {
LOGE("Failed to push gst buffer");
- g_mutex_unlock(&core->drain_mutex);
goto ERROR;
}
- LOGD("after refcount %d", GST_MINI_OBJECT_REFCOUNT_VALUE(buff));
- LOGD("gst_app_src_get_current_level_bytes :%"G_GUINT64_FORMAT "\n", core->appsrc);
initiative = false;
- g_mutex_unlock(&core->drain_mutex);
-#if 1
- if (eos)
- {
- GstPad *pad;
+ if (eos) {
LOGD("end of stream");
-#if 0
- pad = gst_element_get_static_pad(core->appsrc, "src");
- gst_pad_push_event (pad, gst_event_new_eos() );
- gst_object_unref(pad);
-#else
- //goto EOS;
-
- //g_signal_emit_by_name(core->appsrc, "end-of-stream", &ret);
- gst_app_src_end_of_stream ( core->appsrc );
-#endif
-
- while(!core->eos)
- {
- LOGD("waiting for eos signal...");
- if(!g_cond_wait_until(&core->eos_cond, &core->eos_mutex, wait_until))
- {
- core->eos = true;
- LOGD("time out");
- }
- else
- LOGD("recevied signal");
- }
-
- core->eos = false;
+ gst_app_src_end_of_stream(GST_APP_SRC(core->appsrc));
+ _mc_wait_for_eos(core);
initiative = true;
-#endif
-
}
+
+
continue;
ERROR:
-
- g_mutex_lock(&core->drain_mutex);
_mc_gst_set_flush_input(core);
- g_mutex_unlock(&core->drain_mutex);
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
- {
- ((mc_error_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])(MC_INTERNAL_ERROR, core->user_data[_MEDIACODEC_EVENT_TYPE_ERROR]);
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
+ ((mc_error_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
+ (MC_INTERNAL_ERROR, core->user_data[_MEDIACODEC_EVENT_TYPE_ERROR]);
}
continue;
LEAVE:
- //LOGE("status : in_buf : %p, codec_config : %d, eos : %d, encoder : %d in feed_task", in_buf, codec_config, eos, core->encoder);
+ /*LOGE("status : in_buf : %p, codec_config : %d, eos : %d, encoder : %d in feed_task", in_buf, codec_config, eos, core->encoder);*/
continue;
}
- if(new_caps)
- {
+ 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",
static void __mc_gst_stop_feed(GstElement *pipeline, gpointer data)
{
- mc_gst_core_t *core = (mc_gst_core_t*)data;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
LOGI("stop_feed called");
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
- {
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
((mc_buffer_status_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
- (MEDIACODEC_NEED_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
+ (MEDIACODEC_ENOUGH_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
}
}
static void __mc_gst_start_feed(GstElement *pipeline, guint size, gpointer data)
{
- mc_gst_core_t *core = (mc_gst_core_t*)data;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
LOGI("start_feed called");
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
- {
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]) {
((mc_buffer_status_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS])
- (MEDIACODEC_ENOUGH_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
+ (MEDIACODEC_NEED_DATA, core->user_data[_MEDIACODEC_EVENT_TYPE_BUFFER_STATUS]);
}
}
{
MEDIACODEC_FENTER();
- g_return_val_if_fail (core != NULL, MC_PARAM_ERROR);
+ g_return_val_if_fail(core != NULL, MC_PARAM_ERROR);
- switch (id)
- {
+ switch (id) {
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_vtable : adec_vtable;
+ core->vtable = encoder ? aenc_aac_vtable : adec_aac_vtable;
break;
}
case MEDIACODEC_AAC_HE:
case MEDIACODEC_AAC_HE_PS:
{
LOGD("aac he v12 vtable");
- core->vtable = encoder ? aenc_vtable : adec_aacv12_vtable;
+ core->vtable = encoder ? aenc_aac_vtable : adec_aacv12_vtable;
if (encoder) {
- LOGD("[MC_NOT_SUPPORTED] aac encoder is not supported yet!!!");
+ LOGD("[MC_NOT_SUPPORTED] he-aac-v12 encoder is not supported yet!!!");
return MC_NOT_SUPPORTED;
}
break;
LOGD("[MC_NOT_SUPPORTED] mp3 encoder is not supported yet!!!");
return MC_NOT_SUPPORTED;
}
-
break;
}
case MEDIACODEC_AMR_NB:
{
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;
+ }
+ 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;
+ }
+ 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;
+ }
+ break;
+ }
+ case MEDIACODEC_WMAV1:
+ case MEDIACODEC_WMAV2:
+ 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;
+ }
break;
}
case MEDIACODEC_H263:
{
LOGD("h263 vtable");
- core->vtable = encoder ? venc_vtable : vdec_vtable;
+ core->vtable = encoder ? (is_hw ? venc_h263_hw_vtable : venc_h263_sw_vtable) : is_hw ? vdec_h263_hw_vtable : vdec_h263_sw_vtable;
break;
}
case MEDIACODEC_MPEG4:
{
LOGD("mpeg4 vtable");
- core->vtable = encoder ? venc_vtable : vdec_vtable;
+ core->vtable = encoder ? (is_hw ? venc_mpeg4_hw_vtable : venc_mpeg4_sw_vtable) : is_hw ? vdec_mpeg4_hw_vtable : vdec_mpeg4_sw_vtable;
+
break;
}
case MEDIACODEC_H264:
{
LOGD("h264 vtable");
- if ( is_hw )
- core->vtable = encoder ? venc_vtable : vdec_h264_vtable;
- else
- core->vtable = encoder ? venc_vtable : vdec_vtable;
+ core->vtable = encoder ? (is_hw ? venc_h264_hw_vtable : venc_vtable) : is_hw ? vdec_h264_hw_vtable : vdec_h264_sw_vtable;
break;
}
default:
int ret = MC_ERROR_NONE;
- LOGD(" pushed buffer to appsrc : %p, buffer of size %" G_GSIZE_FORMAT "", buff->buffer, gst_buffer_get_size (buff->buffer));
+ LOGD("pushed buffer to appsrc : %p, buffer of size %" G_GSIZE_FORMAT "",
+ buff->buffer, gst_buffer_get_size(buff->buffer));
ret = gst_app_src_push_buffer(GST_APP_SRC(core->appsrc), buff->buffer);
int ret = MC_ERROR_NONE;
media_format_mimetype_e out_mime;
+ int num_supported_codec=0;
int i = 0;
if (!mc_handle)
bool encoder;
bool hardware;
gchar *factory_name = NULL;
- static const mc_codec_map_t *codec_map;
+ mc_codec_map_t *codec_map;
id = mc_handle->codec_id;
video = mc_handle->is_video;
encoder = mc_handle->is_encoder;
hardware = mc_handle->is_hw;
+ codec_map = encoder ? mc_handle->encoder_map : mc_handle->decoder_map;
+ num_supported_codec = encoder ? mc_handle->num_supported_encoder : mc_handle->num_supported_decoder;
- const int codec_list = encoder ? (sizeof(encoder_map) / sizeof(encoder_map[0])) : (sizeof(decoder_map) / sizeof(decoder_map[0]));
-
- codec_map = encoder ? encoder_map : decoder_map;
-
- for(i = 0; i < codec_list; i++)
- {
- if((id == codec_map[i].id) && (hardware == codec_map[i].hardware))
+ for (i = 0; i < num_supported_codec; i++){
+ if ((id == codec_map[i].id) && (hardware == codec_map[i].hardware))
break;
}
- if( i == codec_list )
+ if (i == num_supported_codec)
return MC_NOT_SUPPORTED;
factory_name = codec_map[i].type.factory_name;
out_mime = codec_map[i].type.out_format;
/* gst_core create */
- mc_gst_core_t* new_core = mc_gst_core_new();
+ mc_gst_core_t *new_core = mc_gst_core_new();
new_core->mime = codec_map[i].type.mime;
new_core->is_hw = hardware;
new_core->eos = false;
new_core->encoder = encoder;
new_core->video = video;
- new_core->codec_info = encoder ? (void*)&mc_handle->info.encoder : (void*)&mc_handle->info.decoder;
+ new_core->codec_info = encoder ? (void *)&mc_handle->info.encoder : (void *)&mc_handle->info.decoder;
new_core->out_mime = codec_map[i].type.out_format;
+ new_core->codec_id = id;
+
+ new_core->bufmgr = tbm_bufmgr_init(new_core->drm_fd);
+ if (new_core->bufmgr == NULL) {
+ LOGE("TBM initialization failed");
+ return MC_ERROR;
+ }
LOGD("@%p(%p) core is initializing...v(%d)e(%d)", mc_handle, new_core, new_core->video, new_core->encoder);
LOGD("factory name : %s, output_fmt : %x", factory_name, out_mime);
/* create media_packet for output fmt */
- if ( (ret = _mc_output_media_packet_new(new_core, video, encoder, out_mime)) != MC_ERROR_NONE)
- {
+ if ((ret = _mc_output_media_packet_new(new_core, video, encoder, out_mime)) != MC_ERROR_NONE) {
LOGE("Failed to create output pakcet");
return ret;
}
/* link vtable */
- if((ret = _mc_link_vtable(new_core, id, encoder, hardware)) != MC_ERROR_NONE)
- {
+ 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++)
- {
+ for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER ; i++) {
LOGD("copy cb function [%d]", i);
- if (mc_handle->user_cb[i])
- {
+ if (mc_handle->user_cb[i]) {
new_core->user_cb[i] = mc_handle->user_cb[i];
new_core->user_data[i] = mc_handle->user_data[i];
LOGD("user_cb[%d] %p, %p", i, new_core->user_cb[i], mc_handle->user_cb[i]);
/* create basic core elements */
ret = _mc_gst_create_pipeline(mc_handle->core, factory_name);
- LOGD("initialized...");
+ LOGD("initialized... %d", ret);
return ret;
}
int i;
int ret = MC_ERROR_NONE;
mc_gst_core_t *core = NULL;
- uint64_t wait_until = g_get_monotonic_time() + G_TIME_SPAN_SECOND / 2;
if (!mc_handle)
return MC_PARAM_ERROR;
- core = (mc_gst_core_t*)mc_handle->core;
+ core = (mc_gst_core_t *)mc_handle->core;
- if(core)
- {
- LOGD("@%p(%p) core is uninitializing... v(%d)e(%d)",mc_handle, core, core->video, core->encoder);
+ if (core) {
+ LOGD("@%p(%p) core is uninitializing... v(%d)e(%d)", mc_handle, core, core->video, core->encoder);
+
+ if (core->eos) {
+ _mc_send_eos_signal(core);
+ }
+
+ _mc_gst_flush_buffers(core);
- _mc_gst_flush_buffers (core);
+
+ ret = _mc_gst_destroy_pipeline(core);
/* unset callback */
- for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER ; i++)
- {
+ for (i = 0; i < _MEDIACODEC_EVENT_TYPE_INTERNAL_FILLBUFFER; i++) {
LOGD("unset cb function [%d]", i);
- if (mc_handle->user_cb[i])
- {
+ if (mc_handle->user_cb[i]) {
core->user_cb[i] = NULL;
core->user_data[i] = NULL;
LOGD("user_cb[%d] %p, %p", i, core->user_cb[i], mc_handle->user_cb[i]);
}
}
- ret = _mc_gst_destroy_pipeline(core);
+ media_format_unref(core->output_fmt);
- if(core != NULL)
- {
+ if (core->bufmgr != NULL) {
+ tbm_bufmgr_deinit(core->bufmgr);
+ core->bufmgr = NULL;
+ }
+
+ if(core->drm_fd != -1) {
+ close(core->drm_fd);
+ LOGD("close drm_fd");
+ }
+
+ if (core != NULL) {
mc_gst_core_free(core);
mc_handle->core = NULL;
}
if (!mc_handle)
return MC_PARAM_ERROR;
- core = (mc_gst_core_t*)mc_handle->core;
- LOGI("@%p v(%d)e(%d)process_input", core, core->video, core->encoder);
- LOGD("input buffer count :%d", input_count);
+ core = (mc_gst_core_t *)mc_handle->core;
- g_get_current_time (&nowtv);
- g_time_val_add (&nowtv, 500 * 1000 ); /* usec */
+ g_get_current_time(&nowtv);
+ g_time_val_add(&nowtv, 500 * 1000); /* usec */
/*
if (!g_cond_timed_wait(&nowtv)) {
}
*/
- input_count++;
- if(!core->eos)
+ if (core->prepare_count == 0)
+ return MEDIACODEC_ERROR_INVALID_STATE;
+
+ if (!core->eos)
mc_async_queue_push(core->available_queue->input, inbuf);
else
ret = MC_INVALID_IN_BUF;
-
+ LOGI("@%p v(%d)e(%d)process_input(%d)", core, core->video, core->encoder, core->queued_count);
+ core->queued_count++;
MEDIACODEC_FLEAVE();
if (!mc_handle)
return MC_PARAM_ERROR;
- core = (mc_gst_core_t*)mc_handle->core;
+ core = (mc_gst_core_t *)mc_handle->core;
LOGI("@%p v(%d)e(%d) get_output", core, core->video, core->encoder);
g_mutex_lock(&core->ports[1]->mutex);
- if(!g_queue_is_empty(core->ports[1]->queue))
- {
+ if (!g_queue_is_empty(core->ports[1]->queue)) {
out_pkt = g_queue_pop_head(core->ports[1]->queue);
LOGD("pop from output_queue : %p", out_pkt);
- }
- else
- {
+ } else {
ret = MC_OUTPUT_BUFFER_EMPTY;
LOGD("output_queue is empty");
}
int ret = MC_ERROR_NONE;
mc_gst_core_t *core = NULL;
- GstPad *pad;
-
- pad = gst_element_get_static_pad(core->appsrc, "src");
if (!mc_handle)
return MC_PARAM_ERROR;
- core = (mc_gst_core_t*)mc_handle->core;
+ core = (mc_gst_core_t *)mc_handle->core;
LOGI("@%p v(%d)e(%d) get_output", core, core->video, core->encoder);
- _mc_gst_flush_buffers ( core );
+ _mc_gst_flush_buffers(core);
MEDIACODEC_FLEAVE();
static gboolean initialized = FALSE;
static const int max_argc = 50;
- gint* argc = NULL;
- gchar** argv = NULL;
- gchar** argv2 = NULL;
+ gint *argc = NULL;
+ gchar **argv = NULL;
+ gchar **argv2 = NULL;
GError *err = NULL;
int i = 0;
int arg_count = 0;
- if ( initialized )
- {
+ if (initialized) {
LOGD("gstreamer already initialized.\n");
return TRUE;
}
/* alloc */
- argc = malloc( sizeof(int) );
- argv = malloc( sizeof(gchar*) * max_argc );
- argv2 = malloc( sizeof(gchar*) * max_argc );
+ argc = malloc(sizeof(int));
+ argv = malloc(sizeof(gchar *) *max_argc);
+ argv2 = malloc(sizeof(gchar *) *max_argc);
- if ( !argc || !argv || !argv2 )
+ if (!argc || !argv || !argv2)
goto ERROR;
- memset( argv, 0, sizeof(gchar*) * max_argc );
- memset( argv2, 0, sizeof(gchar*) * max_argc );
+ memset(argv, 0, sizeof(gchar *) *max_argc);
+ memset(argv2, 0, sizeof(gchar *) *max_argc);
/* add initial */
*argc = 1;
- argv[0] = g_strdup( "media codec" );
+ argv[0] = g_strdup("media codec");
/* we would not do fork for scanning plugins */
argv[*argc] = g_strdup("--gst-disable-registry-fork");
LOGD("argc : %d\n", *argc);
arg_count = *argc;
- for ( i = 0; i < arg_count; i++ )
- {
+ for (i = 0; i < arg_count; i++) {
argv2[i] = argv[i];
LOGD("argv[%d] : %s\n", i, argv2[i]);
}
/* initializing gstreamer */
- if ( ! gst_init_check (argc, &argv, &err))
- {
+ if (!gst_init_check(argc, &argv, &err)) {
LOGE("Could not initialize GStreamer: %s\n", err ? err->message : "unknown error occurred");
- if (err)
- {
- g_error_free (err);
+ if (err) {
+ g_error_free(err);
}
goto ERROR;
}
/* release */
- for ( i = 0; i < arg_count; i++ )
- {
- MC_FREEIF( argv2[i] );
+ for (i = 0; i < arg_count; i++) {
+ MC_FREEIF(argv2[i]);
}
- MC_FREEIF( argv );
- MC_FREEIF( argv2 );
- MC_FREEIF( argc );
+ MC_FREEIF(argv);
+ MC_FREEIF(argv2);
+ MC_FREEIF(argc);
/* done */
initialized = TRUE;
+ MEDIACODEC_FLEAVE();
return TRUE;
ERROR:
/* release */
- for ( i = 0; i < arg_count; i++ )
- {
+ for (i = 0; i < arg_count; i++) {
LOGD("free[%d] : %s\n", i, argv2[i]);
- MC_FREEIF( argv2[i] );
+ MC_FREEIF(argv2[i]);
}
- MC_FREEIF( argv );
- MC_FREEIF( argv2 );
- MC_FREEIF( argc );
+ MC_FREEIF(argv);
+ MC_FREEIF(argv2);
+ MC_FREEIF(argc);
return FALSE;
}
-mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t* core, gchar *factory_name)
+mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name)
{
GstBus *bus = NULL;
- GstPad *pad = NULL;
MEDIACODEC_FENTER();
g_mutex_lock(&core->prepare_lock);
- if(core->prepare_count == 0)
- {
+ if (core->prepare_count == 0) {
- if (!__mc_gst_init_gstreamer())
- {
- LOGE ("gstreamer initialize fail");
+ if (!__mc_gst_init_gstreamer()) {
+ LOGE("gstreamer initialize fail");
g_mutex_unlock(&core->prepare_lock);
return MC_NOT_INITIALIZED;
}
core->codec = gst_element_factory_make(factory_name, NULL);
- if(!core->codec)
- {
- LOGE ("codec element create fail");
+ if (!core->codec) {
+ LOGE("codec element create fail");
goto ERROR;
}
/* create common elements */
core->pipeline = gst_pipeline_new(NULL);
- if (!core->pipeline)
- {
- LOGE ("pipeline create fail");
+ if (!core->pipeline) {
+ LOGE("pipeline create fail");
goto ERROR;
}
core->appsrc = gst_element_factory_make("appsrc", NULL);
- if (!core->appsrc)
- {
- LOGE ("appsrc can't create");
+ if (!core->appsrc) {
+ LOGE("appsrc can't create");
goto ERROR;
}
core->capsfilter = gst_element_factory_make("capsfilter", NULL);
- if (!core->capsfilter)
- {
- LOGE ("capsfilter can't create");
+ if (!core->capsfilter) {
+ LOGE("capsfilter can't create");
goto ERROR;
}
core->fakesink = gst_element_factory_make("fakesink", NULL);
- if (!core->fakesink)
- {
- LOGE ("fakesink create fail");
+ if (!core->fakesink) {
+ LOGE("fakesink create fail");
goto ERROR;
}
- g_object_set(core->fakesink, "enable-last-buffer", FALSE, NULL);
+ g_object_set(core->fakesink, "enable-last-sample", FALSE, NULL);
- //__mc_link_elements(core);
+ /*__mc_link_elements(core);*/
gst_bin_add_many(GST_BIN(core->pipeline), core->appsrc, core->capsfilter, core->codec, core->fakesink, NULL);
/* link elements */
gst_element_link_many(core->appsrc, core->capsfilter, core->codec, core->fakesink, NULL);
/* connect signals, bus watcher */
- bus = gst_pipeline_get_bus (GST_PIPELINE (core->pipeline));
- core->bus_whatch_id = gst_bus_add_watch (bus, __mc_gst_bus_callback, core);
+ bus = gst_pipeline_get_bus(GST_PIPELINE(core->pipeline));
+ core->bus_whatch_id = gst_bus_add_watch(bus, __mc_gst_bus_callback, core);
core->thread_default = g_main_context_get_thread_default();
/* set sync handler to get tag synchronously */
gst_bus_set_sync_handler(bus, __mc_gst_bus_sync_callback, core, NULL);
-
- gst_object_unref (GST_OBJECT(bus));
-
- /* add pad probe */
- pad = gst_element_get_static_pad(core->fakesink, "sink");
- //core->probe_id = gst_pad_add_event_probe(pad, G_CALLBACK(event_probe_cb), core);
- core->probe_id =
- gst_pad_add_probe(pad, GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM,
- (GstPadProbeCallback)event_probe_cb, core, NULL);
- gst_object_unref (pad);
+ gst_object_unref(GST_OBJECT(bus));
/* app src */
g_signal_connect(core->appsrc, "need-data", G_CALLBACK(__mc_gst_start_feed), core);
g_signal_connect(core->appsrc, "enough-data", G_CALLBACK(__mc_gst_stop_feed), core);
/* connect handoff */
- g_object_set (GST_OBJECT(core->fakesink), "signal-handoffs", TRUE, NULL);
+ g_object_set(GST_OBJECT(core->fakesink), "signal-handoffs", TRUE, NULL);
core->signal_handoff = g_signal_connect(core->fakesink, "handoff", G_CALLBACK(__mc_gst_buffer_add), core);
/* set state PLAYING */
STATE_CHANGE_FAILED:
ERROR:
- if(core->codec)
+ if (core->codec)
gst_object_unref(GST_OBJECT(core->codec));
- if(core->pipeline)
+ if (core->pipeline)
gst_object_unref(GST_OBJECT(core->pipeline));
- if(core->appsrc)
+ if (core->appsrc)
gst_object_unref(GST_OBJECT(core->appsrc));
- if(core->capsfilter)
+ if (core->capsfilter)
gst_object_unref(GST_OBJECT(core->capsfilter));
- if(core->fakesink)
+ if (core->fakesink)
gst_object_unref(GST_OBJECT(core->fakesink));
g_mutex_unlock(&core->prepare_lock);
mc_ret_e _mc_gst_destroy_pipeline(mc_gst_core_t *core)
{
int ret = MC_ERROR_NONE;
- GstPad *pad = NULL;
MEDIACODEC_FENTER();
g_mutex_lock(&core->prepare_lock);
core->prepare_count--;
- if(core->prepare_count == 0)
- {
+ if (core->prepare_count == 0) {
- if(core->pipeline)
- {
+ if (core->pipeline) {
/* disconnect signal */
- if(core->fakesink && GST_IS_ELEMENT(core->fakesink))
- {
- if(g_signal_handler_is_connected(core->fakesink, core->signal_handoff))
- {
+ if (core->fakesink && GST_IS_ELEMENT(core->fakesink)) {
+ if (g_signal_handler_is_connected(core->fakesink, core->signal_handoff)) {
g_signal_handler_disconnect(core->fakesink, core->signal_handoff);
LOGD("handoff signal destroy");
}
}
- if(core->bus_whatch_id)
- {
+ if (core->bus_whatch_id) {
GSource *source = NULL;
- source = g_main_context_find_source_by_id (core->thread_default, core->bus_whatch_id);
+ source = g_main_context_find_source_by_id(core->thread_default, core->bus_whatch_id);
g_source_destroy(source);
- //g_source_remove(core->bus_whatch_id);
LOGD("bus_whatch_id destroy");
}
- pad = gst_element_get_static_pad(core->fakesink, "sink");
- gst_pad_remove_probe(pad, core->probe_id);
- g_object_unref(pad);
-
MEDIACODEC_ELEMENT_SET_STATE(core->pipeline, GST_STATE_NULL);
gst_object_unref(GST_OBJECT(core->pipeline));
return ret;
STATE_CHANGE_FAILED:
- if(core->pipeline)
+ if (core->pipeline)
gst_object_unref(GST_OBJECT(core->pipeline));
LOGD("@%p v(%d)e(%d) destroy_pipeline failed", core, core->video, core->encoder);
return MC_ERROR;
}
-void __mc_gst_append_codec_data(mc_gst_core_t *core, media_packet_h pkt)
+void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- void* buf_data = NULL;
- uint64_t buf_size = 0;
- void *tmp = NULL;
-
- media_packet_get_buffer_size(pkt, &buf_size);
- media_packet_get_buffer_data_ptr(pkt, &buf_data);
-
- tmp = (unsigned char*)malloc(sizeof(unsigned char)*buf_size);
- memcpy(tmp, buf_data, buf_size);
- memcpy(buf_data, core->codec_data, core->codec_data_size);
- memcpy(buf_data + core->codec_data_size, tmp, buf_size);
- media_packet_set_buffer_size(pkt, buf_size+core->codec_data_size);
- free(tmp);
-}
-
-void __mc_gst_buffer_add (GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data)
-{
- mc_gst_core_t* core = (mc_gst_core_t*) data;
- void* buf_data = NULL;
- uint64_t buf_size = 0;
- static gboolean initialized = FALSE;
- int mask = 0xfffffff0;
guint n;
GstMemory *mem;
- MMVideoBuffer *imgb = NULL;
GstMapInfo map = GST_MAP_INFO_INIT;
media_packet_h out_pkt = NULL;
MEDIACODEC_FENTER();
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
+
gst_buffer_ref(buffer);
n = gst_buffer_n_memory(buffer);
mem = gst_buffer_peek_memory(buffer, n-1);
gst_memory_map(mem, &map, GST_MAP_READ);
- LOGD("n : %d, map.data : %p, map.size : %d",n, map.data, map.size);
+ LOGD("n : %d, map.data : %p, map.size : %d", n, map.data, map.size);
out_pkt = __mc_gst_make_media_packet(core, map.data, map.size);
gst_memory_unmap(mem, &map);
- if ( out_pkt ) {
+ if (out_pkt) {
media_packet_set_extra(out_pkt, buffer);
media_packet_set_pts(out_pkt, GST_BUFFER_TIMESTAMP(buffer));
core->need_codec_data = false;
}
- if ( core->need_sync_flag ) {
+ if (core->need_sync_flag) {
media_packet_set_flags(out_pkt, MEDIA_PACKET_SYNC_FRAME);
core->need_sync_flag = false;
}
/* push it to output buffer queue */
g_queue_push_tail(core->ports[1]->queue, out_pkt);
- count++;
- LOGD("queued : %d", count);
+ core->dequeued_count++;
+ LOGD("dequeued : %d", core->dequeued_count);
+ LOGD("GST_BUFFER_TIMESTAMP = %"GST_TIME_FORMAT, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)));
g_mutex_unlock(&core->ports[1]->mutex);
- if ( core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER] ) {
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) {
((mc_fill_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER])
(out_pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]);
}
int __mc_output_buffer_finalize_cb(media_packet_h packet, int error_code, void *user_data)
{
- GstMemory *mem;
- void* buffer = NULL;
+ void *buffer = NULL;
+ LOGD("packet finalized: %p", packet);
media_packet_get_extra(packet, &buffer);
- gst_buffer_unref((GstBuffer*)buffer);
+ gst_buffer_unref((GstBuffer *)buffer);
return MEDIA_PACKET_FINALIZE;
}
media_packet_get_format(packet, &fmt);
media_format_get_video_info(fmt, &mimetype, NULL, NULL, NULL, NULL);
+ media_format_unref(fmt);
LOGD("input packet mimetype : %x", mimetype);
- switch(mimetype)
- {
+ switch (mimetype) {
case MEDIA_FORMAT_I420:
format = "I420";
break;
return format;
}
-guint __mc_set_codecdata_buffer(mc_gst_core_t *core, GstCaps **caps, void *buf_data, int buf_size)
-{
- GstBuffer *codec_data;
- guint16 codec_data_data;
- GstMapInfo map;
- guint codecdata_size;
-
- LOGD("[LEO] Enable codec_config, So Set caps for codec_data in codec_id (0x%x)", core->codec_id);
-
- if ( (!core->encoder) &&
- (core->codec_id == MEDIACODEC_AAC ||core->codec_id == MEDIACODEC_AAC_HE || core->codec_id == MEDIACODEC_AAC_HE_PS))
- {
- /*
- * The codec_data data is according to AudioSpecificConfig,
- * ISO/IEC 14496-3, 1.6.2.1
- */
- codecdata_size = 16; /*AUDIO_CODECDATA_SIZE = 16 (in testsuit)*/
- codec_data = gst_buffer_new_and_alloc (codecdata_size);
- gst_buffer_map (codec_data, &map, GST_MAP_WRITE);
- memcpy (map.data, buf_data, codecdata_size);
- gst_buffer_unmap (codec_data, &map);
-
- gst_caps_set_simple (*caps, "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
- }
- else
- {
- codecdata_size = 0;
- LOGW("codec data set fail");
- }
-
- return codecdata_size;
-}
-
-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, GstCaps **caps, media_packet_h pkt, bool codec_config)
{
int ret = MEDIA_PACKET_ERROR_NONE;
- GstMCBuffer* mc_buffer = NULL;
- void* buf_data = NULL;
+ GstMCBuffer *mc_buffer = NULL;
+ void *buf_data = NULL;
uint64_t buf_size = 0;
uint64_t pts = 0;
uint64_t dur = 0;
ret = media_packet_get_buffer_size(pkt, &buf_size);
- if (ret != MEDIA_PACKET_ERROR_NONE)
- {
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
LOGW("buffer size get fail");
return NULL;
}
ret = media_packet_get_buffer_data_ptr(pkt, &buf_data);
- if (ret != MEDIA_PACKET_ERROR_NONE)
- {
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
LOGW("buffer size get fail");
return NULL;
}
mc_buffer = gst_mediacodec_buffer_new(core, pkt, buf_size);
- if(mc_buffer->buffer == NULL)
- {
+ if (mc_buffer == NULL) {
LOGW("failed to create inbuf");
return NULL;
}
-#if 1 //Added code for codec_data
- if (codec_config)
- {
- guint codec_data_size = 0;
- codec_data_size = __mc_set_codecdata_buffer(core, caps, buf_data, (int)buf_size);
-
- buf_data += codec_data_size;
- buf_size -= codec_data_size;
-
- LOGD("Enable codec_config, returned codec_data_size (%d)", codec_data_size);
- }
-#endif
+ LOGD("pkt : %p, buf_size : %d", pkt, (int)buf_size);
- ret = __mc_fill_input_buffer(core, buf_data, (int)buf_size, mc_buffer);
- if (ret != MC_ERROR_NONE)
- {
+ ret = __mc_fill_input_buffer(core, pkt, mc_buffer);
+ if (ret != MC_ERROR_NONE) {
LOGW("failed to fill inbuf");
return NULL;
}
return mc_buffer;
}
-media_packet_h __mc_gst_gstbuffer_to_media_packet(mc_gst_core_t* core, GstBuffer* buff)
-{
- media_packet_h out_pkt = NULL;
-
- if (!buff)
- return NULL;
-
- //__mc_fill_output_buffer(core, buff, &out_pkt);
-
- gst_buffer_ref(buff);
-
- return out_pkt;
-}
-
media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *data, int size)
{
media_packet_h pkt = NULL;
__mc_fill_output_buffer(core, data, size, &pkt);
+
return pkt;
}
-gboolean __mc_gst_bus_callback (GstBus *bus, GstMessage *msg, gpointer data)
+gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data)
{
int ret = MC_ERROR_NONE;
- mc_gst_core_t *core = (mc_gst_core_t*)data;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
LOGD("@%p v(%d)e(%d)", core, core->video, core->encoder);
- switch (GST_MESSAGE_TYPE (msg)) {
+ switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_EOS:
{
- core->eos = true;
- g_cond_signal(&core->eos_cond);
- LOGD("send eos signal");
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS])
- {
+ _mc_send_eos_signal(core);
+
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) {
LOGD("eos callback invoked");
((mc_eos_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS])(core->user_data[_MEDIACODEC_EVENT_TYPE_EOS]);
}
- LOGD ("End of stream\n");
+ LOGD("End of stream\n");
}
break;
case GST_MESSAGE_ERROR:
{
- GError* error = NULL;
+ GError *error = NULL;
- gst_message_parse_error (msg, &error, NULL);
+ gst_message_parse_error(msg, &error, NULL);
- if (!error)
- {
+ if (!error) {
LOGW("GST error message parsing failed");
break;
}
- LOGW ("Error: %s\n", error->message);
+ LOGW("Error: %s\n", error->message);
- if(error)
- {
- if(error->domain == GST_STREAM_ERROR)
- {
+ if (error) {
+ if (error->domain == GST_STREAM_ERROR) {
ret = __gst_handle_stream_error(core, error, msg);
- }
- else if (error->domain == GST_RESOURCE_ERROR)
- {
+ } else if (error->domain == GST_RESOURCE_ERROR) {
ret = __gst_handle_resource_error(core, error->code);
- }
- else if (error->domain == GST_LIBRARY_ERROR)
- {
+ } else if (error->domain == GST_LIBRARY_ERROR) {
ret = __gst_handle_library_error(core, error->code);
- }
- else if (error->domain == GST_CORE_ERROR)
- {
+ } else if (error->domain == GST_CORE_ERROR) {
ret = __gst_handle_core_error(core, error->code);
- }
- else
- {
+ } else {
LOGW("Unexpected error has occured");
}
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
- {
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) {
((mc_error_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR])
(ret, core->user_data[_MEDIACODEC_EVENT_TYPE_ERROR]);
}
}
- g_error_free (error);
+ g_error_free(error);
}
break;
break;
}
- //gst_object_unref(msg);
-
return TRUE;
}
-static gboolean
-__mc_gst_check_useful_message(mc_gst_core_t *core, GstMessage *msg)
+static gboolean __mc_gst_check_useful_message(mc_gst_core_t *core, GstMessage *msg)
{
gboolean retval = false;
- if(!core->pipeline)
- {
+ if (!core->pipeline) {
LOGE("mediacodec pipeline handle is null");
return true;
}
- switch (GST_MESSAGE_TYPE (msg))
- {
+ switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_TAG:
case GST_MESSAGE_EOS:
case GST_MESSAGE_ERROR:
return retval;
}
-static GstBusSyncReply
-__mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data)
+static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data)
{
- mc_gst_core_t *core = (mc_gst_core_t*)data;
+ mc_gst_core_t *core = (mc_gst_core_t *)data;
GstBusSyncReply reply = GST_BUS_DROP;
LOGD("__mc_gst_bus_sync_callback is called");
- if(!core->pipeline)
- {
+ if (!core->pipeline) {
LOGE("mediacodec pipeline handle is null");
return GST_BUS_PASS;
}
- if(!__mc_gst_check_useful_message(core, msg))
- {
+ if (!__mc_gst_check_useful_message(core, msg)) {
gst_message_unref(msg);
return GST_BUS_DROP;
}
- switch (GST_MESSAGE_TYPE (msg))
- {
+ switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_EOS:
case GST_MESSAGE_ERROR:
__mc_gst_bus_callback(NULL, msg, core);
break;
}
- if( reply == GST_BUS_DROP )
+ if (reply == GST_BUS_DROP)
gst_message_unref(msg);
return reply;
}
-static MMVideoBuffer * __mc_gst_make_tbm_buffer(mc_gst_core_t* core, media_packet_h pkt)
+static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t* core, media_packet_h pkt)
{
tbm_surface_h surface = NULL;
tbm_bo bo = NULL;
- mc_encoder_info_t *enc_info = (mc_encoder_info_t*)core->codec_info;
+ mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info;
if (!pkt) {
LOGE("output is null");
return NULL;
}
- MMVideoBuffer *imgb = NULL;
- imgb = (MMVideoBuffer *)malloc(sizeof(MMVideoBuffer));
- if (!imgb) {
+ MMVideoBuffer *mm_vbuffer = NULL;
+ mm_vbuffer = (MMVideoBuffer *)malloc(sizeof(MMVideoBuffer));
+ if (!mm_vbuffer) {
LOGE("Failed to alloc MMVideoBuffer");
return NULL;
}
- memset(imgb, 0x00, sizeof(MMVideoBuffer));
+ memset(mm_vbuffer, 0x00, sizeof(MMVideoBuffer));
media_packet_get_tbm_surface(pkt, &surface);
bo = tbm_surface_internal_get_bo(surface, 0);
tbm_bo_handle handle = tbm_bo_get_handle(bo, TBM_DEVICE_CPU);
-#ifdef Z130H
+#ifdef TIZEN_PROFILE_LITE
int phy_addr = 0;
int phy_size = 0;
tbm_bo_handle handle_fd = tbm_bo_get_handle(bo, TBM_DEVICE_MM);
- if (__tbm_get_physical_addr_bo(handle_fd, &phy_addr, &phy_size) == 0)
- {
- imgb->handle.paddr[0] = (void*)phy_addr;
- LOGD("imgb->paddr : %p", imgb->handle.paddr[0]);
+ if (__tbm_get_physical_addr_bo(handle_fd, &phy_addr, &phy_size) == 0) {
+ mm_vbuffer->handle.paddr[0] = (void *)phy_addr;
+ LOGD("mm_vbuffer->paddr : %p", mm_vbuffer->handle.paddr[0]);
}
LOGD("paddr : %p", phy_addr);
#endif
- imgb->type = MM_VIDEO_BUFFER_TYPE_TBM_BO;
- imgb->handle.bo[0] = bo;
- imgb->data[0] = handle.ptr;
- imgb->width[0] = enc_info->width;
- imgb->height[0] = enc_info->height;
- imgb->stride_width[0] = imgb->width[0];
- imgb->stride_height[0] = imgb->height[0];
+ mm_vbuffer->type = MM_VIDEO_BUFFER_TYPE_TBM_BO;
+ mm_vbuffer->handle.bo[0] = bo;
+ mm_vbuffer->data[0] = handle.ptr;
+ mm_vbuffer->width[0] = enc_info->width;
+ mm_vbuffer->height[0] = enc_info->height;
+ mm_vbuffer->stride_width[0] = mm_vbuffer->width[0];
+ mm_vbuffer->stride_height[0] = mm_vbuffer->height[0];
- return imgb;
+ return mm_vbuffer;
}
static void gst_mediacodec_buffer_finalize(GstMCBuffer *mc_buffer)
{
- MMVideoBuffer *imgb = NULL;
- GstMemory *mem = NULL;
- GstMapInfo map = GST_MAP_INFO_INIT;
- mc_gst_core_t *core = mc_buffer->core;
- guint n;
-
-
-
- n = gst_buffer_n_memory(mc_buffer->buffer);
+ if (!mc_buffer)
+ return;
- mem = gst_buffer_peek_memory(mc_buffer->buffer, n-1);
+ mc_gst_core_t *core = (mc_gst_core_t *)mc_buffer->core;
- gst_memory_map(mem, &map, GST_MAP_READ);
- LOGD("n : %d, map.data : %p, map.size : %d",n, map.data, map.size);
-
- gst_memory_unmap(mem, &map);
-
- LOGD("gst_mediacodec_buffer_finalize()");
-/*
- if(mc_buffer->has_imgb) {
-
- mem = gst_buffer_peek_memory(mc_buffer->buffer, 1);
- gst_memory_map(mem, &map, GST_MAP_READ);
- imgb = (MMVideoBuffer*)map.data;
- gst_memory_unmap(mem, &map);
-
- if(imgb) {
- free(imgb);
- imgb = NULL;
- LOGD("imgb is destroyed");
- }
- }
-*/
-
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
- {
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
(mc_buffer->pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]);
}
+ LOGD("%p buffer finalized...", mc_buffer);
+ free(mc_buffer);
+ mc_buffer = NULL;
+
return;
}
GstMCBuffer *mc_buffer = NULL;
mc_buffer = (GstMCBuffer *)malloc(sizeof(*mc_buffer));
+
+ if (mc_buffer == NULL) {
+ LOGE("malloc fail");
+ return NULL;
+ }
+
mc_buffer->buffer = gst_buffer_new();
- mc_buffer->buf_size = size;
+ mc_buffer->buf_size = 0;
LOGD("creating buffer : %p, %p", mc_buffer, mc_buffer->buffer);
mc_buffer->core = core;
return mc_buffer;
}
-static gint __gst_handle_core_error(mc_gst_core_t* core, int code )
+static gint __gst_handle_core_error(mc_gst_core_t *core, int code)
{
gint trans_err = MEDIACODEC_ERROR_NONE;
g_return_val_if_fail(core, MC_PARAM_ERROR);
- switch ( code )
- {
+ switch (code) {
case GST_CORE_ERROR_MISSING_PLUGIN:
return MEDIACODEC_ERROR_NOT_SUPPORTED_FORMAT;
case GST_CORE_ERROR_STATE_CHANGE:
return trans_err;
}
-static gint __gst_handle_library_error(mc_gst_core_t* core, int code)
+static gint __gst_handle_library_error(mc_gst_core_t *core, int code)
{
gint trans_err = MEDIACODEC_ERROR_NONE;
g_return_val_if_fail(core, MC_PARAM_ERROR);
- switch ( code )
- {
+ switch (code) {
case GST_LIBRARY_ERROR_FAILED:
case GST_LIBRARY_ERROR_TOO_LAZY:
case GST_LIBRARY_ERROR_INIT:
}
-static gint __gst_handle_resource_error(mc_gst_core_t* core, int code )
+static gint __gst_handle_resource_error(mc_gst_core_t *core, int code)
{
gint trans_err = MEDIACODEC_ERROR_NONE;
g_return_val_if_fail(core, MC_PARAM_ERROR);
- switch ( code )
- {
+ switch (code) {
case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
trans_err = MEDIACODEC_ERROR_NO_FREE_SPACE;
break;
return trans_err;
}
-static gint __gst_handle_stream_error(mc_gst_core_t* core, GError* error, GstMessage * message)
+static gint __gst_handle_stream_error(mc_gst_core_t *core, GError* error, GstMessage * message)
{
gint trans_err = MEDIACODEC_ERROR_NONE;
g_return_val_if_fail(core, MC_PARAM_ERROR);
g_return_val_if_fail(error, MC_PARAM_ERROR);
- g_return_val_if_fail (message, MC_PARAM_ERROR);
+ g_return_val_if_fail(message, MC_PARAM_ERROR);
- switch ( error->code )
- {
+ switch (error->code) {
case GST_STREAM_ERROR_FAILED:
case GST_STREAM_ERROR_TYPE_NOT_FOUND:
case GST_STREAM_ERROR_DECODE:
case GST_STREAM_ERROR_DECRYPT:
case GST_STREAM_ERROR_DECRYPT_NOKEY:
case GST_STREAM_ERROR_CODEC_NOT_FOUND:
- trans_err = __gst_transform_gsterror( core, message, error );
+ trans_err = __gst_transform_gsterror(core, message, error);
break;
case GST_STREAM_ERROR_NOT_IMPLEMENTED:
return trans_err;
}
-static gint __gst_transform_gsterror( mc_gst_core_t *core, GstMessage * message, GError* error )
+static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage * message, GError* error)
{
gchar *src_element_name = NULL;
GstElement *src_element = NULL;
GstElementFactory *factory = NULL;
- const gchar* klass = NULL;
+ const gchar *klass = NULL;
src_element = GST_ELEMENT_CAST(message->src);
- if ( !src_element )
+ if (!src_element)
goto INTERNAL_ERROR;
src_element_name = GST_ELEMENT_NAME(src_element);
- if ( !src_element_name )
+ if (!src_element_name)
goto INTERNAL_ERROR;
factory = gst_element_get_factory(src_element);
- if ( !factory )
+ if (!factory)
goto INTERNAL_ERROR;
klass = gst_element_factory_get_klass(factory);
- if ( !klass )
+ if (!klass)
goto INTERNAL_ERROR;
LOGD("error code=%d, msg=%s, src element=%s, class=%s\n",
error->code, error->message, src_element_name, klass);
- switch ( error->code )
- {
+ switch (error->code) {
case GST_STREAM_ERROR_DECODE:
return MEDIACODEC_ERROR_INVALID_STREAM;
break;
return MEDIACODEC_ERROR_INTERNAL;
}
-static void _mc_gst_flush_buffers( mc_gst_core_t *core )
+static void _mc_gst_flush_buffers(mc_gst_core_t *core)
{
- GstPad *pad;
-
- pad = gst_element_get_static_pad(core->appsrc, "src");
+ int ret = MC_ERROR_NONE;
- mc_async_queue_disable(core->available_queue->input);
+ MEDIACODEC_FENTER();
+ _mc_gst_set_flush_input(core);
+ ret = gst_pad_push_event(core->pipeline, gst_event_new_flush_start());
+ if (ret != MC_ERROR_NONE) {
+ LOGE("failed to send flush_start event");
+ }
- _mc_gst_set_flush_input ( core );
- gst_pad_push_event( pad, gst_event_new_flush_start());
- _mc_gst_set_flush_output ( core );
- gst_pad_push_event ( pad, gst_event_new_flush_stop (FALSE));
- gst_object_unref(pad);
+ ret = gst_pad_push_event(core->pipeline, gst_event_new_flush_stop(TRUE));
+ if (ret != MC_ERROR_NONE) {
+ LOGE("failed to send flush_stop event");
+ }
- mc_async_queue_enable(core->available_queue->input);
MEDIACODEC_FLEAVE();
}
media_packet_h pkt = NULL;
LOGI("_mc_gst_set_flush_input is called");
- while( pkt != mc_async_queue_pop_forced(core->available_queue->input) )
- {
+ while (pkt != mc_async_queue_pop_forced(core->available_queue->input)) {
LOGD("%p pkt is poped");
- if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
- {
+ if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) {
((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER])
(pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]);
}
}
mc_async_queue_flush(core->available_queue->input);
+ core->queued_count = 0;
}
static void _mc_gst_set_flush_output(mc_gst_core_t *core)
{
media_packet_h pkt = NULL;
- LOGI("_mc_gst_set_flush_output is called");
+ MEDIACODEC_FENTER();
g_mutex_lock(&core->ports[1]->mutex);
- if(!g_queue_is_empty(core->ports[1]->queue))
+ while(!g_queue_is_empty(core->ports[1]->queue))
{
- while(pkt != g_queue_pop_head(core->ports[1]->queue))
- {
- LOGD("outpkt in output_queue : %p", pkt);
+ pkt = g_queue_pop_head(core->ports[1]->queue);
+ LOGD("outpkt in output_queue : %p", pkt);
+ if (pkt) {
media_packet_destroy(pkt);
+ LOGD("outpkt destroyed");
+ pkt = NULL;
}
}
-
+ core->dequeued_count = 0;
g_mutex_unlock(&core->ports[1]->mutex);
+ MEDIACODEC_FLEAVE();
}
-#ifdef Z130H
-int __tbm_get_physical_addr_bo(tbm_bo_handle tbm_bo_handle_fd_t, int* phy_addr, int* phy_size)
+#ifdef TIZEN_PROFILE_LITE
+int __tbm_get_physical_addr_bo(tbm_bo_handle tbm_bo_handle_fd_t, int *phy_addr, int *phy_size)
{
int tbm_bo_handle_fd;
- int ret=0;
+ int ret = 0;
tbm_bo_handle_fd = tbm_bo_handle_fd_t.u32;
custom_data.cmd = 4;
custom_data.arg = (unsigned long)&mmu_data;
- ion_fd = open ("/dev/ion", open_flags);
- if (ion_fd < 0)
- {
- LOGE ("[tbm_get_physical_addr_bo] ion_fd open device failed");
+ ion_fd = open("/dev/ion", open_flags);
+ if (ion_fd < 0) {
+ LOGE("[tbm_get_physical_addr_bo] ion_fd open device failed");
}
- if (ioctl(ion_fd, ION_IOC_CUSTOM, &custom_data)<0)
- {
- LOGE ("[tbm_get_physical_addr_bo] ION_IOC_CUSTOM fails %d %s",errno,strerror(errno));
- ret=-1;
+ if (ioctl(ion_fd, ION_IOC_CUSTOM, &custom_data) < 0) {
+ LOGE("[tbm_get_physical_addr_bo] ION_IOC_CUSTOM failed");
+ ret = -1;
}
- if (!ret)
- {
+ if (!ret) {
*phy_addr = mmu_data.iova_addr;
*phy_size = mmu_data.iova_size;
- }
- else
- {
+ } else {
*phy_addr = 0;
*phy_size = 0;
- LOGW ("[tbm_get_physical_addr_bo] getting physical address is failed. phy_addr = 0");
+ LOGW("[tbm_get_physical_addr_bo] getting physical address is failed. phy_addr = 0");
}
- if (ion_fd != -1)
- {
- close (ion_fd);
+ if (ion_fd != -1) {
+ close(ion_fd);
ion_fd = -1;
}
int x_addr;
int trans_addr;
- pixel_x_m1 = x_size -1;
- pixel_y_m1 = y_size -1;
+ pixel_x_m1 = x_size - 1;
+ pixel_y_m1 = y_size - 1;
roundup_x = ((pixel_x_m1 >> 7) + 1);
x_addr = x_pos >> 2;
- if ((y_size <= y_pos+32) && ( y_pos < y_size) &&
+ if ((y_size <= y_pos+32) && (y_pos < y_size) &&
(((pixel_y_m1 >> 5) & 0x1) == 0) && (((y_pos >> 5) & 0x1) == 0)) {
- linear_addr0 = (((y_pos & 0x1f) <<4) | (x_addr & 0xf));
+ linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 6) & 0x3f));
if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
}
linear_addr0 = linear_addr0 << 2;
- trans_addr = (linear_addr1 <<13) | (bank_addr << 11) | linear_addr0;
+ trans_addr = (linear_addr1 << 13) | (bank_addr << 11) | linear_addr0;
return trans_addr;
}
temp1 = temp3-left;
/* real width is greater than or equal 256 */
if (temp1 >= 256) {
- for (i=top; i<yuv420_height-buttom; i=i+1) {
+ for (i = top; i < yuv420_height-buttom; i += 1) {
j = left;
temp3 = (j>>8)<<8;
temp3 = temp3>>6;
temp4 = 8;
} else {
temp2 = ((yuv420_height+31)>>5)<<5;
- if ((i+32)<temp2) {
+ if ((i + 32) < temp2) {
/* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
temp1 = temp3+2;
temp1 = (temp1>>2)<<2;
temp1 = ((yuv420_width+127)>>7)<<7;
tiled_offset = tiled_offset+temp4*(temp1>>6);
tiled_offset = tiled_offset<<11;
- tiled_offset1 = tiled_offset+2048*6;
+ tiled_offset1 = tiled_offset + 2048 * 6;
temp4 = 8;
} else {
/* even2 fomula: x+x_block_num*y */
j = (left>>8)<<8;
j = j + 256;
temp2 = yuv420_width-right-256;
- for (; j<=temp2; j=j+256) {
+ for (; j <= temp2; j += 256) {
memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
tiled_offset1 = tiled_offset1+temp4*2048;
memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
}
}
} else if (temp1 >= 64) {
- for (i=top; i<(yuv420_height-buttom); i=i+1) {
+ for (i = top; i < (yuv420_height-buttom); i += 1) {
j = left;
tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
temp2 = ((j+64)>>6)<<6;
}
}
} else {
- for (i=top; i<(yuv420_height-buttom); i=i+1) {
+ for (i = top; i < (yuv420_height-buttom); i += 1) {
linear_offset = temp1*(i-top);
- for (j=left; j<(yuv420_width-right); j=j+2) {
+ for (j = left; j < (yuv420_width - right); j += 2) {
tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
temp4 = j&0x3;
tiled_offset = tiled_offset+temp4;
}
}
-int _mc_check_out_bytestream (mc_gst_core_t *core, unsigned char *nal, int byte_length)
+void _mc_send_eos_signal(mc_gst_core_t *core)
{
- int ret = MC_ERROR_NONE;
- int stacked_length = 0;
- int nal_length = 0;
- unsigned int syntax = 0;
- int idr = 0;
- int nal_unit_type = 0;
- unsigned char tmp[1000000];
- unsigned char sps[100];
- unsigned char pps[100];
-
- mc_bitstream_t pstream;
-
- nal_unit_type = nal[2] == 1 ? (nal[3] & 0x1F) : (nal[4] & 0x1F);
-
- if ( nal_unit_type == 0x7 || nal_unit_type == 0x8 || nal_unit_type == 0x9 )
- {
- while (1)
- {
- nal_length = __mc_bytestream_to_nal( nal + stacked_length, byte_length - stacked_length, tmp);
-
- mc_init_bits (&pstream, nal + stacked_length, byte_length - stacked_length );
- mc_read_bits (&pstream, 32, &syntax);
- mc_read_bits (&pstream, 8, &syntax);
-
- LOGD("stacked_length : %d, byte_length : %d, nal_length : %d",
- stacked_length, byte_length, nal_length);
-
- switch ( syntax & 0x1F )
- {
- case NAL_SEQUENCE_PARAMETER_SET:
- LOGD("SPS is found : ", nal_length);
- core->sps_size = nal_length;
- memcpy(sps, tmp, nal_length);
- break;
- case NAL_PICTURE_PARAMETER_SET:
- LOGD("PPS is found : %d", nal_length);
- core->pps_size = nal_length;
- memcpy(pps, tmp, nal_length);
- break;
- case NAL_SLICE_IDR:
- LOGD ("IDR is found");
- idr++;
- core->idr_count++;
- break;
- default:
- LOGD ("%x nal_unit_type is detected");
- break;
- }
-
- stacked_length += nal_length;
-
- if ( stacked_length >= byte_length )
- break;
- }
- if( core->sps_size > 0 && core->pps_size > 0 ) {
- memcpy (core->codec_data, sps, core->sps_size);
- memcpy (core->codec_data+core->sps_size, pps, core->pps_size);
- core->codec_data_size = core->sps_size + core->pps_size;
- }
+ g_mutex_lock(&core->eos_mutex);
+ core->eos = FALSE;
+ g_cond_broadcast(&core->eos_cond);
+ g_mutex_unlock(&core->eos_mutex);
+ LOGD("send EOS signal");
+}
+void _mc_wait_for_eos(mc_gst_core_t *core)
+{
+ g_mutex_lock(&core->eos_mutex);
+ core->eos = TRUE;
+ LOGD("waiting for EOS");
+ while (core->eos) {
+ g_cond_wait(&core->eos_cond, &core->eos_mutex);
}
- else if ( nal_unit_type == 0x5 )
- {
- if ( !core->idr_count )
- core->need_codec_data = true;
- core->idr_count++;
- LOGD("IDR : %d", core->idr_count);
- }
- else
- {
- LOGD("nal_unit_type : %x", nal_unit_type);
- }
-
- return ret;
+ LOGD("received EOS");
+ g_mutex_unlock(&core->eos_mutex);
}
#include <media_codec_queue.h>
+#include <dlog.h>
-async_queue_t *mc_async_queue_new (void)
+async_queue_t *mc_async_queue_new(void)
{
async_queue_t *async_queue;
- async_queue = g_slice_new0 (async_queue_t);
+ async_queue = g_slice_new0(async_queue_t);
+ if (async_queue == NULL) {
+ LOGE("async_queue initialization failed");
+ return NULL;
+ }
- g_cond_init (&async_queue->condition);
+ g_cond_init(&async_queue->condition);
g_mutex_init(&async_queue->mutex);
async_queue->enabled = TRUE;
return async_queue;
}
-void mc_async_queue_free (async_queue_t * async_queue)
+void mc_async_queue_free(async_queue_t *async_queue)
{
- g_cond_clear (&async_queue->condition);
- g_mutex_clear (&async_queue->mutex);
+ g_cond_clear(&async_queue->condition);
+ g_mutex_clear(&async_queue->mutex);
- g_list_free (async_queue->head);
- g_slice_free (async_queue_t, async_queue);
+ g_list_free(async_queue->head);
+ g_slice_free(async_queue_t, async_queue);
}
-void mc_async_queue_push (async_queue_t * async_queue, gpointer data)
+void mc_async_queue_push(async_queue_t *async_queue, gpointer data)
{
- g_mutex_lock (&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
async_queue->tail = g_list_append(async_queue->tail, data);
- if(async_queue->tail->next)
+ if (async_queue->tail->next)
async_queue->tail = async_queue->tail->next;
else
async_queue->head = async_queue->tail;
async_queue->length++;
- g_cond_signal (&async_queue->condition);
- //LOGD("queue pushed : %p, %d, %p",queue, async_queue->length, data);
+ g_cond_signal(&async_queue->condition);
+ /*LOGD("queue pushed : %p, %d, %p",queue, async_queue->length, data);*/
- g_mutex_unlock (&async_queue->mutex);
+ g_mutex_unlock(&async_queue->mutex);
}
-gpointer mc_async_queue_pop (async_queue_t * async_queue)
+gpointer mc_async_queue_pop(async_queue_t *async_queue)
{
gpointer data = NULL;
- g_mutex_lock (&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
if (!async_queue->enabled) {
/* g_warning ("not enabled!"); */
}
if (!async_queue->head) {
- g_cond_wait (&async_queue->condition, &async_queue->mutex);
+ g_cond_wait(&async_queue->condition, &async_queue->mutex);
}
if (async_queue->head) {
data = node->data;
async_queue->head = node->next;
+
if (async_queue->head)
async_queue->head->prev = NULL;
else
async_queue->tail = NULL;
async_queue->length--;
- //LOGD("async queue poped : %p, %d, %p",queue, async_queue->length, data);
- g_list_free_1 (node);
+ /*LOGD("async queue poped : %p, %d, %p",queue, async_queue->length, data);*/
+ g_list_free_1(node);
}
leave:
- g_mutex_unlock (&async_queue->mutex);
+ g_mutex_unlock(&async_queue->mutex);
return data;
}
-gpointer mc_async_queue_pop_forced (async_queue_t * async_queue)
+gpointer mc_async_queue_pop_forced(async_queue_t *async_queue)
{
gpointer data = NULL;
- g_mutex_lock (&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
if (async_queue->head) {
GList *node = async_queue->head;
else
async_queue->tail = NULL;
async_queue->length--;
- //LOGD("async queue poped : %p, %d, %p",queue, async_queue->length, data);
- g_list_free_1 (node);
+ /*LOGD("async queue poped : %p, %d, %p",queue, async_queue->length, data);*/
+ g_list_free_1(node);
}
- g_mutex_unlock (&async_queue->mutex);
+ g_mutex_unlock(&async_queue->mutex);
return data;
}
-void mc_async_queue_disable (async_queue_t * async_queue)
+void mc_async_queue_disable(async_queue_t *async_queue)
{
- g_mutex_lock (&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
async_queue->enabled = FALSE;
- g_cond_broadcast (&async_queue->condition);
- g_mutex_unlock (&async_queue->mutex);
+ g_cond_broadcast(&async_queue->condition);
+ g_mutex_unlock(&async_queue->mutex);
}
-void mc_async_queue_enable (async_queue_t * async_queue)
+void mc_async_queue_enable(async_queue_t *async_queue)
{
- g_mutex_lock (&async_queue->mutex);
+ g_mutex_lock(&async_queue->mutex);
async_queue->enabled = TRUE;
- g_mutex_unlock (&async_queue->mutex);
+ g_mutex_unlock(&async_queue->mutex);
}
void mc_async_queue_flush(async_queue_t *async_queue)
unsigned char *pMem;
unsigned char *tmp;
- if((tmp = (unsigned char *)malloc(size + alignment)) != NULL)
- {
- pMem = (unsigned char*)((unsigned int)(tmp + alignment - 1) & (~(unsigned int)(alignment -1)));
+ if ((tmp = (unsigned char *)malloc(size + alignment)) != NULL) {
+ pMem = (unsigned char *)((unsigned int)(tmp + alignment - 1) & (~(unsigned int)(alignment - 1)));
- if(pMem == tmp)
+ if (pMem == tmp)
pMem += alignment;
*(pMem - 1) = (unsigned int)(pMem - tmp);
- return ((void*) pMem);
+ return ((void *) pMem);
}
return NULL;
}
{
unsigned char *ptr;
- if(mem == NULL)
+ if (mem == NULL)
return;
ptr = mem;
{
mc_sem_t *sem;
sem = g_new(mc_sem_t, 1);
- //sem->cond = g_cond_new();
g_cond_init(&sem->cond);
- //sem->mutex = g_mutex_new();
g_mutex_init(&sem->mutex);
sem->counter = 0;
void mc_sem_free(mc_sem_t *sem)
{
- //g_cond_free(sem->cond);
g_cond_clear(&sem->cond);
- //g_mutex_free(sem->mutex);
g_mutex_clear(&sem->mutex);
g_free(sem);
}
{
g_mutex_lock(&sem->mutex);
- while(sem->counter == 0)
+ while (sem->counter == 0)
g_cond_wait(&sem->cond, &sem->mutex);
sem->counter--;
{
int i;
unsigned char buff[17];
- unsigned char *pc = (unsigned char*)addr;
+ unsigned char *pc = (unsigned char *)addr;
if (desc != NULL)
printf("%s:\n", desc);
- for (i = 0; i < len; i++)
- {
+ for (i = 0; i < len; i++) {
- if ((i % 16) == 0)
- {
+ if ((i % 16) == 0) {
if (i != 0)
printf(" %s\n", buff);
#include <glib.h>
#include <Elementary.h>
#include <appcore-efl.h>
+#include <gst/gst.h>
#include <media_codec.h>
#include <media_packet.h>
-#include <media_codec_queue.h> // !!!! remove it
-#include <media_codec_port.h> // !!!! remove it
-
-//#include <media_codec_private.h>
-//#include <media_codec_port_general.h>
-//#include <media_codec_port_omx.h>
-//#include <media_codec_port.h>
-//#include <media_codec_util.h>
+#include <tbm_surface.h>
+#include <dlog.h>
+#include <time.h>
#define PACKAGE "media_codec_test"
-#define TEST_FILE_SIZE (10 * 1024 * 1024) //10M - test case
-#define MAX_STRING_LEN 256
-#define MAX_HANDLE 10
-#define DEFAULT_OUT_BUF_WIDTH 640
-#define DEFAULT_OUT_BUF_HEIGHT 480
-#define OUTBUF_SIZE (DEFAULT_OUT_BUF_WIDTH * DEFAULT_OUT_BUF_HEIGHT * 3 / 2)
+#define MAX_HANDLE 4
+//#define DUMP_OUTBUF 1
+#define TEST_FILE_SIZE (10 * 1024 * 1024)
+#define MAX_STRING_LEN 256
#define DEFAULT_SAMPPLERATE 44100
#define DEFAULT_CHANNEL 2
-#define DEFAULT_BIT 16
-#define DEFAULT_BITRATE 128
-#define DEFAULT_SAMPLEBYTE 1024
-#define ADTS_HEADER_SIZE 7
+#define DEFAULT_BIT 16
+#define DEFAULT_BITRATE 128
+#define DEFAULT_SAMPLEBYTE 1024
+#define ADTS_HEADER_SIZE 7
+#define AMRNB_PCM_INPUT_SIZE 320
+#define AMRWB_PCM_INPUT_SIZE 640
-/*
- * 0 (disable) : used in (*.aac_lc, adts)
- * 1 (enable) : used in (*.m4a, mp4), Need "codec_data"
- * TODO : AUDIO_CODECDATA_SIZE is temporal size (16byte) for codec_data
- */
-#if 1
- #define HE_AAC_V12_ENABLE 1
- #define AUDIO_CODECDATA_SIZE 16
-#endif
+#define CHECK_BIT(x, y) (((x) >> (y)) & 0x01)
+#define GET_IS_ENCODER(x) CHECK_BIT(x, 0)
+#define GET_IS_DECODER(x) CHECK_BIT(x, 1)
+#define GET_IS_HW(x) CHECK_BIT(x, 2)
+#define ES_DEFAULT_VIDEO_PTS_OFFSET 33000000
+#define CHECK_VALID_PACKET(state, expected_state) \
+ ((state & (expected_state)) == (expected_state))
-#define DUMP_OUTBUF 1
-#define MAX_INPUT_BUF_NUM 20
-#define USE_INPUT_QUEUE 1
+static int samplerate = DEFAULT_SAMPPLERATE;
+static int channel = DEFAULT_CHANNEL;
+static int bit = DEFAULT_BIT;
+static int bitrate = DEFAULT_BITRATE;
+static int samplebyte = DEFAULT_SAMPLEBYTE;
+unsigned char buf_adts[ADTS_HEADER_SIZE];
+enum
+{
+ MC_EXIST_SPS = 1 << 0,
+ MC_EXIST_PPS = 1 << 1,
+ MC_EXIST_IDR = 1 << 2,
+ MC_EXIST_SLICE = 1 << 3,
-//extern int file_handle_args (int argc, char ** argv, int flag);
+ MC_VALID_HEADER = ( MC_EXIST_SPS | MC_EXIST_PPS ),
+ MC_VALID_FIRST_SLICE = ( MC_EXIST_SPS | MC_EXIST_PPS | MC_EXIST_IDR )
+};
-/*
- * Test MAIN
- */
+typedef struct _App App;
enum
{
CURRENT_STATUS_SET_SIZE,
};
-int g_menu_state = CURRENT_STATUS_MAINMENU;
-int g_handle_num = 1;
-static mediacodec_h g_media_codec[MAX_HANDLE] = {0};
-char g_uri[MAX_STRING_LEN];
-FILE *fp_src = NULL;
-media_format_h input_fmt = NULL;
-#if USE_INPUT_QUEUE
-//media_packet_h *input_buf = NULL;
-media_packet_h input_buf[MAX_INPUT_BUF_NUM];
-#else
-media_packet_h in_buf = NULL;
-#endif
-media_packet_h output_buf = NULL;
-//async_queue_t *input_avaliable = NULL;
-GQueue input_available;
-
-uint64_t pts = 0;
-
-static int width = DEFAULT_OUT_BUF_WIDTH;
-static int height = DEFAULT_OUT_BUF_HEIGHT;
-static float fps = 0;
-static int target_bits = 0;
+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
+} nal_unit_type;
+
+typedef enum
+{
+ VIDEO_DEC,
+ VIDEO_ENC,
+ AUDIO_DEC,
+ AUDIO_ENC
+}type_e;
-static int samplerate = DEFAULT_SAMPPLERATE;
-static int channel = DEFAULT_CHANNEL;
-static int bit = DEFAULT_BIT;
-static int bitrate = DEFAULT_BITRATE;
-static int samplebyte = DEFAULT_SAMPLEBYTE;
-unsigned char buf_adts[ADTS_HEADER_SIZE];
-unsigned char sps[100];
-unsigned char pps[100];
-unsigned char tmp_buf[1000000];
-static int sps_len, pps_len;
+struct _App
+{
+ GMainLoop *loop;
+ guint sourceid;
+
+ GMappedFile *file;
+ guint8 *data;
+ gsize length;
+ guint64 offset;
+ guint obj;
+
+ GTimer *timer;
+ long start;
+ long finish;
+ long process_time;
+ int frame_count;
+
+ int codecid;
+ int flag;
+ bool is_video[MAX_HANDLE];
+ bool is_encoder[MAX_HANDLE];
+ bool hardware;
+ type_e type;
+ /* video */
+ mediacodec_h mc_handle[MAX_HANDLE];
+ guint width;
+ guint height;
+ guint fps;
+ guint target_bits;
+ media_format_mimetype_e mime;
+
+ /* Audio */
+ guint samplerate;
+ guint channel;
+ guint bit;
+ guint bitrate;
+ bool is_amr_nb;
+
+
+ /* Render */
+ guint w;
+ guint h;
+ Evas_Object *win;
+ Evas_Object *img;
+ media_packet_h packet;
+ Ecore_Pipe *pipe;
+ //camera_h camera_handle;
+ GList *packet_list;
+ GMutex lock;
+};
-media_format_mimetype_e mimetype;
+App s_app;
-int use_video = 0;
-int use_encoder = 0;
-int frame_count = 0;
+media_format_h aenc_fmt = NULL;
+media_format_h adec_fmt = NULL;
+media_format_h vdec_fmt = NULL;
+media_format_h venc_fmt = NULL;
#if DUMP_OUTBUF
FILE *fp_out = NULL;
#endif
-//static gpointer _feed_pa(gpointer data);
+
+/* Internal Functions */
+static int _create_app(void *data);
+static int _terminate_app(void *data);
+static void displaymenu(void);
static void display_sub_basic();
-static int _mediacodec_get_output(void);
-static void _mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data);
-static void _mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data);
+
+/* For debugging */
+static void mc_hex_dump(char *desc, void *addr, int len);
+static void decoder_output_dump(App *app, media_packet_h pkt);
+
+/* */
+
+void (*extractor)(App *app, unsigned char** data, int *size, bool *have_frame);
+
+int g_menu_state = CURRENT_STATUS_MAINMENU;
static int _create_app(void *data)
{
printf("My app is going alive!\n");
+ App *app = (App*)data;
+
+ g_mutex_init(&app->lock);
return 0;
}
static int _terminate_app(void *data)
{
printf("My app is going gone!\n");
+ App *app = (App*)data;
+
+ g_mutex_clear(&app->lock);
return 0;
}
.terminate = _terminate_app,
};
-unsigned int bytestream2nalunit(FILE *fd, unsigned char* nal)
+static const guint mp3types_bitrates[2][3][16] = {
+{
+ {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
+ {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
+ },
+{
+ {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
+ {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
+ {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
+ },
+};
+
+static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},
+ {22050, 24000, 16000},
+ {11025, 12000, 8000}
+};
+
+void h264_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
int nal_length = 0;
- size_t result;
- int read_size = 1;
- unsigned char buffer[1000000];
- unsigned char val, zero_count, i;
- int nal_unit_type;
- int init;
+ unsigned char val, zero_count;
+ //unsigned char *pNal = data;
+ unsigned char *pNal = app->data + app->offset;
+ int max = app->length - app->offset;
+ int i = 0;
+ int index = 0;
+ int nal_unit_type = 0;
+ bool init;
+ bool slice;
+ bool idr;
+ static int state;
+ int read;
zero_count = 0;
- if (feof(fd))
- return -1;
- result = fread(buffer, 1, read_size, fd);
-
- if(result != read_size)
- {
- //exit(1);
- return -1;
- }
- val = buffer[0];
+ val = pNal[index++];
while (!val)
{
- if ((zero_count == 2 || zero_count == 3) && val == 1)
- {
- break;
- }
zero_count++;
- result = fread(buffer, 1, read_size, fd);
-
- if(result != read_size)
- {
- break;
- }
- val = buffer[0];
+ val = pNal[index++];
}
- nal[nal_length++] = 0;
- nal[nal_length++] = 0;
- nal[nal_length++] = 0;
- nal[nal_length++] = 1;
+
zero_count = 0;
- init = 1;
- while(1)
- {
- if (feof(fd))
- return nal_length;
- result = fread(buffer, 1, read_size, fd);
- if(result != read_size)
- {
- break;
+ while (1)
+ {
+ if (index >= max) {
+ read = (index - 1);
+ goto DONE;
}
- val = buffer[0];
- if(init) {
- nal_unit_type = val & 0xf;
- init = 0;
- }
+ val = pNal[index++];
+
if (!val)
- {
zero_count++;
- }
- else
- {
- if ((zero_count == 2 || zero_count == 3 || zero_count == 4) && (val == 1))
- {
+ else {
+ if ((zero_count >= 2) && (val == 1))
break;
- }
- else
- {
- for (i = 0; i<zero_count; i++)
- {
- nal[nal_length++] = 0;
- }
- nal[nal_length++] = val;
+ else {
zero_count = 0;
}
}
}
- fseek(fd, -(zero_count + 1), SEEK_CUR);
+ if( zero_count > 3 )
+ zero_count = 3;
- if (nal_unit_type == 0x7)
- {
- sps_len = nal_length;
- memcpy(sps, nal, nal_length);
- return 0;
- }
- else if (nal_unit_type == 0x8)
- {
- pps_len = nal_length;
- memcpy(pps, nal, nal_length);
- return 0;
- }
- else if (nal_unit_type == 0x5)
+ read = ( index - zero_count - 1);
+
+ nal_unit_type = *(app->data+app->offset+4) & 0x1F;
+ g_print("nal_unit_type : %x\n", nal_unit_type);
+
+ switch ( nal_unit_type )
{
- memcpy(tmp_buf, nal, nal_length);
- memcpy(nal, sps, sps_len);
- memcpy(nal + sps_len, pps, pps_len);
- memcpy(nal + sps_len + pps_len, tmp_buf, nal_length);
- nal_length += sps_len + pps_len;
+ case NAL_SEQUENCE_PARAMETER_SET:
+ g_print("nal_unit_type : SPS\n");
+ state |= MC_EXIST_SPS;
+ break;
+ case NAL_PICTURE_PARAMETER_SET:
+ g_print("nal_unit_type : PPS\n");
+ state |= MC_EXIST_PPS;
+ break;
+ case NAL_SLICE_IDR:
+ case NAL_SEI:
+ g_print ("nal_unit_type : IDR\n");
+ state |= MC_EXIST_IDR;
+ break;
+ case NAL_SLICE_NO_PARTITIONING:
+ case NAL_SLICE_PART_A:
+ case NAL_SLICE_PART_B:
+ case NAL_SLICE_PART_C:
+ state |= MC_EXIST_SLICE;
+ break;
+ default:
+ g_print ("nal_unit_type : %x", nal_unit_type);
+ break;
}
- return nal_length;
+ init = CHECK_VALID_PACKET(state, MC_VALID_FIRST_SLICE) ? 1 :0;
+ slice = CHECK_VALID_PACKET(state, MC_EXIST_SLICE) ? 1 :0;
+ idr = CHECK_VALID_PACKET(state, MC_EXIST_IDR) ? 1 : 0;
+ g_print("status : %d, slice : %d, idr : %d\n", init, slice, idr);
+
+ if (init || idr || slice) {
+ *have_frame = TRUE;
+ if (init) {
+ *data = app->data;
+ *size = app->offset + read;
+ } else {
+ *data = app->data+app->offset;
+ *size = read;
+ }
+ state = 0;
+ } else {
+ *data = app->data+app->offset;
+ *size = read;
+ //app->offset += read;
+ }
+DONE:
+ app->offset += read;
}
-unsigned int bytestream2yuv420(FILE *fd, unsigned char* yuv)
+void nv12_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
+{
+ int yuv_size;
+ int offset = app->length - app->offset;
+
+ yuv_size = app->width * app->height * 3 / 2;
+
+ if (offset >= yuv_size)
+ *size = offset;
+
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
+
+ if (offset >= yuv_size)
+ *size = offset;
+ else
+ *size = yuv_size;
+}
+
+void yuv_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
+{
+ int yuv_size;
+ int offset = app->length - app->offset;
+
+ yuv_size = app->width * app->height * 3 / 2;
+
+ if (yuv_size >= offset)
+ *size = offset;
+
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
+
+ if (yuv_size >= offset)
+ *size = offset;
+ else
+ *size = yuv_size;
+
+ app->offset += *size;
+
+}
+
+void aacenc_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- size_t result;
int read_size;
- unsigned char buffer[1000000];
+ int offset = app->length - app->offset;
- if (feof(fd))
- return 0;
+ read_size = ((samplebyte*app->channel)*(app->bit/8));
- read_size = width*height*3/2;
- result = fread(buffer, 1,read_size, fd);
- if(result != read_size)
- {
- //exit(1);
- return -1;
- }
+ *have_frame = TRUE;
- memcpy(yuv, buffer, width*height*3/2);
+ if (offset >= read_size)
+ *size = offset;
+ else
+ *size = read_size;
- return width*height*3/2;
+ app->offset += *size;
}
+void amrenc_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
+{
+ int read_size;
+ int offset = app->length - app->offset;
+
+ if(app->is_amr_nb)
+ read_size = AMRNB_PCM_INPUT_SIZE;
+ else
+ read_size = AMRWB_PCM_INPUT_SIZE;
+
+ *have_frame = TRUE;
+
+ if (offset >= read_size)
+ *size = offset;
+ else
+ *size = read_size;
+
+ app->offset += *size;
+}
/**
- * Extract Input data for MP3 decoder
- * (MPEG-1/2/2.5 layer 3)
- * As-Is : Extractor code support only mp3 file exclude ID3tag, So mp3 file should start mp3 sync format. (0xffe0)
- * To-Be : Will support mp3 file include ID3tag (v1,v2)
+ * Extract Input data for AAC decoder
+ * (case of (LC profile) ADTS format)
+ * codec_data : Don't need
**/
-
-static const guint mp3types_bitrates[2][3][16] = {
+void aacdec_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
- {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
- {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
- },
-{
- {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
- {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
- {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
- },
-};
+ int read_size;
+ int offset = app->length - app->offset;
+ unsigned char *pData = app->data + app->offset;
-static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},
- {22050, 24000, 16000},
- {11025, 12000, 8000}
-};
+ if ((pData != NULL) && (pData[0] == 0xff) && ((pData[1] & 0xf6) == 0xf0)) {
+ read_size = ((pData[3] & 0x03) << 11) | (pData[4] << 3) | ((pData[5] & 0xe0) >> 5);
+ } else {
+ read_size = 0;
+ g_print("[FAIL] Not found aac frame sync.....\n");
+ }
+
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
+
+ if (read_size >= offset)
+ *size = offset;
+ else
+ *size = read_size;
+
+ app->offset += *size;
+
+}
-unsigned int extract_input_mp3dec(FILE *fd, unsigned char* mp3data)
+void mp3dec_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- int readsize;
- size_t result;
- unsigned char buffer[1000000];
+ int read_size;
guint header;
guint padding, bitrate, lsf, layer, mpg25;
guint hdr_bitrate, sf;
+ int offset = app->length - app->offset;
+ unsigned char *pData = app->data + app->offset;
- if (feof(fd))
- return 0;
+ header = GST_READ_UINT32_BE(pData);
- result = fread(buffer, 1, 4, fd); //mp3 header
- if(result != 4) {
- g_print ("[ERROR] fread size is %d\n", result);
- return -1;
- }
- header = GST_READ_UINT32_BE (buffer);
-#if 1 //normal extract code
if (header == 0) {
g_print ("[ERROR] read header size is 0\n");
- return -1;
+ *have_frame = FALSE;
}
/* if it's not a valid sync */
if ((header & 0xffe00000) != 0xffe00000) {
g_print ("[ERROR] invalid sync\n");
- return -1;
+ *have_frame = FALSE;
}
- /* if it's an invalid MPEG version */
if (((header >> 19) & 3) == 0x1) {
g_print ("[ERROR] invalid MPEG version: %d\n", (header >> 19) & 3);
- return -1;
+ *have_frame = FALSE;
} else {
if (header & (1 << 20)) {
lsf = (header & (1 << 19)) ? 0 : 1;
/* if it's an invalid layer */
if (!((header >> 17) & 3)) {
g_print("[ERROR] invalid layer: %d\n", (header >> 17) & 3);
- return -1;
+ *have_frame = FALSE;
} else {
layer = 4 - ((header >> 17) & 0x3);
}
/* if it's an invalid bitrate */
if (((header >> 12) & 0xf) == 0xf) {
g_print ("[ERROR] invalid bitrate: %d\n", (header >> 12) & 0xf);
- return -1;
+ *have_frame = FALSE;
} else {
bitrate = (header >> 12) & 0xF;
hdr_bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;
/* The caller has ensured we have a valid header, so bitrate can't be zero here. */
if(hdr_bitrate == 0)
- return -1;
+ *have_frame = FALSE;
}
/* if it's an invalid samplerate */
if (((header >> 10) & 0x3) == 0x3) {
g_print ("[ERROR] invalid samplerate: %d\n", (header >> 10) & 0x3);
- return -4;
+ *have_frame = FALSE;
} else {
sf = (header >> 10) & 0x3;
sf = mp3types_freqs[lsf + mpg25][sf];
switch (layer) {
case 1:
- readsize = 4 * ((hdr_bitrate * 12) / sf + padding);
+ read_size = 4 * ((hdr_bitrate * 12) / sf + padding);
break;
case 2:
- readsize = (hdr_bitrate * 144) / sf + padding;
+ read_size = (hdr_bitrate * 144) / sf + padding;
break;
default:
case 3:
- readsize = (hdr_bitrate * 144) / (sf << lsf) + padding;
+ read_size = (hdr_bitrate * 144) / (sf << lsf) + padding;
break;
}
-#else //simple extract code - hard coding test code for supporting only 'test.mp3'
- readsize = 1044 + ((header >> 9) & 0x1); //only simple test => (1044 + padding)
-#endif
-
- if (readsize > 0) {
- result = fread(buffer+4, 1, (readsize - 4), fd);
- memcpy(mp3data, buffer,readsize);
- } else {
- readsize = 0;
- g_print("[FAIL] Not found mp3 frame sync.....\n");
- }
-
- return readsize;
-}
-
-
-/**
- * Extract Input data for AAC decoder
- * (case of (LC profile) ADTS format)
- * codec_data : Don't need
- **/
-unsigned int extract_input_aacdec(FILE *fd, unsigned char* aacdata)
-{
- int readsize;
- size_t result;
- unsigned int hader_size = ADTS_HEADER_SIZE;
- unsigned char buffer[1000000];
-
- if (feof(fd))
- return 0;
+ g_print("header : %d, read : %d\n", header, read_size);
- result = fread(buffer, 1, hader_size, fd); //adts header
- if(result != hader_size)
- {
- exit(1);
- }
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
- if ((buffer != NULL) && (buffer[0] == 0xff) && ((buffer[1] & 0xf6) == 0xf0)) {
- readsize = ((buffer[3] & 0x03) << 11) | (buffer[4] << 3) | ((buffer[5] & 0xe0) >> 5);
- result = fread(buffer + hader_size, 1,(readsize - hader_size), fd);
- memcpy(aacdata, buffer, readsize);
- } else {
- readsize = 0;
- g_print("[FAIL] Not found aac frame sync.....\n");
- }
+ if (read_size >= offset)
+ *size = offset;
+ else
+ *size = read_size;
- return readsize;
+ app->offset += *size;
}
-
-#ifdef HE_AAC_V12_ENABLE
-/**
- * Extract Input data for AAC decoder
- * (case of (AAC+/EAAC+ profile) RAW format)
- * codec_data : Need
- * profile : AAC_LC(2) AAC_HE(5), AAC_HE_PS (29)
- **/
-unsigned int extract_input_aacdec_m4a_test(FILE *fd, unsigned char* aacdata)
+#if 0
+void extract_input_aacdec_m4a_test(App *app, unsigned char* data, int *size, bool *have_frame)
{
int readsize = 0;
size_t result;
- unsigned int hader_size = ADTS_HEADER_SIZE;
+ unsigned int header_size = ADTS_HEADER_SIZE;
unsigned char buffer[1000000];
- unsigned char codecdata[AUDIO_CODECDATA_SIZE] = {0,};
+ unsigned char codecdata[AAC_CODECDATA_SIZE] = {0,};
+
+ /*
+ * It is not support full parsing MP4 container box.
+ * So It MUST start as RAW valid frame sequence.
+ * Testsuit that are not guaranteed to be available on functionality of all General DEMUXER/PARSER.
+ */
if (feof(fd))
return 0;
*/
#if 1
/*
+ * The codec_data data is according to AudioSpecificConfig,
+ * ISO/IEC 14496-3, 1.6.2.1
+ *
* below example is test for using "test.aac" or "TestSample-AAC-LC.m4a"
* case : M4A - LC profile
* codec_data=(buffer)119056e5000000000000000000000000
codecdata[6] = 0x80;
#endif
- memcpy(aacdata, codecdata, AUDIO_CODECDATA_SIZE);
+ memcpy(aacdata, codecdata, AAC_CODECDATA_SIZE);
- result = fread(buffer, 1, hader_size, fd); //adts header
- if(result != hader_size)
+ result = fread(buffer, 1, header_size, fd); //adts header
+ if(result != header_size)
{
- exit(1);
+ return -1;
}
if ((buffer != NULL) && (buffer[0] == 0xff) && ((buffer[1] & 0xf6) == 0xf0)) {
readsize = ((buffer[3] & 0x03) << 11) | (buffer[4] << 3) | ((buffer[5] & 0xe0) >> 5);
- readsize = readsize -hader_size;
+ readsize = readsize -header_size;
result = fread(buffer, 1, readsize, fd); //Make only RAW data, so exclude header 7 bytes
- memcpy(aacdata+AUDIO_CODECDATA_SIZE, buffer, readsize);
+ memcpy(aacdata+AAC_CODECDATA_SIZE, buffer, readsize);
}
- g_print( "[example] Insert 'codec_data' in 1st frame buffer size (%d)\n", readsize+AUDIO_CODECDATA_SIZE);
- return (readsize + AUDIO_CODECDATA_SIZE); //return combination of (codec_data + raw_data)
+ g_print( "[example] Insert 'codec_data' in 1st frame buffer size (%d)\n", readsize+AAC_CODECDATA_SIZE);
+ return (readsize + AAC_CODECDATA_SIZE); //return combination of (codec_data + raw_data)
}
- result = fread(buffer, 1, hader_size, fd); //adts header
- if(result != hader_size)
+ result = fread(buffer, 1, header_size, fd); //adts header
+ if(result != header_size)
{
exit(1);
}
if ((buffer != NULL) && (buffer[0] == 0xff) && ((buffer[1] & 0xf6) == 0xf0)) {
readsize = ((buffer[3] & 0x03) << 11) | (buffer[4] << 3) | ((buffer[5] & 0xe0) >> 5);
- readsize = readsize -hader_size;
+ readsize = readsize -header_size;
result = fread(buffer, 1, readsize, fd); //Make only RAW data, so exclude header 7 bytes
memcpy(aacdata, buffer, readsize);
} else {
}
#endif
-
/**
- * Extract Input data for AMR-NB/WB decoder
- * - AMR-NB : mime type ("audio/AMR") / 8Khz / 1 ch / 16 bits
- * - AMR-WB : mime type ("audio/AMR-WB") / 16Khz / 1 ch / 16 bits
+ * Extract Input data for AAC encoder
**/
-static const char AMR_header [] = "#!AMR\n";
-static const char AMRWB_header [] = "#!AMR-WB\n";
-#define AMR_NB_MIME_HDR_SIZE 6
-#define AMR_WB_MIME_HDR_SIZE 9
-static const int block_size_nb[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
-static const int block_size_wb[16] = { 17, 23, 32, 36, 40, 46, 50, 58, 60, 5, -1, -1, -1, -1, 0, 0 };
-int *blocksize_tbl;
-
-unsigned int extract_input_amrdec(FILE *fd, unsigned char* amrdata)
+/*
+void aacenc_extractor(App *app, unsigned char **data, int *size, bool *have_frame)
{
- int readsize = 0;
- size_t result;
- unsigned int mime_size = AMR_NB_MIME_HDR_SIZE;
- unsigned char buffer[1000000];
- unsigned int fsize, mode;
+ int read_size;
+ int offset = app->length - app->offset;
- if (feof(fd))
- return 0;
+ read_size = ((DEFAULT_SAMPLEBYTE*DEFAULT_CHANNEL)*(DEFAULT_BIT/8));
- if (frame_count == 0)
- {
- /* Check if the given data contains an AMR mime header. */
- result = fread(buffer, 1, mime_size, fd); //amr-nb header
- if(result != mime_size)
- exit(1);
+ if (read_size >= offset)
+ *size = offset;
- if ( !memcmp (buffer, AMR_header, AMR_NB_MIME_HDR_SIZE))
- {
- blocksize_tbl = (int *)block_size_nb;
- g_print("[----AMR-NB mime header detected----]\n");
- }
- else
- {
- result = fread(buffer + mime_size, 1, 3, fd); //need more (3) bytes for checking amr-wb mime header
- if (!memcmp (buffer, AMRWB_header, AMR_WB_MIME_HDR_SIZE))
- {
- mime_size = AMR_WB_MIME_HDR_SIZE;
- blocksize_tbl = (int *)block_size_wb;
- g_print("[----AMR-WB mime header detected----]\n");
- }
- else
- {
- g_print("[ERROR] AMR-NB/WB don't detected..\n");
- return 0;
- }
- }
- }
+ *have_frame = TRUE;
+ *data = app->data + app->offset;
- result = fread(buffer, 1, 1, fd); /* mode byte check */
- if(result != 1)
- exit(1);
- if ((buffer[0] & 0x83) == 0)
+ if (read_size >= offset)
+ *size = offset;
+ else
+ *size = read_size;
+
+ app->offset += *size;
+}
+*/
+static void _mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
+{
+ if (pkt != NULL)
{
- mode = (buffer[0] >> 3) & 0x0F; /* Yep. Retrieve the frame size */
- fsize = blocksize_tbl[mode];
-
- result = fread(buffer+1, 1, fsize, fd); /* +1 for the previous mode byte */
- if(result != fsize)
- exit(1);
- memcpy(amrdata, buffer, fsize);
- readsize = fsize + 1;
- } else {
- readsize = 0;
- g_print("[FAIL] Not found amr frame sync.....\n");
+ g_print("Used input buffer = %p\n", pkt);
+ media_packet_destroy(pkt);
}
-
- return readsize;
+ return;
}
-
-/**
- * Extract Input data for AAC encoder
- **/
-unsigned int extract_input_aacenc(FILE *fd, unsigned char* rawdata)
+int _mediacodec_set_codec(int codecid, int flag, int *hardware)
{
- int readsize;
- size_t result;
- unsigned char buffer[1000000];
-
- if (feof(fd))
- return 0;
-
- readsize = ((samplebyte*channel)*(bit/8));
- result = fread(buffer, 1, readsize, fd);
- if(result != readsize)
- {
- exit(1);
- }
-
- memcpy(rawdata, buffer,readsize);
-
- return readsize;
-}
-
-/**
- * Add ADTS header at the beginning of each and every AAC packet.
- * 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(unsigned char *buffer, int packetLen) {
- int profile = 2; //AAC LC (0x01)
- int freqIdx = 3; //48KHz (0x03)
- int chanCfg = 2; //CPE (0x02)
-
- if (samplerate == 96000) freqIdx = 0;
- else if (samplerate == 88200) freqIdx = 1;
- else if (samplerate == 64000) freqIdx = 2;
- else if (samplerate == 48000) freqIdx = 3;
- else if (samplerate == 44100) freqIdx = 4;
- else if (samplerate == 32000) freqIdx = 5;
- else if (samplerate == 24000) freqIdx = 6;
- else if (samplerate == 22050) freqIdx = 7;
- else if (samplerate == 16000) freqIdx = 8;
- else if (samplerate == 12000) freqIdx = 9;
- else if (samplerate == 11025) freqIdx = 10;
- else if (samplerate == 8000) freqIdx = 11;
-
- if ((channel == 1) || (channel == 2))
- chanCfg = 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;
-}
-
-
-/**
- * Extract Input data for AMR-NB/WB encoder
- * But, WB encoder is not support because we don't have WB decoder for reference.
- **/
-#define AMRNB_PCM_INPUT_SIZE 320
-#define AMRWB_PCM_INPUT_SIZE 640
-#define AMRNB_ENC_TEST 1 /* 1: AMR-NB , 0: AMR-WB*/
-int write_amr_header = 1; /* write magic number for AMR Header at one time */
-unsigned int extract_input_amrenc(FILE *fd, unsigned char* rawdata, int is_amr_nb)
-{
- int readsize;
- size_t result;
- unsigned char buffer[1000000];
-
- if (feof(fd))
- return 0;
-
- if (is_amr_nb)
- readsize = AMRNB_PCM_INPUT_SIZE;
- else
- readsize = AMRWB_PCM_INPUT_SIZE;
-
- result = fread(buffer, 1, readsize, fd);
- if(result != readsize)
- {
- exit(1);
- }
-
- memcpy(rawdata, buffer,readsize);
-
- if (frame_count == 0)
- {
- g_print("amr encoder input size (%d) - NB(320) / WB(640)\n", readsize);
+ bool encoder;
+ //bool hardware;
+ media_format_mimetype_e mime;
+ encoder = GET_IS_ENCODER(flag) ? 1 : 0;
+ *hardware = GET_IS_HW(flag) ? 1 : 0;
+
+ switch (codecid) {
+ case MEDIACODEC_H264:
+ if (encoder) {
+ extractor = yuv_extractor;
+ mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
+ } else {
+ extractor = h264_extractor;
+ mime = MEDIA_FORMAT_H264_SP;
+ }
+ break;
+ case MEDIACODEC_MPEG4:
+ if (encoder) {
+ extractor = yuv_extractor;
+ mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
+ } else {
+ extractor = h264_extractor;
+ mime = MEDIA_FORMAT_MPEG4_SP;
+ }
+ break;
+ case MEDIACODEC_H263:
+ if (encoder) {
+ extractor = yuv_extractor;
+ mime = *hardware ? MEDIA_FORMAT_NV12 : MEDIA_FORMAT_I420;
+ } else {
+ extractor = h264_extractor;
+ mime = MEDIA_FORMAT_H263P;
+ }
+ break;
+ case MEDIACODEC_AAC:
+ if (encoder) {
+ extractor = aacenc_extractor;
+ mime = MEDIA_FORMAT_PCM;
+ } else {
+ extractor = aacdec_extractor;
+ mime = MEDIA_FORMAT_AAC;
+ }
+ break;
+ case MEDIACODEC_AAC_HE:
+ if (encoder) {
+ extractor = aacenc_extractor;
+ mime = MEDIA_FORMAT_PCM;
+ } else {
+ //extractor = aacdec_extractor;
+ mime = MEDIA_FORMAT_AAC_HE;
+ }
+ break;
+ case MEDIACODEC_AAC_HE_PS:
+ break;
+ case MEDIACODEC_MP3:
+ extractor = mp3dec_extractor;
+ mime = MEDIA_FORMAT_MP3;
+ break;
+ case MEDIACODEC_VORBIS:
+ break;
+ case MEDIACODEC_FLAC:
+ break;
+ case MEDIACODEC_WMAV1:
+ break;
+ case MEDIACODEC_WMAV2:
+ break;
+ case MEDIACODEC_WMAPRO:
+ break;
+ case MEDIACODEC_WMALSL:
+ break;
+ default:
+ LOGE("NOT SUPPORTED!!!!");
+ break;
}
-
- return readsize;
+ //media_format_set_video_mime(vdec_fmt, mime);
+ return mime;
}
-
-static void input_filepath(char *filename)
+static gboolean read_data(App *app)
{
- int len = strlen(filename);
- int i = 0;
-
- if(len < 0 || len > MAX_STRING_LEN)
- return;
-
- for(i = 0; i < g_handle_num; i++)
- {
- if(g_media_codec[i] != NULL)
- {
- mediacodec_unprepare(g_media_codec[i]);
- mediacodec_destroy(g_media_codec[i]);
- g_media_codec[i] = NULL;
+ guint len;
+ bool have_frame = FALSE;
+ int ret;
+ static guint64 pts = 0L;
+ void *buf_data_ptr = NULL;
+ media_packet_h pkt = NULL;
+ unsigned char *tmp;
+ int read;
+ int plane_num;
+ int offset;
+ int stride_width, stride_height;
+
+ g_print("----------read data------------\n");
+ //read = extractor(app, app->data + app->offset, app->length - app->offset );
+ extractor(app, &tmp, &read, &have_frame);
+
+ if ( app->offset >= app->length - 1 ) {
+ /* EOS */
+ //media_packet_set_flags(in_buf, MEDIA_PACKET_END_OF_STREAM);
+ g_print("EOS\n");
+ app->finish = clock();
+ g_main_loop_quit (app->loop);
+ return FALSE;
+ }
+ g_print("length : %d, offset : %d\n", app->length, app->offset);
+
+ if ( app->offset + len > app->length )
+ len = app->length - app->offset;
+
+ g_print("%p, %d, have_frame :%d, read: %d\n", tmp, (int)read, have_frame, read);
+
+ if (have_frame) {
+ if (media_packet_create_alloc(vdec_fmt, NULL, NULL, &pkt) != MEDIA_PACKET_ERROR_NONE) {
+ fprintf(stderr, "media_packet_create_alloc failed\n");
+ return FALSE;
}
- if (mediacodec_create(&g_media_codec[i]) != MEDIACODEC_ERROR_NONE)
- {
- g_print("mediacodec create is failed\n");
+ if (media_packet_set_pts(pkt, (uint64_t)(pts)) != MEDIA_PACKET_ERROR_NONE) {
+ fprintf(stderr, "media_packet_set_pts failed\n");
+ return FALSE;
}
- }
- //input_fmt = (media_format_s *) malloc(sizeof(media_format_s));
- //memset(input_fmt, 0, sizeof(media_format_s));
- media_format_create(&input_fmt);
-#if DUMP_OUTBUF
- fp_out = fopen("/opt/usr/media/codec_dump.out", "wb");
-#endif
+ if (app->type != VIDEO_ENC) {
+ media_packet_get_buffer_data_ptr(pkt, &buf_data_ptr);
+ media_packet_set_buffer_size(pkt, (uint64_t)read);
- strncpy (g_uri, filename, len);
+ memcpy(buf_data_ptr, tmp, read);
+ g_print("tmp:%p, read:%d\n",tmp, read);
+ } else {
+ /* Y */
+ media_packet_get_video_plane_data_ptr(pkt, 0, &buf_data_ptr);
+ media_packet_get_video_stride_width(pkt, 0, &stride_width);
+ media_packet_get_video_stride_height(pkt, 0, &stride_height);
- return;
-}
+ offset = stride_width*stride_height;
-void _allocate_buf(void)
-{
-#if USE_INPUT_QUEUE
- int i = 0;
+ memcpy(buf_data_ptr, tmp, offset);
- // !!!! remove dependency on internal headers.
- //input_avaliable = mc_async_queue_new();
- //input_buf = (media_packet_h *)malloc(sizeof(media_packet_h)*MAX_INPUT_BUF_NUM);
+ /* UV or U*/
+ media_packet_get_video_plane_data_ptr(pkt, 1, &buf_data_ptr);
+ media_packet_get_video_stride_width(pkt, 1, &stride_width);
+ media_packet_get_video_stride_height(pkt, 1, &stride_height);
+ memcpy(buf_data_ptr, tmp + offset, stride_width*stride_height);
- for (i = 0; i < MAX_INPUT_BUF_NUM; i++)
- {
- media_packet_create_alloc(input_fmt, NULL, NULL, &input_buf[i]);
- g_print("input queue buf = %p\n", input_buf[i]);
- //mc_async_queue_push(input_avaliable, input_buf[i]);
- g_queue_push_tail(&input_available, input_buf[i]);
- }
-#else
- media_packet_create_alloc(input_fmt, NULL, NULL, &in_buf);
- //media_format_unref(input_fmt);
- g_print("input queue buf = %p\n", in_buf);
-#endif
- return;
-}
+ if (app->hardware == FALSE) {
+ /* V */
+ media_packet_get_video_plane_data_ptr(pkt, 2, &buf_data_ptr);
+ media_packet_get_video_stride_width(pkt, 2, &stride_width);
+ media_packet_get_video_stride_height(pkt, 2, &stride_height);
-#if USE_INPUT_QUEUE
-void _free_buf(void)
-{
- int i = 0;
+ offset += stride_width * stride_height;
- //mc_async_queue_free(input_avaliable);
- if (input_buf)
- {
- for (i = 0; i < MAX_INPUT_BUF_NUM; i++)
- {
- if(input_buf[i])
- {
- media_packet_destroy(input_buf[i]);
+ memcpy(buf_data_ptr, tmp + offset, stride_width*stride_height);
}
}
- media_format_unref(input_fmt);
- input_fmt = NULL;
- //free(input_buf);
- //input_buf = NULL;
- }
- g_queue_clear(&input_available);
- return;
-}
-#endif
-
-static void _mediacodec_empty_buffer_cb(media_packet_h pkt, void *user_data)
-{
- if (pkt != NULL)
- {
-#if USE_INPUT_QUEUE
- media_packet_unset_flags(pkt, MEDIA_PACKET_CODEC_CONFIG);
- //mc_async_queue_push(input_avaliable, pkt);
- g_queue_push_tail(&input_available, pkt);
- g_print("availablebuf = %p\n", pkt);
-#else
- g_print("Used input buffer = %p\n", pkt);
- media_packet_destroy(pkt);
-#endif
- }
- return;
-}
-
-static void _mediacodec_fill_buffer_cb(media_packet_h pkt, void *user_data)
-{
- if (pkt != NULL)
- {
- _mediacodec_get_output();
- }
- return;
-}
-
-static void _mediacodec_eos_cb(void *user_data)
-{
- g_print("event : eos\n");
-}
-
-static bool _mcdiacodec_supported_cb(mediacodec_codec_type_e type, void *user_data)
-{
- if(type != -1)
- g_printf("type : %x\n", type);
- return true;
-}
-
-void _mediacodec_destroy(void)
-{
- int i = 0;
- g_print("mediacodec_destroy\n");
-
- for (i = 0; i < g_handle_num; i++)
- {
- if(g_media_codec[i] != NULL)
- {
- //mediacodec_unprepare(g_media_codec[i]);
- mediacodec_destroy(g_media_codec[i]);
- g_media_codec[i] = NULL;
- }
- }
-#if USE_INPUT_QUEUE
- _free_buf();
-#endif
- if (fp_src)
- fclose(fp_src);
-#if DUMP_OUTBUF
- if (fp_out)
- fclose(fp_out);
-#endif
- return;
-}
+ mc_hex_dump("inbuf", tmp, 48);
-void _mediacodec_set_codec(int codecid, int flag)
-{
- int encoder = 0;
- g_print("_mediacodec_configure\n");
- g_print("codecid = %x, flag = %d\n", codecid, flag);
- if (g_media_codec[0] != NULL)
- {
- mediacodec_set_codec(g_media_codec[0], (mediacodec_codec_type_e)codecid, flag);
- encoder = GET_IS_ENCODER(flag) ? 1 : 0;
- if (use_video)
- {
- if (encoder)
- {
- //input_fmt->mimetype |= MEDIA_FORMAT_RAW;
- mimetype |= MEDIA_FORMAT_NV12;
- mimetype |= MEDIA_FORMAT_RAW;
- //mimetype |= MEDIA_FORMAT_I420;
- }
- else
- {
- //input_fmt->mimetype |= MEDIA_FORMAT_H264_SP;
- mimetype |= MEDIA_FORMAT_H264_SP;
- }
- mimetype |= MEDIA_FORMAT_VIDEO;
- }
- else
- {
- if (encoder)
- {
- mimetype |= MEDIA_FORMAT_RAW;
- mimetype |= MEDIA_FORMAT_PCM;
- }
- else
- {
- if (codecid == MEDIACODEC_AAC) /* same as MEDIACODEC_AAC_LC */
- mimetype |= MEDIA_FORMAT_AAC; /* MPEG-2/4 : (*.aac, adts), need adts header */
- else if (codecid == MEDIACODEC_AAC_HE)
- mimetype |= MEDIA_FORMAT_AAC_HE; /* MPEG-4 : (*.m4a, mp4) */
- else if (codecid == MEDIACODEC_AAC_HE_PS)
- mimetype |= MEDIA_FORMAT_AAC_HE_PS; /* MPEG-4 : (*.m4a, mp4) */
- else if (codecid == MEDIACODEC_MP3)
- mimetype |= MEDIA_FORMAT_MP3;
- else if (codecid == MEDIACODEC_AMR_NB)
- mimetype |= MEDIA_FORMAT_AMR_NB;
- else if (codecid == MEDIACODEC_AMR_WB)
- mimetype |= MEDIA_FORMAT_AMR_WB;
- }
- mimetype |= MEDIA_FORMAT_AUDIO;
- g_print("[audio test] mimetype (0x%x)\n", mimetype);
+ ret = mediacodec_process_input(app->mc_handle[0], pkt, 0);
+ if(ret != MEDIACODEC_ERROR_NONE) {
+ return FALSE;
}
+ pts += ES_DEFAULT_VIDEO_PTS_OFFSET;
}
- else
- {
- g_print("mediacodec handle is not created\n");
- }
- return;
-}
-
-void _mediacodec_set_vdec_info(int width, int height)
-{
- g_print("_mediacodec_set_vdec_info\n");
- g_print("width = %d, height = %d\n", width, height);
- if (g_media_codec[0] != NULL)
- {
- mediacodec_set_vdec_info(g_media_codec[0], width, height);
- //input_fmt->detail.video.width = width;
- //input_fmt->detail.video.height = height;
- }
- else
- {
- g_print("mediacodec handle is not created\n");
- }
- return;
-}
+ //app->offset += read;
-void _mediacodec_set_venc_info(int width, int height, float fps, int target_bits)
-{
- g_print("_mediacodec_set_venc_info\n");
- if (g_media_codec[0] != NULL)
- {
- mediacodec_set_venc_info(g_media_codec[0], width, height, fps, target_bits);
- //input_fmt->detail.video.width = width;
- //input_fmt->detail.video.height = height;
- }
- else
- {
- g_print("mediacodec handle is not created\n");
- }
- return;
+ return TRUE;
}
-void _mediacodec_set_adec_info(int samplerate, int chnnel, int bit)
+static void start_feed(App *app)
{
- g_print("_mediacodec_set_adec_info\n");
- g_print("samplerate = %d, channel = %d, bit = %d\n", samplerate, chnnel, bit);
- if (g_media_codec[0] != NULL)
- {
- mediacodec_set_adec_info(g_media_codec[0], samplerate, chnnel, bit);
+ if (app->sourceid == 0) {
+ //start feeding
+ app->sourceid = g_idle_add((GSourceFunc)read_data, app);
+ g_print("start_feed\n");
}
- else
- {
- g_print("mediacodec handle is not created\n");
- }
- return;
}
-void _mediacodec_set_aenc_info(int samplerate, int chnnel, int bit, int bitrate)
+static void stop_feed(App *app)
{
- g_print("_mediacodec_set_aenc_info\n");
- g_print("samplerate = %d, channel = %d, bit = %d, bitrate = %d\n", samplerate, chnnel, bit, bitrate);
- if (g_media_codec[0] != NULL)
- {
- mediacodec_set_aenc_info(g_media_codec[0], samplerate, chnnel, bit, bitrate);
+ if (app->sourceid != 0) {
+ //stop feeding
+ g_source_remove(app->sourceid);
+ app->sourceid = 0;
+ g_print("stop_feed\n");
}
- else
- {
- g_print("mediacodec handle is not created\n");
- }
- return;
}
-
-void _mediacodec_prepare(void)
+static bool _mediacodec_inbuf_used_cb(media_packet_h pkt, void *user_data)
{
- int i = 0;
- int err = 0;
- if (use_video)
- {
- media_format_set_video_mime(input_fmt, mimetype);
- media_format_set_video_width(input_fmt, width);
- media_format_set_video_height(input_fmt, height);
- media_format_set_video_avg_bps(input_fmt, target_bits);
- }
- else
- {
- g_print(" [audio test] mimetype (0x%x), channel(%d), samplerate (%d), bit (%d)\n", mimetype, channel, samplerate, bit);
- media_format_set_audio_mime(input_fmt, mimetype);
- media_format_set_audio_channel(input_fmt, channel);
- media_format_set_audio_samplerate(input_fmt, samplerate);
- media_format_set_audio_bit(input_fmt, bit);
- }
-
- for (i=0; i < g_handle_num; i++)
- {
- if(g_media_codec[i] != NULL)
- {
- mediacodec_set_input_buffer_used_cb(g_media_codec[i], _mediacodec_empty_buffer_cb, g_media_codec[i]);
- mediacodec_set_output_buffer_available_cb(g_media_codec[i], _mediacodec_fill_buffer_cb, g_media_codec[i]);
- mediacodec_set_eos_cb(g_media_codec[i], _mediacodec_eos_cb, g_media_codec[i]);
-
- mediacodec_foreach_supported_codec(g_media_codec[i], _mcdiacodec_supported_cb, g_media_codec[i]);
-
- err = mediacodec_prepare(g_media_codec[i]);
-
- if (err != MEDIACODEC_ERROR_NONE)
- {
- g_print("mediacodec_prepare failed error = %d \n", err);
- }
-#if USE_INPUT_QUEUE
- _allocate_buf();
-#endif
- }
- else
- {
- g_print("mediacodec handle is not created\n");
- }
- }
- frame_count = 0;
-
- return;
-}
-
-
-
-void _mediacodec_unprepare(void)
-{
- int i = 0;
- int err = 0;
- g_print("_mediacodec_unprepare\n");
-
- for (i=0; i < g_handle_num; i++)
- {
- if(g_media_codec[i] != NULL)
- {
- mediacodec_unset_input_buffer_used_cb(g_media_codec[i]);
- mediacodec_unset_output_buffer_available_cb(g_media_codec[i]);
-
- err = mediacodec_unprepare(g_media_codec[i]);
- if (err != MEDIACODEC_ERROR_NONE)
- {
- g_print("mediacodec_unprepare failed error = %d \n", err);
- }
- }
- else
- {
- g_print("mediacodec handle is not created\n");
- }
- }
- frame_count = 0;
- return;
-}
-
-//#define AUDIO_EOS_TEST
-#ifdef AUDIO_EOS_TEST
-#define AUDIO_AAC_EOS_TEST 2851 /* test.aac */
-#define AUDIO_AAC_EOS_TEST 51 /* test50f.aac*/
-#define AUDIO_MP3_EOS_TEST 1756
-#endif
-int _mediacodec_process_input(void)
-{
-// g_print("_mediacodec_process_input (frame_count :%d)\n", frame_count);
- unsigned int buf_size = 0;
-#if USE_INPUT_QUEUE
- media_packet_h in_buf = NULL;
-#endif
- void *data = NULL;
- int ret = 0;
- mediacodec_s * handle = NULL;
- mc_handle_t* mc_handle = NULL;
-
- if (g_media_codec[0] == NULL)
- {
- g_print("mediacodec handle is not created\n");
- return MEDIACODEC_ERROR_INVALID_PARAMETER;
- }
- else
- {
- handle = (mediacodec_s *) g_media_codec[0];
- mc_handle = (mc_handle_t*) handle->mc_handle;
- }
-
- if (fp_src == NULL)
- {
- fp_src = fopen(g_uri, "r");
- if (fp_src == NULL)
- {
- g_print("%s file open failed\n", g_uri);
- return MEDIACODEC_ERROR_INVALID_PARAMETER;
- }
- }
-#if USE_INPUT_QUEUE
- //in_buf = mc_async_queue_pop(input_avaliable);
- in_buf = g_queue_pop_head(&input_available);
-#else
- _allocate_buf();
-#endif
-
- if (in_buf != NULL)
- {
- media_packet_get_buffer_data_ptr(in_buf, &data);
- if(data == NULL)
- return MEDIACODEC_ERROR_INVALID_PARAMETER;
-
- if (use_encoder)
- {
- if (use_video)
- {
- /*
- * Video Encoder
- */
- buf_size = bytestream2yuv420(fp_src, data);
- media_packet_set_pts (in_buf, pts);
- g_print("input pts = %llu\n", pts);
- if (fps != 0)
- {
- pts += (GST_SECOND / fps);
- }
- }
- else
- {
- /*
- * Aduio Encoder - AAC /AMR-NB
- */
- if (mc_handle->codec_id == MEDIACODEC_AAC_LC)
- {
- buf_size = extract_input_aacenc(fp_src, data);
- media_packet_set_pts (in_buf, pts);
- g_print("input pts = %llu\n", pts);
- if (samplerate != 0)
- {
- pts += ((GST_SECOND / samplerate) * samplebyte);
- }
- }
- else if(mc_handle->codec_id == MEDIACODEC_AMR_NB)
- {
- buf_size = extract_input_amrenc(fp_src, data, 1);
- media_packet_set_pts (in_buf, pts);
- g_print("input pts = %llu\n", pts);
- pts += (GST_SECOND / 50); /* (20ms/frame) AMR_FRAMES_PER_SECOND = 50 */
- }
- else
- {
- g_print(" [Input process] Not Suppor Audio Encodert!!!!! - mimetype (0x%x) codecid (0x%x)\n", mimetype, mc_handle->codec_id);
- }
- }
- }
- else
- {
- if (use_video)
- {
- /*
- * Video Decoder
- */
- //else if(frame_count == 150)
- // ret = media_packet_set_flags(in_buf, MEDIA_PACKET_END_OF_STREAM);
-
- buf_size = bytestream2nalunit(fp_src, data);
-
- if(frame_count == 2)
- ret = media_packet_set_flags(in_buf, MEDIA_PACKET_CODEC_CONFIG);
- //mc_hex_dump("nal",data, 16);
- }
- else
- {
- /*
- * Audio Decoder - AAC_LC (adts) / MP3 / AMR-NB / AMR-WB
- * - AAC_HE (v1) / AAC_HE_PS (v2)
- */
- if (mimetype == MEDIA_FORMAT_AAC_LC)
- {
-#ifdef AUDIO_EOS_TEST
- if(frame_count == AUDIO_AAC_EOS_TEST) {
- ret = media_packet_set_flags(in_buf, MEDIA_PACKET_END_OF_STREAM);
- g_print("ret (%d) Set MEDIA_PACKET_END_OF_STREAM at frame_count = %d\n", ret, frame_count);
- }
-#endif
- buf_size = extract_input_aacdec(fp_src, data);
- }
- else if (mimetype == MEDIA_FORMAT_AAC_HE || mimetype == MEDIA_FORMAT_AAC_HE_PS)
- {
-#ifdef HE_AAC_V12_ENABLE
- if(frame_count == 0) {
- g_print("%s -Enable 'HE_AAC_V12_ENABLE' for *.mp4 or *.m4a case\n",__func__);
- ret = media_packet_set_flags(in_buf, MEDIA_PACKET_CODEC_CONFIG);
- //To-Do for inserting codec_data
- }
- buf_size = extract_input_aacdec_m4a_test(fp_src, data);
-#endif
- }
- else if (mimetype == MEDIA_FORMAT_MP3)
- {
- buf_size = extract_input_mp3dec(fp_src, data);
- }
- else if (mimetype == MEDIA_FORMAT_AMR_NB || mimetype == MEDIA_FORMAT_AMR_WB)
- {
- buf_size = extract_input_amrdec(fp_src, data);
- }
- else
- {
- g_print(" [Input process] Not Suppor Audio Decodert!!!!! - mimetype (0x%x) codecid (0x%x)\n", mimetype, mc_handle->codec_id);
- }
- }
- }
+ g_print("_mediacodec_inbuf_used_cb!!!\n");
+ media_packet_destroy(pkt);
+ return TRUE;
+}
+static bool _mediacodec_outbuf_available_cb(media_packet_h pkt, void *user_data)
+{
+ media_packet_h out_pkt = NULL;
+ int ret;
- if(buf_size > 0) {
+ App *app = (App*)user_data;
- if(buf_size == 4)
- {
- media_packet_set_flags(in_buf, MEDIA_PACKET_END_OF_STREAM);
- media_packet_set_buffer_size(in_buf, 4);
- mediacodec_process_input (g_media_codec[0], in_buf, 0);
- g_printf("eos packet is sent\n");
+ g_print("_mediacodec_outbuf_available_cb\n");
- return MEDIACODEC_ERROR_INVALID_INBUFFER;
- }
- media_packet_set_buffer_size(in_buf, buf_size);
- g_print("%s - input_buf size = %4d (0x%x) at %4d frame, %p\n",__func__, buf_size, buf_size, frame_count, in_buf);
+ g_mutex_lock(&app->lock);
+
+ ret = mediacodec_get_output(app->mc_handle[0], &out_pkt, 0);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("get_output failed\n");
+ }
+ //decoder_output_dump(app, out_pkt);
+
+#if DUMP_OUTBUF
+ void *data;
+ uint64_t buf_size;
+ int stride_width, stride_height;
+
+ media_packet_get_buffer_data_ptr(out_pkt, 0, &data);
+ media_packet_get_buffer_size(out_pkt, &buf_size);
+ g_print("output data : %p, size %d\n",data, (int)buf_size);
+
+ fwrite(data, 1, buf_size, fp_out);
- ret = mediacodec_process_input (g_media_codec[0], in_buf, 0);
- if (use_video && buf_size == -1)
- {
- g_print("%s - END : input_buf size = %d frame_count : %d\n",__func__, buf_size, frame_count);
- return MEDIACODEC_ERROR_INVALID_INBUFFER;
- }
-#ifdef AUDIO_EOS_TEST
- else if(mimetype == MEDIA_FORMAT_AAC_LC && frame_count == AUDIO_AAC_EOS_TEST)
- {
- g_print("%s - AAC END : input_buf size = %d frame_count : %d\n",__func__, buf_size, frame_count);
- return MEDIACODEC_ERROR_INVALID_INBUFFER;
- }
- else if(mimetype == MEDIA_FORMAT_MP3 && frame_count == AUDIO_MP3_EOS_TEST)
- {
- g_print("%s -MP3 END : input_buf size = %d frame_count : %d\n",__func__, buf_size, frame_count);
- return MEDIACODEC_ERROR_INVALID_INBUFFER;
- }
#endif
- }
- frame_count++;
+ app->frame_count++;
- return ret;
- }
- return MEDIACODEC_ERROR_NONE;
+ g_mutex_unlock(&app->lock);
+
+ media_packet_destroy(out_pkt);
+ out_pkt = NULL;
+ g_print("done\n");
+
+ return TRUE;
}
-int _mediacodec_get_output(void)
+static bool _mediacodec_buffer_status_cb(mediacodec_status_e status, void *user_data)
{
- int err = 0;
- uint64_t buf_size = 0;
- void *data = NULL;
- mediacodec_s * handle = NULL;
- mc_handle_t* mc_handle = NULL;
-
- g_print("_mediacodec_get_output\n");
- if (g_media_codec[0] == NULL)
- {
- g_print("mediacodec handle is not created\n");
- return MEDIACODEC_ERROR_INVALID_PARAMETER;
- }
- else
- {
- handle = (mediacodec_s *) g_media_codec[0];
- mc_handle = (mc_handle_t*) handle->mc_handle;
- }
-
- err = mediacodec_get_output(g_media_codec[0], &output_buf, 0);
- if( err == MEDIACODEC_ERROR_NONE)
- {
- media_packet_get_buffer_size(output_buf, &buf_size);
- g_print("%s - output_buf size = %lld\n",__func__, buf_size);
-#if DUMP_OUTBUF
- media_packet_get_buffer_data_ptr(output_buf, &data);
+ g_print("_mediacodec_buffer_status_cb %d\n", status);
- if ((!use_video) && (use_encoder))
- {
- /*
- * Prepend Header For Aduio Encoder of AAC(adts) and AMR-NB
- */
- if (mc_handle->codec_id == MEDIACODEC_AAC_LC)
- {
- if (buf_size > 0)
- {
- /* This is used only AAC encoder case for adding each ADTS frame header */
- add_adts_header_for_aacenc(buf_adts, (buf_size+ADTS_HEADER_SIZE));
- fwrite(&buf_adts[0], 1, ADTS_HEADER_SIZE, fp_out);
- }
- }
- else if (mc_handle->codec_id == MEDIACODEC_AMR_NB)
- {
- if ((buf_size > 0) && (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__);
- fwrite(&AMR_header[0], 1, sizeof(AMR_header) - 1, fp_out); /* AMR-NB magic number */
- write_amr_header = 0;
- }
- }
- }
+ App *app = (App*)user_data;
- if (data != NULL)
- fwrite(data, 1, buf_size, fp_out);
-#endif
-// printf("%s - output_buf : %p\n",__func__, output_buf);
-// mediacodec_reset_output_buffer(g_media_codec[0], &output_buf);
- media_packet_destroy(output_buf);
- }
- else
- {
- g_print("get_output failed err = %d\n", err);
- return err;
+ if (status == MEDIACODEC_NEED_DATA) {
+ start_feed(app);
+ } else if (status == MEDIACODEC_ENOUGH_DATA ){
+ stop_feed(app);
}
+ return TRUE;
+}
- return MEDIACODEC_ERROR_NONE;
+static bool _mediacodec_error_cb(mediacodec_error_e error, void *user_data)
+{
+ return TRUE;
}
-void _mediacodec_reset_output_buffer(void)
+static bool _mediacodec_eos_cb(void *user_data)
{
- g_print("_media_codec_reset_output_buffer\n");
- if (g_media_codec[0] == NULL)
- {
- g_print("mediacodec handle is not created\n");
+ return TRUE;
+}
+
+static void _mediacodec_prepare(App *app)
+{
+ int ret;
+ media_format_mimetype_e mime;
+
+#if DUMP_OUTBUF
+ fp_out = fopen("/opt/usr/codec_dump.out", "wb");
+#endif
+ /* create instance */
+ ret = mediacodec_create(&app->mc_handle[0]);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_create failed\n");
return;
}
-/*
- if(output_buf == NULL)
- {
- g_print("output buffer is NULL");
+
+ /* set codec */
+ ret = mediacodec_set_codec(app->mc_handle[0], app->codecid, app->flag);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_set_codec failed\n");
return;
}
-*/
- //mediacodec_reset_output_buffer(g_media_codec[0], &output_buf);
- return;
-}
-void _mediacodec_process_input_n(int num)
-{
- int i = 0;
- int ret = 0;
- for (i =0; i < num; i++)
- {
- ret = _mediacodec_process_input();
- if (ret != 0)
- g_print ("_mediacodec_process_input err = %d\n", ret);
+
+ app->mime = _mediacodec_set_codec(app->codecid, app->flag, &app->hardware);
+
+ /* set codec info */
+ ret = media_format_create(&vdec_fmt);
+
+ switch (app->type) {
+ case VIDEO_DEC:
+ ret = mediacodec_set_vdec_info(app->mc_handle[0], app->width, app->height);
+ media_format_set_video_mime(vdec_fmt, app->mime);
+ media_format_set_video_width(vdec_fmt, app->width);
+ media_format_set_video_height(vdec_fmt, app->height);
+ break;
+ case VIDEO_ENC:
+ ret = mediacodec_set_venc_info(app->mc_handle[0], app->width, app->height, app->fps, app->target_bits);
+ media_format_set_video_mime(vdec_fmt, app->mime);
+ media_format_set_video_width(vdec_fmt, app->width);
+ media_format_set_video_height(vdec_fmt, app->height);
+ media_format_set_video_avg_bps(vdec_fmt, app->target_bits);
+ break;
+ case AUDIO_DEC:
+ ret = mediacodec_set_adec_info(app->mc_handle[0], app->samplerate, app->channel, app->bit);
+ media_format_set_audio_mime(vdec_fmt, app->mime);
+ media_format_set_audio_channel(vdec_fmt, app->channel);
+ media_format_set_audio_samplerate(vdec_fmt, app->samplerate);
+ media_format_set_audio_bit(vdec_fmt, app->bit);
+ break;
+ case AUDIO_ENC:
+ ret = mediacodec_set_aenc_info(app->mc_handle[0], app->samplerate, app->channel, app->bit, app->bitrate);
+ media_format_set_audio_mime(vdec_fmt, app->mime);
+ media_format_set_audio_channel(vdec_fmt, app->channel);
+ media_format_set_audio_samplerate(vdec_fmt, app->samplerate);
+ media_format_set_audio_bit(vdec_fmt, app->bit);
+ break;
+ default:
+ g_print("invaild type\n");
+ break;
+ }
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_set_xxxc(%d)_info failed\n", app->type);
+ return;
}
- return;
-}
-void _mediacodec_get_output_n(int num)
-{
- int i = 0;
- int ret = 0;
- for (i =0; i < num; i++)
- {
- ret = _mediacodec_get_output();
- if (ret != 0)
- g_print ("_mediacodec_get_output err = %d\n", ret);
+
+ /* set callback */
+ mediacodec_set_input_buffer_used_cb(app->mc_handle[0], _mediacodec_inbuf_used_cb, NULL);
+ mediacodec_set_output_buffer_available_cb(app->mc_handle[0], _mediacodec_outbuf_available_cb, app);
+ mediacodec_set_buffer_status_cb(app->mc_handle[0], _mediacodec_buffer_status_cb, app);
+ mediacodec_set_eos_cb(app->mc_handle[0],_mediacodec_eos_cb, NULL);
+ mediacodec_set_error_cb(app->mc_handle[0], _mediacodec_error_cb, NULL);
+
+
+ /* prepare */
+ ret = mediacodec_prepare(app->mc_handle[0]);
+ if (ret != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_prepare failed\n");
+ return;
}
+
+ app->frame_count = 0;
+ app->start = clock();
+ g_main_loop_run(app->loop);
+
+ g_print("Average FPS = %3.3f\n", ((double)app->frame_count*1000000/(app->finish - app->start)));
+
+ g_print("---------------------------\n");
+
+
return;
}
-static gpointer vdec_task(gpointer data)
-{
- int i;
- //TODO extract packets from MediaDemuxer
- /*
- for(i=0; demuxer->get_track_count; i++)
- {
- }
- */
- return NULL;
-}
+/**
+ *
+ *
+* @param filename
+*/
-void _mediacodec_process_all(void)
+static void input_filepath(char *filename, App *app)
{
- g_print("_mediacodec_process_all\n");
- int ret = MEDIACODEC_ERROR_NONE;
- GThread *vdec_thread, *venc_thread, *adec_thread, *aenc_thread;
-
- while(1)
- {
- ret = _mediacodec_process_input();
+ GError *error = NULL;
- if(ret != MEDIACODEC_ERROR_NONE) {
- g_print ("_mediacodec_process_input ret = %d\n", ret);
- break;
- }
+ app->obj++;
+ app->file = g_mapped_file_new (filename, FALSE, &error);
+ if (error) {
+ g_print ("failed to open file : %s\n", error->message);
+ g_error_free(error);
+ return -1;
}
+ app->length = g_mapped_file_get_length (app->file);
+ app->data = (guint8 *) g_mapped_file_get_contents (app->file);
+ app->offset = 0;
+ g_print("len : %d, offset : %d, obj : %d", app->length, (int)app->offset, app->obj);
+
/*
- if(use_encoder)
+ if ( mediacodec_create(&app->mc_handle[app->obj]) != MEDIACODEC_ERROR_NONE) {
+ g_print("mediacodec_create failed\n");
+ }
+*/
+#if 0
+ if(len < 0 || len > MAX_STRING_LEN)
+ return;
+
+ for(i = 0; i < g_handle_num; i++)
{
- if(use_video)
+ if(g_media_codec[i] != NULL)
{
+ mediacodec_unprepare(g_media_codec[i]);
+ mediacodec_destroy(g_media_codec[i]);
+ g_media_codec[i] = NULL;
}
- else
+
+ if (mediacodec_create(&g_media_codec[i]) != MEDIACODEC_ERROR_NONE)
{
+ g_print("mediacodec create is failed\n");
}
}
- else
- {
- if(use_video)
- {
- vdec_thread = g_thread_create(vdec_task, NULL, TRUE, NULL);
+ //input_fmt = (media_format_s *) malloc(sizeof(media_format_s));
+ //memset(input_fmt, 0, sizeof(media_format_s));
+ media_format_create(&input_fmt);
- g_thread_join(vdec_thread);
- }
- else
- {
- }
+#if DUMP_OUTBUF
+ fp_out = fopen("/opt/usr/media/codec_dump.out", "wb");
+#endif
- }
-*/
+ strncpy (g_uri, filename, len);
+#endif
return;
}
-
-void quit_program(void)
+void quit_program()
{
- int i = 0;
+ //g_main_loop_quit (app->loop);
+#if DUMP_OUTBUF
+ if (fp_out)
+ fclose(fp_out);
+#endif
- for (i = 0; i < g_handle_num; i++)
- {
- if(g_media_codec[i]!=NULL)
- {
- mediacodec_unprepare(g_media_codec[i]);
- mediacodec_destroy(g_media_codec[i]);
- g_media_codec[i] = NULL;
- }
- }
}
void reset_menu_state()
return;
}
-void _interpret_main_menu(char *cmd)
+void _interpret_main_menu(char *cmd, App *app)
{
int len = strlen(cmd);
if (len == 1)
{
- if (strncmp(cmd, "a", 1) == 0)
- {
+ if (strncmp(cmd, "a", 1) == 0) {
g_menu_state = CURRENT_STATUS_FILENAME;
- }
- else if (strncmp(cmd, "o", 1) == 0)
- {
+ } else if (strncmp(cmd, "o", 1) == 0) {
g_menu_state = CURRENT_STATUS_GET_OUTPUT;
- }
- else if (strncmp(cmd, "q", 1) == 0)
+ } else if (strncmp(cmd, "q", 1) == 0)
{
quit_program();
- }
- else
- {
+ //g_main_loop_quit (app->loop);
+ } else {
g_print("unknown menu \n");
}
- }
- else if (len == 2)
- {
- if (strncmp(cmd, "pr", 2) == 0)
- {
- _mediacodec_prepare();
- }
- else if (strncmp(cmd, "sc", 2) == 0)
- {
+ } else if (len == 2) {
+ if (strncmp(cmd, "pr", 2) == 0) {
+ _mediacodec_prepare(app);
+ } else if (strncmp(cmd, "sc", 2) == 0) {
g_menu_state = CURRENT_STATUS_SET_CODEC;
- }
- else if (strncmp(cmd, "vd", 2) == 0)
- {
+ } else if (strncmp(cmd, "vd", 2) == 0) {
g_menu_state = CURRENT_STATUS_SET_VDEC_INFO;
- }
- else if (strncmp(cmd, "ve", 2) == 0)
- {
+ } else if (strncmp(cmd, "ve", 2) == 0) {
g_menu_state = CURRENT_STATUS_SET_VENC_INFO;
- }
- else if (strncmp(cmd, "ad", 2) == 0)
- {
+ } else if (strncmp(cmd, "ad", 2) == 0) {
g_menu_state = CURRENT_STATUS_SET_ADEC_INFO;
- }
- else if (strncmp(cmd, "ae", 2) == 0)
- {
+ } else if (strncmp(cmd, "ae", 2) == 0) {
g_menu_state = CURRENT_STATUS_SET_AENC_INFO;
- }
- else if (strncmp(cmd, "pi", 2) == 0)
- {
+ } else if (strncmp(cmd, "pi", 2) == 0) {
g_menu_state = CURRENT_STATUS_PROCESS_INPUT;
+ } else if (strncmp(cmd, "rb", 2) == 0) {
+ //_mediacodec_reset_output_buffer();
+ } else if (strncmp(cmd, "pa", 2) == 0) {
+ //_mediacodec_process_all();
+ } else if (strncmp(cmd, "un", 2) == 0) {
+ //_mediacodec_unprepare();
+ } else if (strncmp(cmd, "dt", 2) == 0) {
+ //_mediacodec_destroy();
+ } else {
+ //g_print("unknown menu \n");
+ display_sub_basic();
}
- else if (strncmp(cmd, "rb", 2) == 0)
- {
- _mediacodec_reset_output_buffer();
- }
- else if (strncmp(cmd, "pa", 2) == 0)
- {
- _mediacodec_process_all();
- }
- else if (strncmp(cmd, "un", 2) == 0)
- {
- _mediacodec_unprepare();
- }
- else if (strncmp(cmd, "dt", 2) == 0)
- {
- _mediacodec_destroy();
- }
- else
- {
- g_print("unknown menu \n");
- }
- }
- else
- {
+ } else {
g_print("unknown menu \n");
}
+
return;
}
}
else if (g_menu_state == CURRENT_STATUS_SET_CODEC)
{
-#if 1 //NEW
g_print("*** Codec id : Select Codec ID Numbe (e.g. AAC_LC = 96)\n");
g_print(" L16 = 16 (0x10)\n");
g_print(" ALAW = 32 (0x20)\n");
g_print(" AAC_PS = 98 (0x62)\n");
g_print(" MP3 = 112 (0x70)\n");
g_print(" VORBIS = 128 (0x80)\n");
+ g_print(" FLAC = 144 (0x90)\n");
+ g_print(" WMAV1 = 160 (0xA0)\n");
+ g_print(" WMAV2 = 161 (0xA1)\n");
+ g_print(" WMAPRO = 162 (0xA2)\n");
+ g_print(" WMALSL = 163 (0xA3)\n");
g_print(" -------------------\n");
g_print(" H261 = 101\n");
g_print(" H263 = 102\n");
g_print("*** Flags : Select Combination Number (e.g. DEOCDER + TYPE_SW = 10)\n");
g_print(" CODEC : ENCODER = 1 DECODER = 2\n");
g_print(" TYPE : HW = 4 SW = 8\n");
- g_print(" TYPE : OMX = 16 GEN = 32\n");
- g_print("*** input codec id, falgs.\n");
-#else
- g_print("*** Codec id : L16 = 1 Flags : MEDIACODEC_ENCODER = 1\n");
- g_print(" ALAW = 2 MEDIACODEC_DECODER = 2\n");
- g_print(" ULAW = 3 MEDIACODEC_SUPPORT_TYPE_HW = 4,\n");
- g_print(" AMR = 4 MEDIACODEC_SUPPORT_TYPE_SW = 8,\n");
- g_print(" G729 = 5 MEDIACODEC_SUPPORT_TYPE_OMX = 16\n");
- g_print(" AAC = 6 MEDIACODEC_SUPPORT_TYPE_GEN = 32,\n");
- g_print(" MP3 = 7\n");
- g_print(" H261 = 101\n");
- g_print(" H263 = 102\n");
- g_print(" H264 = 103\n");
- g_print(" MJPEG = 104\n");
- g_print(" MPEG1 = 105\n");
- g_print(" MPEG2 = 106\n");
- g_print(" MPEG4 = 107\n");
g_print("*** input codec id, falgs.\n");
-#endif
}
else if (g_menu_state == CURRENT_STATUS_SET_VDEC_INFO)
{
else
{
g_print("*** unknown status.\n");
- quit_program();
+ //quit_program(app);
}
g_print(" >>> ");
}
}
-static void interpret (char *cmd)
+static void interpret (char *cmd, App *app)
{
switch (g_menu_state)
{
case CURRENT_STATUS_MAINMENU:
{
- _interpret_main_menu(cmd);
+ _interpret_main_menu(cmd, app);
}
break;
case CURRENT_STATUS_FILENAME:
{
- input_filepath(cmd);
+ input_filepath(cmd, app);
reset_menu_state();
}
break;
case CURRENT_STATUS_SET_CODEC:
{
- static int codecid = 0;
- static int flag = 0;
- static int cnt = 0;
-
int tmp;
+ static int cnt = 0;
char **ptr = NULL;
switch (cnt)
{
case 0:
tmp = atoi(cmd);
-#if 1 //NEW - ToDo : BUG for case of MP3 (112 = 0x70)
- if(tmp > 100 && tmp != 112 && tmp != 128) //Temporary - exclude MP3 and VORBIS
-#else
- if(tmp > 100) //orginal
-#endif
+ if(tmp > 100 &&
+ (tmp != 112) &&
+ (tmp != 128) &&
+ (tmp != 144) &&
+ (tmp != 160) && (tmp != 161) && (tmp != 162) && (tmp != 163)) //Temporary
{
tmp = strtol(cmd, ptr, 16);
- codecid = 0x2000 + ((tmp & 0xFF) << 4);
- use_video = 1;
- }
- else
- {
-#if 1 //NEW
- codecid = 0x1000 + tmp;
-#else
- codecid = 0x1000 + (tmp<<4);
-#endif
+ app->codecid = 0x2000 + ((tmp & 0xFF) << 4);
+ } else {
+ app->codecid = 0x1000 + tmp;
}
cnt++;
break;
case 1:
- flag = atoi(cmd);
- if (GET_IS_ENCODER(flag))
- use_encoder = 1;
- else if (GET_IS_DECODER(flag))
- use_encoder = 0;
- _mediacodec_set_codec(codecid, flag);
- reset_menu_state();
- codecid = 0;
- flag = 0;
+ app->flag = atoi(cmd);
cnt = 0;
+ reset_menu_state();
break;
default:
break;
switch (cnt)
{
case 0:
- width = atoi(cmd);
+ app->width = atoi(cmd);
cnt++;
break;
case 1:
- height = atoi(cmd);
- _mediacodec_set_vdec_info(width, height);
+ app->height = atoi(cmd);
+ app->type = VIDEO_DEC;
+
reset_menu_state();
cnt = 0;
break;
static int cnt = 0;
switch (cnt) {
case 0:
- width = atoi(cmd);
+ app->width = atoi(cmd);
cnt++;
break;
case 1:
- height = atoi(cmd);
+ app->height = atoi(cmd);
cnt++;
break;
case 2:
- fps = atol(cmd);
+ app->fps = atol(cmd);
cnt++;
break;
case 3:
- target_bits = atoi(cmd);
- g_print("width = %d, height = %d, fps = %f, target_bits = %d\n", width, height, fps, target_bits);
- _mediacodec_set_venc_info(width, height, fps, target_bits);
+ app->target_bits = atoi(cmd);
+ app->type = VIDEO_ENC;
+
reset_menu_state();
cnt = 0;
break;
switch (cnt)
{
case 0:
- samplerate = atoi(cmd);
+ app->samplerate = atoi(cmd);
cnt++;
break;
case 1:
- channel = atoi(cmd);
+ app->channel = atoi(cmd);
cnt++;
break;
case 2:
- bit = atoi(cmd);
- _mediacodec_set_adec_info(samplerate, channel,bit);
+ app->bit = atoi(cmd);
+ app->type = AUDIO_DEC;
+
reset_menu_state();
cnt = 0;
break;
switch (cnt)
{
case 0:
- samplerate = atoi(cmd);
+ app->samplerate = atoi(cmd);
cnt++;
break;
case 1:
- channel = atoi(cmd);
+ app->channel = atoi(cmd);
cnt++;
break;
case 2:
- bit = atoi(cmd);
+ app->bit = atoi(cmd);
cnt++;
break;
case 3:
- bitrate = atoi(cmd);
- _mediacodec_set_aenc_info(samplerate, channel,bit,bitrate);
+ app->bitrate = atoi(cmd);
+ app->type = AUDIO_ENC;
+
reset_menu_state();
cnt = 0;
break;
{
static int num = 0;
num = atoi(cmd);
- _mediacodec_process_input_n(num);
+ //_mediacodec_process_input_n(num);
reset_menu_state();
}
break;
{
static int num = 0;
num = atoi(cmd);
- _mediacodec_get_output_n(num);
+ //_mediacodec_get_output_n(num);
reset_menu_state();
}
break;
g_print("=========================================================================================\n");
}
-gboolean input (GIOChannel *channel)
+gboolean input (GIOChannel *channel, GIOCondition cond, gpointer data)
{
gchar buf[MAX_STRING_LEN];
gsize read;
GError *error = NULL;
+ App *context = (App*)data;
g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, &error);
buf[read] = '\0';
g_strstrip(buf);
- interpret (buf);
+ interpret (buf, context);
return TRUE;
}
-
int main(int argc, char *argv[])
{
+ App *app = &s_app;
+ //app->obj = -1;
+
+ GError *error = NULL;
GIOChannel *stdin_channel;
stdin_channel = g_io_channel_unix_new(0);
g_io_channel_set_flags (stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
- g_io_add_watch (stdin_channel, G_IO_IN, (GIOFunc)input, NULL);
+ g_io_add_watch (stdin_channel, G_IO_IN, (GIOFunc)input, app);
+
+
+ app->loop = g_main_loop_new(NULL, TRUE);
+ app->timer = g_timer_new();
+ /*
+ app->file = g_mapped_file_new ("/opt/usr/media/Simpsons.h264", FALSE, &error);
+ if (error) {
+ g_print ("failed to open file : %s\n", error->message);
+ g_error_free(error);
+ return -1;
+ }
+
+ app->length = g_mapped_file_get_length (app->file);
+ app->data = (guint8 *) g_mapped_file_get_contents (app->file);
+ app->offset = 0;
+*/
+
+ //g_print("len %d, offset %d", app->length, (int)app->offset);
+
+ //g_main_loop_run(app->loop);
displaymenu();
- ops.data = NULL;
+ ops.data = app;
return appcore_efl_main(PACKAGE, &argc, &argv, &ops);
+}
+
+
+
+void mc_hex_dump(char *desc, void *addr, int len)
+{
+ int i;
+ unsigned char buff[17];
+ unsigned char *pc = (unsigned char *)addr;
+
+ if (desc != NULL)
+ printf("%s:\n", desc);
+
+ for (i = 0; i < len; i++) {
+
+ if ((i % 16) == 0) {
+ if (i != 0)
+ printf(" %s\n", buff);
+
+ printf(" %04x ", i);
+ }
+
+ printf(" %02x", pc[i]);
+
+ if ((pc[i] < 0x20) || (pc[i] > 0x7e))
+ buff[i % 16] = '.';
+ else
+ buff[i % 16] = pc[i];
+ buff[(i % 16) + 1] = '\0';
+ }
+
+ while ((i % 16) != 0) {
+ printf(" ");
+ i++;
+ }
+ printf(" %s\n", buff);
+}
+
+
+static void decoder_output_dump(App *app, media_packet_h pkt)
+{
+ unsigned char *temp;
+ int i = 0;
+ int stride_width, stride_height;
+ char filename[100]={0};
+ FILE *fp = NULL;
+ int ret =0;
+
+ sprintf(filename, "/opt/usr/dec_output_dump_%d_%d.yuv", app->width, app->height);
+ fp = fopen(filename, "ab");
+
+ media_packet_get_video_plane_data_ptr(pkt, 0, &temp);
+ media_packet_get_video_stride_width(pkt, 0, &stride_width);
+ media_packet_get_video_stride_height(pkt, 0, &stride_height);
+
+ for (i = 0; i < app->height; i++) {
+ ret = fwrite(temp, app->width, 1, fp);
+ temp += stride_width;
+ }
+
+ if (app->hardware == TRUE) {
+ media_packet_get_video_plane_data_ptr(pkt, 1, &temp);
+ media_packet_get_video_stride_width(pkt, 1, &stride_width);
+ for (i = 0; i < app->height/2; i++) {
+ ret = fwrite(temp, app->width, 1, fp);
+ temp += stride_width;
+ }
+ } else {
+ media_packet_get_video_plane_data_ptr(pkt, 1, &temp);
+ media_packet_get_video_stride_width(pkt, 1, &stride_width);
+ for (i = 0; i < app->height/2; i++) {
+ ret = fwrite(temp, app->width/2, 1, fp);
+ temp += stride_width;
+ }
+
+ media_packet_get_video_plane_data_ptr(pkt, 2, &temp);
+ media_packet_get_video_stride_width(pkt, 2, &stride_width);
+ for (i = 0; i < app->height/2; i++) {
+ ret = fwrite(temp, app->width/2, 1, fp);
+ temp += stride_width;
+ }
+ }
+
+ g_print("codec dec output dumped!!%d\n", ret);
+ fclose(fp);
}
+
projects / platform / core / api / mediacodec.git / commitdiff