static int gst_muxer_stop(MMHandleType pHandle);
static int gst_muxer_unprepare(MMHandleType pHandle);
static int gst_muxer_destroy(MMHandleType pHandle);
-static int gst_set_error_cb(MMHandleType pHandle,
- gst_error_cb callback, void* user_data);
+static int gst_muxer_set_error_cb(MMHandleType pHandle,
+ gst_muxer_error_cb callback, void* user_data);
+static void _generate_header_aac_adts(unsigned char *buffer, int packetLen, int samplerate, int channel);
/* Media Muxer API common */
static media_port_muxer_ops def_mux_ops = {
.stop = gst_muxer_stop,
.unprepare = gst_muxer_unprepare,
.destroy = gst_muxer_destroy,
- .set_error_cb = gst_set_error_cb,
+ .set_error_cb = gst_muxer_set_error_cb,
};
int gst_mediamuxer_port_register(media_port_muxer_ops *pOps)
new_mediamuxer->eos_flg = false;
*pHandle = (MMHandleType) new_mediamuxer;
+
+ gst_init(NULL, NULL);
+
MEDIAMUXER_FLEAVE();
return ret;
ERROR:
mxgst_handle_t *mx_handle_gst = (mxgst_handle_t *) pHandle;
/* Set desired parameters */
- mx_handle_gst->output_uri = uri;
+ MEDIAMUXER_FREEIF(mx_handle_gst->output_uri);
+ mx_handle_gst->output_uri = g_strdup((const gchar *)uri);
mx_handle_gst->muxed_format = format;
MEDIAMUXER_FLEAVE();
return ret;
}
+static GstCaps * __gst_codec_specific_caps(media_format_mimetype_e mimetype)
+{
+ MEDIAMUXER_FENTER();
+ GstCaps *new_caps = NULL;
+ switch (mimetype) {
+ /* video */
+ case MEDIA_FORMAT_H261:
+ break;
+ case MEDIA_FORMAT_H263:
+ case MEDIA_FORMAT_H263P:
+ new_caps = gst_caps_new_simple("video/x-h263",
+ "variant", G_TYPE_STRING, "itu", NULL);
+ if (!new_caps) {
+ MX_E("Fail to make simple caps");
+ return NULL;
+ }
+ break;
+ case MEDIA_FORMAT_H264_SP:
+ case MEDIA_FORMAT_H264_MP:
+ case MEDIA_FORMAT_H264_HP:
+ new_caps = gst_caps_new_simple("video/x-h264",
+ "stream-format", G_TYPE_STRING, "byte-stream", NULL);
+ if (!new_caps) {
+ MX_E("Fail to make simple caps");
+ return NULL;
+ }
+ break;
+ case MEDIA_FORMAT_MJPEG:
+ break;
+ case MEDIA_FORMAT_MPEG1:
+ break;
+ case MEDIA_FORMAT_MPEG2_SP:
+ break;
+ case MEDIA_FORMAT_MPEG2_MP:
+ break;
+ case MEDIA_FORMAT_MPEG2_HP:
+ break;
+ case MEDIA_FORMAT_MPEG4_SP:
+ new_caps = gst_caps_new_simple("video/mpeg",
+ "mpegversion", G_TYPE_INT, 4, NULL);
+ if (!new_caps) {
+ MX_E("Fail to make simple caps");
+ return NULL;
+ }
+ break;
+ case MEDIA_FORMAT_MPEG4_ASP:
+ break;
+ case MEDIA_FORMAT_HEVC:
+ break;
+ case MEDIA_FORMAT_VP8:
+ break;
+ case MEDIA_FORMAT_VP9:
+ break;
+ case MEDIA_FORMAT_VC1:
+ break;
+ case MEDIA_FORMAT_I420:
+ break;
+ case MEDIA_FORMAT_NV12:
+ break;
+ case MEDIA_FORMAT_NV12T:
+ break;
+ case MEDIA_FORMAT_YV12:
+ break;
+ case MEDIA_FORMAT_NV21:
+ break;
+ case MEDIA_FORMAT_NV16:
+ break;
+ case MEDIA_FORMAT_YUYV:
+ break;
+ case MEDIA_FORMAT_UYVY:
+ break;
+ case MEDIA_FORMAT_422P:
+ break;
+ case MEDIA_FORMAT_RGB565:
+ break;
+ case MEDIA_FORMAT_RGB888:
+ break;
+ case MEDIA_FORMAT_RGBA:
+ break;
+ case MEDIA_FORMAT_ARGB:
+ break;
+ /* audio */
+ case MEDIA_FORMAT_L16:
+ break;
+ case MEDIA_FORMAT_ALAW:
+ break;
+ case MEDIA_FORMAT_ULAW:
+ break;
+ case MEDIA_FORMAT_AMR_NB:
+ new_caps = gst_caps_new_empty_simple("audio/x-amr-nb-sh");
+ if (!new_caps) {
+ MX_E("Fail to make simple caps");
+ return NULL;
+ }
+ break;
+ case MEDIA_FORMAT_AMR_WB:
+ new_caps = gst_caps_new_empty_simple("audio/x-amr-wb-sh");
+ if (!new_caps) {
+ MX_E("Fail to make simple caps");
+ return NULL;
+ }
+ break;
+ case MEDIA_FORMAT_G729:
+ break;
+ case MEDIA_FORMAT_AAC_LC:
+ new_caps = gst_caps_new_simple("audio/mpeg",
+ "mpegversion", G_TYPE_INT, 4, NULL);
+ if (!new_caps) {
+ MX_E("Fail to make simple caps");
+ return NULL;
+ }
+ break;
+ case MEDIA_FORMAT_AAC_HE:
+ new_caps = gst_caps_new_simple("audio/mpeg",
+ "mpegversion", G_TYPE_INT, 4, NULL);
+ if (!new_caps) {
+ MX_E("Fail to make simple caps");
+ return NULL;
+ }
+ break;
+ case MEDIA_FORMAT_AAC_HE_PS:
+ new_caps = gst_caps_new_simple("audio/mpeg",
+ "mpegversion", G_TYPE_INT, 4, NULL);
+ if (!new_caps) {
+ MX_E("Fail to make simple caps");
+ return NULL;
+ }
+ break;
+ case MEDIA_FORMAT_MP3:
+ break;
+ case MEDIA_FORMAT_VORBIS:
+ break;
+ case MEDIA_FORMAT_PCM:
+ break;
+ case MEDIA_FORMAT_PCMA:
+ break;
+ case MEDIA_FORMAT_PCMU:
+ break;
+ default:
+ MX_E("Unknown media mimeype %d. Assuming H264\n", mimetype);
+ break;
+ }
+ MEDIAMUXER_FLEAVE();
+ return new_caps;
+}
+
+int _gst_set_caps(MMHandleType pHandle, media_format_h format, int track_index)
+{
+ MEDIAMUXER_FENTER();
+ gint ret = MX_ERROR_NONE;
+ GstCaps *new_caps;
+ mxgst_handle_t *gst_handle = (mxgst_handle_t *) pHandle;
+ media_format_type_e formattype;
+ mx_gst_track *current = NULL;
+ media_format_mimetype_e current_mime;
+
+ /* Reach that track index and set the codec data */
+ for (current = gst_handle->track_info.track_head; current; current = current->next)
+ if (current->track_index == track_index)
+ break;
+
+ if ((!current) || (current->track_index != track_index)) {
+ ret = MX_ERROR_COMMON_INVALID_ARGUMENT;
+ goto ERROR;
+ }
+
+ if (media_format_get_type(format, &formattype)) {
+ MX_E("media_format_get_type failed\n");
+ goto ERROR;
+ }
+
+ switch (formattype) {
+ case MEDIA_FORMAT_AUDIO:
+ /* Following check is safe but not mandatory. */
+ if ((current->track_index)%NO_OF_TRACK_TYPES != 1) {
+ MX_E("This is not an audio track_index. Track_index is not in 3*n+1 format\n");
+ goto ERROR;
+ }
+
+ /* return if track_mime is different to current_mime */
+ if (media_format_get_audio_info(format, ¤t_mime, NULL, NULL, NULL, NULL)
+ != MEDIA_FORMAT_ERROR_NONE) {
+ MX_E("cant read audio mime in packet. returning\n");
+ return MX_ERROR_INVALID_ARGUMENT;
+ }
+
+ if (current->caps == NULL) {
+
+ new_caps = __gst_codec_specific_caps(current_mime);
+
+ if (new_caps == NULL) {
+ MX_E("Setting Audio caps failed\n");
+ ret = MX_ERROR_UNKNOWN;
+ break;
+ }
+ gchar *caps_string = NULL;
+ caps_string = gst_caps_to_string(new_caps);
+ MX_I("New cap is = %s\n", caps_string);
+ if (caps_string)
+ g_free(caps_string);
+ current->caps = new_caps;
+ }
+ break;
+ case MEDIA_FORMAT_VIDEO:
+ /* Following check is safe but not mandatory. */
+ if ((current->track_index)%NO_OF_TRACK_TYPES != 0) {
+ MX_E("This is not an video track_index. Video track_index is not in 3*n format\n");
+ goto ERROR;
+ }
+
+ /* return if track_mime is different to current_mime */
+ if (media_format_get_video_info(format, ¤t_mime, NULL, NULL, NULL, NULL)
+ != MEDIA_FORMAT_ERROR_NONE) {
+ MX_E("cant read video mime. returning\n");
+ return MX_ERROR_INVALID_ARGUMENT;
+ }
+
+ if (current->caps == NULL) {
+ new_caps = __gst_codec_specific_caps(current_mime);
+ if (new_caps == NULL) {
+ MX_E("Setting Audio caps failed\n");
+ ret = MX_ERROR_UNKNOWN;
+ break;
+ }
+ gchar *caps_string = NULL;
+ caps_string = gst_caps_to_string(new_caps);
+ MX_I("New cap is = %s\n", caps_string);
+ if (caps_string)
+ g_free(caps_string);
+ current->caps = new_caps;
+ }
+ break;
+
+ case MEDIA_FORMAT_CONTAINER:
+ case MEDIA_FORMAT_UNKNOWN:
+ default:
+ MX_E("Unknown format type\n");
+ }
+ MEDIAMUXER_FLEAVE();
+ return ret;
+ERROR:
+ ret = MX_ERROR_UNKNOWN;
+ MEDIAMUXER_FLEAVE();
+ return ret;
+}
+
static int gst_muxer_add_track(MMHandleType pHandle,
media_format_h media_format, int *track_index)
{
}
MX_I("Memory allocated to track = %p\n", current);
current->media_format = (void *)media_format;
+ media_format_ref((media_format_h)current->media_format);
current->start_feed = 1;
current->stop_feed = 0;
current->caps = NULL;
last->next = current;
}
- if (media_format_get_video_info(media_format, &mimetype, NULL, NULL, NULL, NULL)
- == MEDIA_FORMAT_ERROR_NONE) {
+ if (media_format_get_video_info((media_format_h)current->media_format,
+ &mimetype, NULL, NULL, NULL, NULL) == MEDIA_FORMAT_ERROR_NONE) {
if ((mx_handle_gst->muxed_format == MEDIAMUXER_CONTAINER_FORMAT_MP4
&& (mimetype == MEDIA_FORMAT_H264_SP || mimetype == MEDIA_FORMAT_H264_MP || mimetype == MEDIA_FORMAT_H264_HP
|| mimetype == MEDIA_FORMAT_H263
} else {
MX_E("Unsupported/Mismatched video MIME Type: %x\n", mimetype);
}
- } else if (media_format_get_audio_info(media_format, &mimetype, NULL, NULL, NULL, NULL) ==
- MEDIA_FORMAT_ERROR_NONE) {
+ } else if (media_format_get_audio_info((media_format_h)current->media_format,
+ &mimetype, NULL, NULL, NULL, NULL) == MEDIA_FORMAT_ERROR_NONE) {
if ((mx_handle_gst->muxed_format == MEDIAMUXER_CONTAINER_FORMAT_MP4
&& (mimetype == MEDIA_FORMAT_AAC_LC || mimetype == MEDIA_FORMAT_AAC_HE || mimetype == MEDIA_FORMAT_AAC_HE_PS))
|| (mx_handle_gst->muxed_format == MEDIAMUXER_CONTAINER_FORMAT_3GP
} else {
MX_E("Unsupported/Mismatched audio MIME Type: %x\n", mimetype);
}
- } else if (media_format_get_text_info(media_format, &mimetype, &text_type_e)
- == MEDIA_FORMAT_ERROR_NONE) {
+ } else if (media_format_get_text_info((media_format_h)current->media_format,
+ &mimetype, &text_type_e) == MEDIA_FORMAT_ERROR_NONE) {
if ((mimetype == MEDIA_FORMAT_TEXT_MP4)
&& (mx_handle_gst->muxed_format == MEDIAMUXER_CONTAINER_FORMAT_MP4
|| mx_handle_gst->muxed_format == MEDIAMUXER_CONTAINER_FORMAT_3GP)) {
} else {
MX_E("Unsupported A/V/Subs MIME Type: %x\n", mimetype);
}
+ ret = _gst_set_caps(mx_handle_gst, (media_format_h)current->media_format, *track_index);
+ if (ret != MX_ERROR_NONE) {
+ MX_E("Set caps error");
+ return ret;
+ }
MEDIAMUXER_FLEAVE();
return ret;
}
else
MX_I("Unknown GStreamer callback error\n");
/* Update the user callback with ret value */
- ((gst_error_cb)gst_handle->user_cb[_GST_EVENT_TYPE_ERROR])(error_val, (void*)error->message);
+ ((gst_muxer_error_cb)gst_handle->user_cb[_GST_EVENT_TYPE_ERROR])
+ (error_val, gst_handle->user_data[_GST_EVENT_TYPE_ERROR]);
return ret;
}
/* Initialize GStreamer */
/* Note: Replace the arguments of gst_init to pass the command line args to GStreamer. */
- gst_init(NULL, NULL);
/* Create the empty pipeline */
gst_handle->pipeline = gst_pipeline_new("Muxer Gst pipeline");
goto ERROR;
} else {
if (gst_handle->muxed_format == MEDIAMUXER_CONTAINER_FORMAT_MP4)
- gst_handle->muxer = gst_element_factory_make("qtmux", "qtmux");
+ gst_handle->muxer = gst_element_factory_make("mp4mux", "mp4mux");
/* gst_element_factory_make("mp4mux", "mp4mux"); */
else if (gst_handle->muxed_format == MEDIAMUXER_CONTAINER_FORMAT_3GP)
gst_handle->muxer = gst_element_factory_make("3gppmux", "3gppmux");
gst_app_src_set_stream_type((GstAppSrc *)current->appsrc,
GST_APP_STREAM_TYPE_STREAM);
#endif
+ if (current->caps)
+ g_object_set(current->appsrc, "caps", current->caps, NULL);
+
+ g_object_set(current->appsrc, "max-bytes", (guint64)3 * 1024 * 1024, NULL);
+
gst_element_link(current->appsrc, current->parser);
/* Link videoparse to muxer_video_pad. Request for muxer A/V pads. */
gst_app_src_set_stream_type((GstAppSrc *)current->appsrc,
GST_APP_STREAM_TYPE_STREAM);
#endif
+ if (current->caps)
+ g_object_set(current->appsrc, "caps", current->caps, NULL);
+
+ g_object_set(current->appsrc, "max-bytes", 3 * 1024 * 1024, NULL);
+
/* For wav, wavenc is muxer */
if (gst_handle->muxed_format == MEDIAMUXER_CONTAINER_FORMAT_WAV
|| gst_handle->muxed_format == MEDIAMUXER_CONTAINER_FORMAT_AAC_ADTS
gst_bin_add_many(GST_BIN(gst_handle->pipeline), current->appsrc, NULL);
/* Set subtitle_caps for corresponding src elements */
- g_object_set(current->appsrc, "caps", gst_caps_from_string(current->caps), NULL);
+ if (current->caps)
+ g_object_set(current->appsrc, "caps", current->caps, NULL);
g_object_set(current->appsrc, "format", GST_FORMAT_TIME, NULL);
#ifdef ASYCHRONOUS_WRITE
return ret;
}
-int __gst_codec_specific_caps(GstCaps *new_cap,
- media_format_mimetype_e mimetype)
+static int _gst_copy_media_packet_to_buf(mx_gst_track *current, media_packet_h out_pkt,
+ GstBuffer *buffer)
{
+ void *pkt_data;
+ uint64_t size;
+ unsigned char *data_ptr = NULL;
MEDIAMUXER_FENTER();
- GValue val = G_VALUE_INIT;
- switch (mimetype) {
- /* video */
- case MEDIA_FORMAT_H261:
- break;
- case MEDIA_FORMAT_H263:
- break;
- case MEDIA_FORMAT_H263P:
- break;
- case MEDIA_FORMAT_H264_SP:
- break;
- case MEDIA_FORMAT_H264_MP:
- break;
- case MEDIA_FORMAT_H264_HP:
- break;
- case MEDIA_FORMAT_MJPEG:
- break;
- case MEDIA_FORMAT_MPEG1:
- break;
- case MEDIA_FORMAT_MPEG2_SP:
- break;
- case MEDIA_FORMAT_MPEG2_MP:
- break;
- case MEDIA_FORMAT_MPEG2_HP:
- break;
- case MEDIA_FORMAT_MPEG4_SP:
- break;
- case MEDIA_FORMAT_MPEG4_ASP:
- break;
- case MEDIA_FORMAT_HEVC:
- break;
- case MEDIA_FORMAT_VP8:
- break;
- case MEDIA_FORMAT_VP9:
- break;
- case MEDIA_FORMAT_VC1:
- break;
- case MEDIA_FORMAT_I420:
- break;
- case MEDIA_FORMAT_NV12:
- break;
- case MEDIA_FORMAT_NV12T:
- break;
- case MEDIA_FORMAT_YV12:
- break;
- case MEDIA_FORMAT_NV21:
- break;
- case MEDIA_FORMAT_NV16:
- break;
- case MEDIA_FORMAT_YUYV:
- break;
- case MEDIA_FORMAT_UYVY:
- break;
- case MEDIA_FORMAT_422P:
- break;
- case MEDIA_FORMAT_RGB565:
- break;
- case MEDIA_FORMAT_RGB888:
- break;
- case MEDIA_FORMAT_RGBA:
- break;
- case MEDIA_FORMAT_ARGB:
- break;
- /* audio */
- case MEDIA_FORMAT_L16:
- break;
- case MEDIA_FORMAT_ALAW:
- break;
- case MEDIA_FORMAT_ULAW:
- break;
- case MEDIA_FORMAT_AMR_NB:
- break;
- case MEDIA_FORMAT_AMR_WB:
- break;
- case MEDIA_FORMAT_G729:
- break;
- case MEDIA_FORMAT_AAC_LC:
- g_value_init(&val, G_TYPE_INT);
- g_value_set_int(&val, 4);
- gst_caps_set_value(new_cap, "mpegversion", &val);
- break;
- case MEDIA_FORMAT_AAC_HE:
- g_value_init(&val, G_TYPE_INT);
- g_value_set_int(&val, 4);
- gst_caps_set_value(new_cap, "mpegversion", &val);
- break;
- case MEDIA_FORMAT_AAC_HE_PS:
- g_value_init(&val, G_TYPE_INT);
- g_value_set_int(&val, 4);
- gst_caps_set_value(new_cap, "mpegversion", &val);
- break;
- case MEDIA_FORMAT_MP3:
- break;
- case MEDIA_FORMAT_VORBIS:
- break;
- case MEDIA_FORMAT_PCM:
- break;
- case MEDIA_FORMAT_PCMA:
- break;
- case MEDIA_FORMAT_PCMU:
- break;
- default:
- MX_E("Unknown media mimeype %d. Assuming H264\n", mimetype);
- break;
- }
- MEDIAMUXER_FLEAVE();
- return 0;
-}
-
+ MEDIAMUXER_CHECK_NULL(out_pkt);
+ /* GstMapInfo map; */
+ int ret = MX_ERROR_NONE;
-int _gst_set_caps(MMHandleType pHandle, media_packet_h packet, int track_index)
-{
- MEDIAMUXER_FENTER();
- gint ret = MX_ERROR_NONE;
- GstCaps *new_cap;
- media_format_h format;
- mxgst_handle_t *gst_handle = (mxgst_handle_t *) pHandle;
- media_format_type_e formattype;
- char *codec_data;
+#if 0
+ /* get codec data and set caps */
+ char *pkt_codec_data;
unsigned int codec_data_size;
- mx_gst_track *current = NULL;
- media_format_mimetype_e track_mime;
- media_format_mimetype_e current_mime;
-
- /* Reach that track index and set the codec data */
- for (current = gst_handle->track_info.track_head; current; current = current->next)
- if (current->track_index == track_index)
- break;
-
- if ((!current) || (current->track_index != track_index)) {
- ret = MX_ERROR_COMMON_INVALID_ARGUMENT;
- goto ERROR;
- }
-
- if (media_packet_get_format(packet, &format)) {
- MX_E("media_format_get_formati call failed \n");
- goto ERROR;
- }
- if (media_format_get_type(format, &formattype)) {
- MX_E("media_format_get_type failed\n");
- goto ERROR;
+ if (media_packet_get_codec_data(out_pkt, (void **)&pkt_codec_data, &codec_data_size) == 0) {
+ GstCaps *appsrc_caps = NULL;
+ GstCaps *new_appsrc_caps = NULL;
+ GstBuffer *codec_data_buffer = NULL;
+ codec_data_buffer = gst_buffer_new();
+ gchar *codec_data_caps_string = NULL;
+ gst_buffer_append_memory(codec_data_buffer,
+ gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, pkt_codec_data, codec_data_size, 0,
+ codec_data_size, pkt_codec_data, NULL));
+
+ g_object_get(G_OBJECT(current->appsrc), "caps", &appsrc_caps, NULL);
+ codec_data_caps_string = gst_caps_to_string(appsrc_caps);
+ MX_I("[LGB] Appsrc caps is %s", codec_data_caps_string);
+ g_free(codec_data_caps_string);
+ if (appsrc_caps)
+ new_appsrc_caps = gst_caps_copy(appsrc_caps);
+
+ if (new_appsrc_caps)
+ gst_caps_set_simple(new_appsrc_caps, "codec_data", GST_TYPE_BUFFER, codec_data_buffer, NULL);
+
+ codec_data_caps_string = gst_caps_to_string(new_appsrc_caps);
+ MX_I("[LGB] New appsrc caps is %s", codec_data_caps_string);
+ g_free(codec_data_caps_string);
+
+ g_object_set(G_OBJECT(current->appsrc), "caps", new_appsrc_caps, NULL);
+ gst_caps_unref(appsrc_caps);
+ gst_caps_unref(new_appsrc_caps);
+ gst_buffer_unref(codec_data_buffer);
+ MX_I("codec data is %p, codec_data_size %u", pkt_codec_data, codec_data_size);
}
-
- switch (formattype) {
- case MEDIA_FORMAT_AUDIO:
- /* Following check is safe but not mandatory. */
- if ((current->track_index)%NO_OF_TRACK_TYPES != 1) {
- MX_E("This is not an audio track_index. Track_index is not in 3*n+1 format\n");
- goto ERROR;
- }
-
- /* return if track_mime is different to current_mime */
- if (media_format_get_audio_info((media_format_h)(current->media_format), &track_mime, NULL, NULL, NULL, NULL)
- == MEDIA_FORMAT_ERROR_NONE) {
- if (media_format_get_audio_info((media_format_h)(format), ¤t_mime, NULL, NULL, NULL, NULL)
- == MEDIA_FORMAT_ERROR_NONE) {
- if (track_mime != current_mime) {
- MX_E("audio track_mime is not matching with packet mime. returning\n");
- return MX_ERROR_INVALID_ARGUMENT;
- }
- } else {
- MX_E("cant read audio mime in packet. returning\n");
- return MX_ERROR_INVALID_ARGUMENT;
- }
- } else {
- MX_E("cant read audio mime, set during add_track. returning\n");
- return MX_ERROR_INVALID_ARGUMENT;
- }
-
- if (media_packet_get_extra(packet,
- (void **)&codec_data)) {
- MX_E("media_packet_get_extra call failed\n");
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- codec_data_size = strlen(codec_data) + 1;
-
- if ((strlen(codec_data)+1) != codec_data_size) {
- MX_E("strlen(codec_data)+1 is not matching with codec_data_size. They are supposed to be equal.\n");
- return MX_ERROR_INVALID_ARGUMENT;
- }
- MX_I("Extracted codec data is =%s size is %d\n", codec_data, codec_data_size);
-
- if (current->caps == NULL ||
- g_strcmp0(codec_data, current->caps) != 0) {
-
-#ifdef SEND_FULL_CAPS_VIA_CODEC_DATA
- /* Debugging purpose. The whole caps filter can be sent via codec_data */
- new_cap = gst_caps_from_string(codec_data);
- MX_I("codec cap is=%s\n", codec_data);
- g_object_set(current->appsrc, "caps", new_cap, NULL);
- if (current->caps == NULL) {
- current->caps = (char *)g_malloc(codec_data_size);
- if (current->caps == NULL) {
- MX_E("[%s][%d] memory allocation failed\n", __func__, __LINE__);
- gst_caps_unref(new_cap);
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- }
- g_stpcpy(current->caps, codec_data);
-#else
- gchar *caps_string = NULL;
- int channel = 0;
- int samplerate = 0;
- int bit = 0;
- int avg_bps = 0;
- media_format_mimetype_e mimetype = MEDIA_FORMAT_MAX;
- if (media_format_get_audio_info(format,
- &mimetype, &channel, &samplerate,
- &bit, &avg_bps)) {
- MX_E("media_format_get_audio_info call failed\n");
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- if (current->caps == NULL) {
- current->caps = (char *)g_malloc(codec_data_size);
- if (current->caps == NULL) {
- MX_E("[%s][%d]memory allocation failed\n", __func__, __LINE__);
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- }
- new_cap = gst_caps_from_string(codec_data);
- if (__gst_codec_specific_caps(new_cap, mimetype)) {
- MX_E("Setting Audio caps failed\n");
- gst_caps_unref(new_cap);
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- caps_string = gst_caps_to_string(new_cap);
- MX_I("New cap set by codec data is = %s\n",
- caps_string);
- if (caps_string)
- g_free(caps_string);
- g_object_set(current->appsrc, "caps", new_cap, NULL);
- MX_I("copying current->caps = codec_data\n");
- g_stpcpy(current->caps, codec_data);
#endif
- gst_caps_unref(new_cap);
- }
- break;
- case MEDIA_FORMAT_VIDEO:
- /* Following check is safe but not mandatory. */
- if ((current->track_index)%NO_OF_TRACK_TYPES != 0) {
- MX_E("This is not an video track_index. Video track_index is not in 3*n format\n");
- goto ERROR;
- }
-
- /* return if track_mime is different to current_mime */
- if (media_format_get_video_info((media_format_h)(current->media_format), &track_mime, NULL, NULL, NULL, NULL)
- == MEDIA_FORMAT_ERROR_NONE) {
- if (media_format_get_video_info((media_format_h)(format), ¤t_mime, NULL, NULL, NULL, NULL)
- == MEDIA_FORMAT_ERROR_NONE) {
- if (track_mime != current_mime) {
- MX_E("video track_mime is not matching with packet mime. returning\n");
- return MX_ERROR_INVALID_ARGUMENT;
- }
- } else {
- MX_E("cant read video mime. returning\n");
- return MX_ERROR_INVALID_ARGUMENT;
- }
- } else {
- MX_E("cant read video mime in packet. returning\n");
- return MX_ERROR_INVALID_ARGUMENT;
- }
-
- if (media_packet_get_extra(packet,
- (void **)&codec_data)) {
- MX_E("media_packet_get_extra call failed\n");
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- codec_data_size = strlen(codec_data) + 1;
+ media_packet_get_buffer_size(out_pkt, &size);
+ MX_I("Media packet Buffer capacity: %llu\n", size);
- if ((strlen(codec_data)+1) != codec_data_size) {
- MX_E("strlen(codec_data)+1 is not matching with codec_data_size. They are supposed to be equal.\n");
- return MX_ERROR_INVALID_ARGUMENT;
- }
- MX_I("codec data is =%s size is %d\n", codec_data, codec_data_size);
- if (current->caps == NULL ||
- g_strcmp0(codec_data, current->caps) != 0) {
-#ifdef SEND_FULL_CAPS_VIA_CODEC_DATA
- /* Debugging purpose. The whole caps filter can be sent via codec_data */
- codec_data_size = strlen(codec_data) + 1;
- MX_I("extracted codec data is =%s\n", codec_data);
- new_cap = gst_caps_from_string(codec_data);
- MX_I("New cap is=%s\n", codec_data);
- g_object_set(current->appsrc, "caps", new_cap, NULL);
- if (current->caps == NULL) {
- current->caps = (char *)g_malloc(codec_data_size);
- if (current->caps == NULL) {
- MX_E("[%s][%d] memory allocation failed\n", __func__, __LINE__);
- gst_caps_unref(new_cap);
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- }
- g_stpcpy(current->caps, codec_data);
-#else
- gchar *caps_string = NULL;
- GValue val = G_VALUE_INIT;
- int numerator = 1;
- int denominator = 1;
- int width = 0;
- int height = 0;
- int avg_bps = 0;
- int max_bps = 0;
- media_format_mimetype_e mimetype = MEDIA_FORMAT_MAX;
-
- if (media_format_get_video_info(format,
- &mimetype, &width, &height,
- &avg_bps, &max_bps)) {
- MX_E("media_format_get_video_info call failed\n");
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- if (current->caps == NULL) {
- current->caps = (char *)g_malloc(codec_data_size);
- if (current->caps == NULL) {
- MX_E("[%s][%d] memory allocation failed\n", __func__, __LINE__);
- ret = MX_ERROR_UNKNOWN;
- break;
+ /* Check adts header */
+ media_format_h format = NULL;
+ unsigned char buf_adts[ADTS_HEADER_SIZE] = {0, };
+ bool is_adts = TRUE;
+ if (media_packet_get_format(out_pkt, &format) == MEDIA_PACKET_ERROR_NONE) {
+ media_format_mimetype_e a_mime;
+ int channel = 0;
+ int samplerate = 0;
+ int bit = 0;
+ if (media_format_get_audio_info(format, &a_mime, &channel, &samplerate,
+ &bit, NULL) == MEDIA_FORMAT_ERROR_NONE) {
+ if (a_mime == MEDIA_FORMAT_AAC_LC) {
+ media_format_get_audio_aac_type(format, &is_adts);
+ if (is_adts == FALSE) {
+ /* generator adts header */
+ size = size + ADTS_HEADER_SIZE;
+ _generate_header_aac_adts(buf_adts, size, samplerate, channel);
+ MX_I("Add adts header");
}
}
- new_cap = gst_caps_from_string(codec_data);
- MX_I("New cap set by codec data is=%s\n", codec_data);
- if (__gst_codec_specific_caps(new_cap, mimetype)) {
- MX_E("Setting Video caps failed\n");
- gst_caps_unref(new_cap);
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- g_stpcpy(current->caps, codec_data);
-
- if (media_format_get_video_frame_rate(format, &numerator))
- MX_E("media_format_get_video_info call failed\n");
- g_value_init(&val, GST_TYPE_FRACTION);
- gst_value_set_fraction(&val, numerator, denominator);
- gst_caps_set_value(new_cap, "framerate", &val);
- caps_string = gst_caps_to_string(new_cap);
- MX_I("New cap set by codec data is = %s\n",
- caps_string);
- if (caps_string)
- g_free(caps_string);
- g_object_set(current->appsrc, "caps", new_cap, NULL);
-#endif
- gst_caps_unref(new_cap);
}
- break;
- case MEDIA_FORMAT_TEXT:
- /* Following check is safe but not mandatory. */
- if ((current->track_index)%NO_OF_TRACK_TYPES != 2) {
- MX_E("Subtitle track_index is not in 3*n+2 format\n");
- goto ERROR;
- }
- if (media_packet_get_codec_data(packet,
- (void **)&codec_data, &codec_data_size)) {
- MX_E("media_packet_get_codec_data call failed\n");
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- MX_I("codec data for subtitle = %s size is %d\n", codec_data, codec_data_size);
- if (current->caps == NULL ||
- g_strcmp0(codec_data, current->caps) != 0) {
-
-#ifdef SEND_FULL_CAPS_VIA_CODEC_DATA
- /* Debugging purpose. The whole caps filter can be sent via codec_data */
- media_packet_get_codec_data(packet, (void **)&codec_data,
- &codec_data_size);
- MX_I("extracted codec data is =%s\n", codec_data);
- new_cap = gst_caps_from_string(codec_data);
- MX_I("New cap is=%s\n", codec_data);
- g_object_set(current->appsrc, "caps", new_cap, NULL);
- if (current->caps == NULL) {
- current->caps = (char *)g_malloc(codec_data_size);
- if (current->caps == NULL) {
- MX_E("[%s][%d] memory allocation failed\n", __func__, __LINE__);
- gst_caps_unref(new_cap);
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- }
- g_stpcpy(current->caps, codec_data);
-#else
- media_format_mimetype_e mimetype = -1;
- media_format_text_type_e text_type_e = -1;
- if (media_format_get_text_info(format,
- &mimetype, &text_type)) {
- MX_E("media_format_get_text_info call failed\n");
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- if (current->caps == NULL) {
- current->caps = (char *)g_malloc(codec_data_size);
- if (current->caps == NULL) {
- MX_E("[%s][%d] memory allocation failed\n", __func__, __LINE__);
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- }
- new_cap = gst_caps_from_string(codec_data);
- MX_I("New cap set by codec data is=%s\n", codec_data);
- if (__gst_codec_specific_caps(new_cap, mimetype)) {
- MX_E("Setting Subtitle caps failed\n");
- gst_caps_unref(new_cap);
- ret = MX_ERROR_UNKNOWN;
- break;
- }
- g_stpcpy(current->caps, codec_data);
- caps_string = gst_caps_to_string(new_cap);
- MX_I("New cap set by codec data is = %s\n",
- caps_string);
- if (caps_string)
- g_free(caps_string);
- g_object_set(current->appsrc, "caps", new_cap, NULL);
-#endif
- gst_caps_unref(new_cap);
- } else if (current != NULL) {
- MX_I("appsrc caps already set to %s\n", current->caps);
- }
- break;
-
- case MEDIA_FORMAT_CONTAINER:
- case MEDIA_FORMAT_UNKNOWN:
- default:
- MX_E("Unknown format type\n");
+ media_format_unref(format);
}
- MEDIAMUXER_FLEAVE();
- return ret;
-ERROR:
- ret = MX_ERROR_UNKNOWN;
- MEDIAMUXER_FLEAVE();
- return ret;
-}
-static int _gst_copy_media_packet_to_buf(media_packet_h out_pkt,
- GstBuffer *buffer)
-{
- MEDIAMUXER_FENTER();
- void *pkt_data;
- uint64_t size;
- unsigned char *data_ptr;
- MEDIAMUXER_FENTER();
- MEDIAMUXER_CHECK_NULL(out_pkt);
- /* GstMapInfo map; */
- int ret = MX_ERROR_NONE;
/* copy data */
- media_packet_get_buffer_size(out_pkt, &size);
- MX_I("Media packet Buffer capacity: %llu\n", size);
- data_ptr = (unsigned char *) g_malloc(size);
+ data_ptr = (unsigned char *)g_malloc(size);
if (!data_ptr) {
MX_E("Memory allocation failed in %s \n", __FUNCTION__);
ret = MX_MEMORY_ERROR;
ret = MX_ERROR_UNKNOWN;
goto ERROR;
}
- /* if (!gst_buffer_map (buffer, &map, GST_MAP_READ)) {
- MX_E("gst_buffer_map failed\n");
- ret = MX_ERROR_UNKNOWN;
- goto ERROR;
- } */
+
+ if (is_adts == FALSE) {
+ memcpy(data_ptr, (char *)buf_adts, ADTS_HEADER_SIZE);
+ memcpy(data_ptr + ADTS_HEADER_SIZE, (char *)pkt_data, size - ADTS_HEADER_SIZE);
+ } else {
+ memcpy(data_ptr, (char *)pkt_data, size);
+ }
+
uint64_t info;
- memcpy(data_ptr, (char *)pkt_data, size);
gst_buffer_insert_memory(buffer, -1,
gst_memory_new_wrapped(0, data_ptr, size, 0,
size, data_ptr, g_free));
goto ERROR;
}
- if (_gst_set_caps(pHandle, inbuf, track_index) != MX_ERROR_NONE) {
- ret = MX_ERROR_INVALID_ARGUMENT;
- goto ERROR;
- }
-
MX_I("Track_index passed = %d, working-with_track_index = %d\n", track_index, current->track_index);
GstBuffer *gst_inbuf2 = NULL;
gst_inbuf2 = gst_buffer_new();
/* ToDo: Add functionality to the following function */
/* MX_I("\nBefore buff=%x\n", gst_inbuf2); */
- _gst_copy_media_packet_to_buf(inbuf, gst_inbuf2);
+ _gst_copy_media_packet_to_buf(current, inbuf, gst_inbuf2);
if (track_index%NO_OF_TRACK_TYPES == 0) { /* NO_OF_TRACK_TYPES*n for video */
MX_I("Waiting till start_feed of current video track, index=%d is active\n", current->track_index);
}
/* Reset the media_format and track_index to default. */
if (current) {
+ media_format_unref((media_format_h)current->media_format);
current->media_format = NULL;
current->track_index = -1;
}
gst_element_set_state(gst_handle->pipeline, GST_STATE_NULL);
/* Free resources & set unused pointers to NULL */
- if (gst_handle->output_uri != NULL)
- gst_handle->output_uri = NULL;
+ MEDIAMUXER_FREEIF(gst_handle->output_uri);
current = gst_handle->track_info.track_head;
while (current) {
current = current->next; /* Update current */
/* Free prev & its contents */
- if (prev->media_format)
+ if (prev->media_format) {
+ media_format_unref((media_format_h)prev->media_format);
prev->media_format = NULL;
- if (prev->caps)
- g_free(prev->caps);
+ }
+ if (prev->caps) {
+ gst_caps_unref(prev->caps);
+ prev->caps = NULL;
+ }
g_free(prev);
}
mxgst_handle_t *new_mediamuxer = (mxgst_handle_t *) pHandle;
MX_I("__gst_muxer_destroy deallocating new_mediamuxer:%p\n", new_mediamuxer);
+ MEDIAMUXER_FREEIF(new_mediamuxer->output_uri);
g_free(new_mediamuxer);
MEDIAMUXER_FLEAVE();
return ret;
}
-int gst_set_error_cb(MMHandleType pHandle, gst_error_cb callback, void* user_data)
+int gst_muxer_set_error_cb(MMHandleType pHandle, gst_muxer_error_cb callback, void* user_data)
{
MEDIAMUXER_FENTER();
int ret = MX_ERROR_NONE;
}
MX_I("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
- gst_handle->user_cb[_GST_EVENT_TYPE_ERROR] = (gst_error_cb) callback;
+ gst_handle->user_cb[_GST_EVENT_TYPE_ERROR] = (gst_muxer_error_cb) callback;
gst_handle->user_data[_GST_EVENT_TYPE_ERROR] = user_data;
MEDIAMUXER_FLEAVE();
return MX_ERROR_NONE;
MEDIAMUXER_FLEAVE();
return ret;
}
+
+static void _generate_header_aac_adts(unsigned char *buffer, int packetLen, int samplerate, int channel)
+{
+ int profile = 2; /* AAC LC (0x01) */
+ int freqIdx = 4; /* 44KHz (0x04) */
+ int chanCfg = 1; /* CPE (0x01) */
+
+ 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;
+
+ /* Make ADTS header */
+ 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;
+}
+
#include <mediamuxer.h>
#include <mediamuxer_private.h>
#include <media_packet_internal.h>
-
+#include <media_format.h>
#include <media_codec.h>
+#include <mediademuxer.h>
+
#define DUMP_OUTBUF 1
/*-----------------------------------------------------------------------
| GLOBAL VARIABLE DEFINITIONS: |
CURRENT_STATUS_RAW_AUDIO_FILENAME,
CURRENT_STATUS_SET_VENC_INFO,
CURRENT_STATUS_SET_AENC_INFO,
+ CURRENT_STATUS_FILENAME,
+ CURRENT_STATUS_PREPARE_DEMUXER,
};
mediamuxer_h myMuxer = 0;
int iseos_codec = 0;
bool validate_with_codec = false;
bool validate_multitrack = false;
+bool validate_with_demux = false;
char media_file[MAX_INPUT_SIZE];
char data_sink[MAX_INPUT_SIZE];
bool have_mp4 = false;
int track_index_text = -1;
int g_menu_state = CURRENT_STATUS_MAINMENU;
+int demuxer_index_vid = -1;
+int demuxer_index_aud = -1;
+bool is_video = false;
+bool is_audio = false;
+
int demux_mp4();
int demux_audio();
static void display_sub_basic();
void mediacodec_config_prepare(void);
void mediacodec_config_set_aenc_info(int samplerate, int chnnel, int bit, int bitrate);
+int test_mediademuxer_create();
+int test_mediademuxer_set_data_source(const char *path);
+int test_mediademuxer_prepare();
+int test_mediademuxer_get_track_count(int *track_num);
+int test_mediademuxer_select_track(int track_num);
+int test_mediademuxer_start();
+int test_mediademuxer_stop();
+int test_mediademuxer_get_track_info(int track_num, media_format_h *format, bool *is_video, bool *is_audio);
+void test_mediademuxer_process_all(bool is_video, bool is_audio);
+
/*-----------------------------------------------------------------------
| LOCAL FUNCTION |
-----------------------------------------------------------------------*/
int avg_bps = 0;
int max_bps = 0;
- g_print("test_mediamuxer_add_track_video\n");
- media_format_create(&media_format);
-
- /* MEDIA_FORMAT_H264_SP MEDIA_FORMAT_H264_MP MEDIA_FORMAT_H264_HP */
- if (strncmp(data_sink, "11", 2) == 0) {
- if (media_format_set_video_mime(media_format, MEDIA_FORMAT_H264_SP) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation\n");
- } else if (strncmp(data_sink, "12", 2) == 0) {
- if (media_format_set_video_mime(media_format, MEDIA_FORMAT_H263) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation\n");
- } else if (strncmp(data_sink, "13", 2) == 0) {
- if (media_format_set_video_mime(media_format, MEDIA_FORMAT_MPEG4_SP) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation\n");
- } else if (strncmp(data_sink, "21", 2) == 0 || strncmp(data_sink, "23", 2) == 0) {
- if (media_format_set_video_mime(media_format, MEDIA_FORMAT_H264_SP) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation\n");
- } else if (strncmp(data_sink, "22", 2) == 0 || strncmp(data_sink, "24", 2) == 0) {
- if (media_format_set_video_mime(media_format, MEDIA_FORMAT_H263) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation\n");
- } else if (strncmp(data_sink, "31", 2) == 0
- || strncmp(data_sink, "41", 2) == 0 || strncmp(data_sink, "42", 2) == 0
- || strncmp(data_sink, "51", 2) == 0) {
- g_print("Add video track is invalid for wav/amr\n");
- return 1;
- }
+ if (!validate_with_demux) {
+
+ g_print("test_mediamuxer_add_track_video\n");
+ media_format_create(&media_format);
+
+ /* MEDIA_FORMAT_H264_SP MEDIA_FORMAT_H264_MP MEDIA_FORMAT_H264_HP */
+ if (strncmp(data_sink, "11", 2) == 0) {
+ if (media_format_set_video_mime(media_format, MEDIA_FORMAT_H264_SP) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation\n");
+ } else if (strncmp(data_sink, "12", 2) == 0) {
+ if (media_format_set_video_mime(media_format, MEDIA_FORMAT_H263) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation\n");
+ } else if (strncmp(data_sink, "13", 2) == 0) {
+ if (media_format_set_video_mime(media_format, MEDIA_FORMAT_MPEG4_SP) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation\n");
+ } else if (strncmp(data_sink, "21", 2) == 0 || strncmp(data_sink, "23", 2) == 0) {
+ if (media_format_set_video_mime(media_format, MEDIA_FORMAT_H264_SP) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation\n");
+ } else if (strncmp(data_sink, "22", 2) == 0 || strncmp(data_sink, "24", 2) == 0) {
+ if (media_format_set_video_mime(media_format, MEDIA_FORMAT_H263) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation\n");
+ } else if (strncmp(data_sink, "31", 2) == 0
+ || strncmp(data_sink, "41", 2) == 0 || strncmp(data_sink, "42", 2) == 0
+ || strncmp(data_sink, "51", 2) == 0) {
+ g_print("Add video track is invalid for wav/amr\n");
+ return 1;
+ }
- if (validate_with_codec) {
- media_format_set_video_width(media_format, width);
- media_format_set_video_height(media_format, height);
- } else {
- media_format_set_video_width(media_format, 640);
- media_format_set_video_height(media_format, 480);
- }
- media_format_set_video_avg_bps(media_format, 256000);
- media_format_set_video_max_bps(media_format, 256000);
+ if (validate_with_codec) {
+ media_format_set_video_width(media_format, width);
+ media_format_set_video_height(media_format, height);
+ } else {
+ media_format_set_video_width(media_format, 640);
+ media_format_set_video_height(media_format, 480);
+ }
+ media_format_set_video_avg_bps(media_format, 256000);
+ media_format_set_video_max_bps(media_format, 256000);
- media_format_get_video_info(media_format, &mimetype, &width, &height, &avg_bps, &max_bps);
+ media_format_get_video_info(media_format, &mimetype, &width, &height, &avg_bps, &max_bps);
- g_print("Video Mimetype trying to set: %x (H264 : %x)\n", (int)(mimetype), (int)(MEDIA_FORMAT_H264_SP));
- g_print("Video param trying to set: (width, height, avg_bps, max_bps): %d %d %d %d \n",
- width, height, avg_bps, max_bps);
+ g_print("Video Mimetype trying to set: %x (H264 : %x)\n", (int)(mimetype), (int)(MEDIA_FORMAT_H264_SP));
+ g_print("Video param trying to set: (width, height, avg_bps, max_bps): %d %d %d %d \n",
+ width, height, avg_bps, max_bps);
- /* To add video track */
- mediamuxer_add_track(myMuxer, media_format, &track_index_vid);
- g_print("Video Track index is returned : %d\n", track_index_vid);
+ /* To add video track */
+ mediamuxer_add_track(myMuxer, media_format, &track_index_vid);
+ g_print("Video Track index is returned : %d\n", track_index_vid);
+ } else {
+ mediamuxer_add_track(myMuxer, media_format, &track_index_vid);
+ g_print("Video Track index returned is: %d\n", track_index_vid);
+ test_mediademuxer_select_track(demuxer_index_vid);
+ }
return 0;
}
int test_mediamuxer_add_track_audio()
{
media_format_mimetype_e mimetype;
- int avg_bps = 128000;
- g_print("test_mediamuxer_add_track_audio\n");
- media_format_create(&media_format_a);
-
- if (strncmp(data_sink, "11", 2) == 0 || strncmp(data_sink, "12", 2) == 0 || strncmp(data_sink, "13", 2) == 0) {
- /* MEDIA_FORMAT_AAC_LC MEDIA_FORMAT_AAC_HE MEDIA_FORMAT_AAC_HE_PS */
- if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AAC_LC) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation, for AAC in MP4\n");
- } else if (strncmp(data_sink, "21", 2) == 0 || strncmp(data_sink, "22", 2) == 0) {
- if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AAC_LC) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation, for AAC in 3GP\n");
- } else if (strncmp(data_sink, "23", 2) == 0 || strncmp(data_sink, "24", 2) == 0) {
- if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AMR_NB) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation for AMR_NB in 3GP\n");
- } else if (strncmp(data_sink, "31", 2) == 0) {
- if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_PCM) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation for PCM in WAV\n");
- } else if (strncmp(data_sink, "41", 2) == 0) {
- if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AMR_NB) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation for amr-nb audio\n");
- } else if (strncmp(data_sink, "42", 2) == 0) {
- if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AMR_WB) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation for amr-wb audio\n");
- } else if (strncmp(data_sink, "51", 2) == 0) {
- if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AAC) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_mime operation for aac-adts audio\n");
- }
+ if (!validate_with_demux) {
+ int avg_bps = 128000;
+
+ g_print("test_mediamuxer_add_track_audio\n");
+ media_format_create(&media_format_a);
+
+ if (strncmp(data_sink, "11", 2) == 0 || strncmp(data_sink, "12", 2) == 0 || strncmp(data_sink, "13", 2) == 0) {
+ /* MEDIA_FORMAT_AAC_LC MEDIA_FORMAT_AAC_HE MEDIA_FORMAT_AAC_HE_PS */
+ if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AAC_LC) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation, for AAC in MP4\n");
+ } else if (strncmp(data_sink, "21", 2) == 0 || strncmp(data_sink, "22", 2) == 0) {
+ if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AAC_LC) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation, for AAC in 3GP\n");
+ } else if (strncmp(data_sink, "23", 2) == 0 || strncmp(data_sink, "24", 2) == 0) {
+ if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AMR_NB) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation for AMR_NB in 3GP\n");
+ } else if (strncmp(data_sink, "31", 2) == 0) {
+ if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_PCM) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation for PCM in WAV\n");
+ } else if (strncmp(data_sink, "41", 2) == 0) {
+ if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AMR_NB) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation for amr-nb audio\n");
+ } else if (strncmp(data_sink, "42", 2) == 0) {
+ if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AMR_WB) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation for amr-wb audio\n");
+ } else if (strncmp(data_sink, "51", 2) == 0) {
+ if (media_format_set_audio_mime(media_format_a, MEDIA_FORMAT_AAC) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_mime operation for aac-adts audio\n");
+ }
- if (validate_with_codec) {
- if (media_format_set_audio_channel(media_format_a, channel) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_channel operation\n");
- media_format_set_audio_samplerate(media_format_a, samplerate);
- media_format_set_audio_bit(media_format_a, bit);
- media_format_set_audio_avg_bps(media_format_a, bitrate);
- } else {
- if (media_format_set_audio_channel(media_format_a, 2) != MEDIA_FORMAT_ERROR_NONE)
- g_print("Problem during media_format_set_audio_channel operation\n");
- media_format_set_audio_samplerate(media_format_a, 44100);
- media_format_set_audio_bit(media_format_a, 16);
- media_format_set_audio_avg_bps(media_format_a, 128000);
- }
+ if (validate_with_codec) {
+ if (media_format_set_audio_channel(media_format_a, channel) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_channel operation\n");
+ media_format_set_audio_samplerate(media_format_a, samplerate);
+ media_format_set_audio_bit(media_format_a, bit);
+ media_format_set_audio_avg_bps(media_format_a, bitrate);
+ } else {
+ if (media_format_set_audio_channel(media_format_a, 2) != MEDIA_FORMAT_ERROR_NONE)
+ g_print("Problem during media_format_set_audio_channel operation\n");
+ media_format_set_audio_samplerate(media_format_a, 44100);
+ media_format_set_audio_bit(media_format_a, 16);
+ media_format_set_audio_avg_bps(media_format_a, 128000);
+ }
- media_format_set_audio_aac_type(media_format_a, true);
- media_format_get_audio_info(media_format_a, &mimetype, &channel, &samplerate, &bit, &avg_bps);
+ media_format_set_audio_aac_type(media_format_a, true);
+ media_format_get_audio_info(media_format_a, &mimetype, &channel, &samplerate, &bit, &avg_bps);
- g_print("Audio Mimetype trying to set: %x (AAC : %x)\n", (int)(mimetype), (int)(MEDIA_FORMAT_AAC_LC));
- g_print("Audio Param trying to set: (ch, samplert, bt, avg_bps) %d %d %d %d \n",
- channel, samplerate, bit, avg_bps);
+ g_print("Audio Mimetype trying to set: %x (AAC : %x)\n", (int)(mimetype), (int)(MEDIA_FORMAT_AAC_LC));
+ g_print("Audio Param trying to set: (ch, samplert, bt, avg_bps) %d %d %d %d \n",
+ channel, samplerate, bit, avg_bps);
- /* To add audio track */
- mediamuxer_add_track(myMuxer, media_format_a, &track_index_aud);
- g_print("Audio Track index returned is: %d\n", track_index_aud);
+ /* To add audio track */
+ mediamuxer_add_track(myMuxer, media_format_a, &track_index_aud);
+ g_print("Audio Track index returned is: %d\n", track_index_aud);
- if (validate_multitrack) {
- mediamuxer_add_track(myMuxer, media_format_a, &track_index_aud2);
- g_print("Audio Multi-Track index returned is: %d\n", track_index_aud2);
+ if (validate_multitrack) {
+ mediamuxer_add_track(myMuxer, media_format_a, &track_index_aud2);
+ g_print("Audio Multi-Track index returned is: %d\n", track_index_aud2);
+ }
+ } else {
+ mediamuxer_add_track(myMuxer, media_format_a, &track_index_aud);
+ g_print("Audio Track index returned is: %d\n", track_index_aud);
+ test_mediademuxer_select_track(demuxer_index_aud);
}
return 0;
}
if (validate_with_codec) {
/* Test muxer with codec */
mediacodec_process_all();
+ } else if (validate_with_demux) {
+ bool sel_vid = false;
+ bool sel_aud = false;
+ test_mediademuxer_start();
+ if (track_index_vid != -1)
+ sel_vid = true;
+ if (track_index_aud != -1)
+ sel_aud = true;
+ g_print("is_video: %d, is_audio: %d\n", sel_vid, sel_aud);
+ test_mediademuxer_process_all(sel_vid, sel_aud);
} else if (strncmp(data_sink, "31", 2) == 0 || strncmp(data_sink, "wav", 3) == 0
|| strncmp(data_sink, "41", 2) == 0
|| strncmp(data_sink, "42", 2) == 0 || strncmp(data_sink, "amr", 3) == 0) {
demux_audio();
} else {
-
demux_mp4();
}
return 0;
int test_mediamuxer_stop()
{
g_print("test_mediamuxer_stop\n");
+ if (validate_with_demux)
+ test_mediademuxer_stop();
mediamuxer_stop(myMuxer);
return 0;
}
return ret;
}
+int test_mediamuxer_with_demuxer_prepare()
+{
+ int tracks_num = 0;
+ int i = 0;
+ if (test_mediademuxer_create())
+ g_print("mediademuxer create fail");
+ if (test_mediademuxer_set_data_source((const char *)media_file))
+ g_print("mediademuxer set_data_source fail");
+ if (test_mediademuxer_prepare())
+ g_print("mediademuxer prepare fail");
+ if (test_mediademuxer_get_track_count(&tracks_num))
+ g_print("mediademuxer get_track_count fail");
+ for (i = 0; i < tracks_num; i++) {
+ media_format_h format;
+ bool video = false;
+ bool audio = false;
+ test_mediademuxer_get_track_info(i, &format, &video, &audio);
+ if (video) {
+ demuxer_index_vid = i;
+ media_format = format;
+ is_video = video;
+ g_print("mediademuxer video track id = %d\n", demuxer_index_vid);
+ } else if (audio) {
+ demuxer_index_aud = i;
+ media_format_a = format;
+ is_audio = audio;
+ g_print("mediademuxer audio track id = %d\n", demuxer_index_aud);
+ }
+ }
+
+ return 0;
+
+}
+
/*-----------------------------------------------------------------------
| TEST FUNCTION |
-----------------------------------------------------------------------*/
have_mp4 = true;
}
}
+
+ if (validate_with_demux)
+ g_menu_state = CURRENT_STATUS_MAINMENU;
+
test_mediamuxer_add_track_audio();
+
} else if (strncmp(cmd, "v", 1) == 0) {
if (!validate_with_codec) {
if (strncmp(data_sink, "11", 2) == 0 || strncmp(data_sink, "12", 2) == 0 || strncmp(data_sink, "13", 2) == 0
}
}
}
+ if (validate_with_demux)
+ g_menu_state = CURRENT_STATUS_MAINMENU;
+
if ((strncmp(data_sink, "11", 2) == 0 || strncmp(data_sink, "12", 2) == 0 || strncmp(data_sink, "13", 2) == 0
|| strncmp(data_sink, "21", 2) == 0 || strncmp(data_sink, "22", 2) == 0) || strncmp(data_sink, "23", 2) == 0 || strncmp(data_sink, "24", 2) == 0)
test_mediamuxer_add_track_video();
else
g_print("Ignoring, data_sink=%s doesnt need video track testing\n", data_sink);
+
} else if (strncmp(cmd, "x", 1) == 0) {
if (!validate_with_codec) {
have_text_track = true;
g_menu_state = CURRENT_STATUS_RAW_AUDIO_FILENAME;
else if (strncmp(cmd, "ae", 2) == 0)
g_menu_state = CURRENT_STATUS_SET_AENC_INFO;
+ } else if (len == 2 && validate_with_demux) {
+ if (strncmp(cmd, "mp", 2) == 0)
+ g_menu_state = CURRENT_STATUS_FILENAME;
+ else if (strncmp(cmd, "pr", 2) == 0)
+ test_mediamuxer_with_demuxer_prepare();
} else {
g_print("unknown menu command. Please try again\n");
}
g_print("*** input raw audio file name");
} else if (g_menu_state == CURRENT_STATUS_SET_AENC_INFO) {
g_print("*** input audio encode configure.(samplerate, channel, bit, bitrate (e.g. 44100, 1, 32, 128000))\n");
+ } else if (g_menu_state == CURRENT_STATUS_FILENAME) {
+ g_print("*** input file path:\n");
} else {
g_print("*** unknown status.\n");
exit(0);
break;
}
}
- break;
-
case CURRENT_STATUS_RAW_AUDIO_FILENAME:
{ /* "ca" */
use_video = 0;
}
}
break;
+ case CURRENT_STATUS_FILENAME: { /* mp */
+ input_filepath(cmd);
+ strncpy(media_file, cmd, MAX_INPUT_SIZE - 1);
+ g_menu_state = CURRENT_STATUS_MAINMENU;
+ break;
+ }
default:
break;
}
g_print("ca. Create Media Codec for Audio\t");
g_print("ae. Set aenc info \n");
}
+ if (validate_with_demux) {
+ g_print("--To test Muxer along with Media Demuxer. --\n");
+ g_print("mp. set media path with demuxer \n");
+ g_print("pr. Prepare mediademuxer \n");
+ }
g_print("c. Create \t");
g_print("o. Set Data Sink \n");
g_print("a. AddAudioTrack \t");
/* Check whether validation with media codec is required */
if (argv[1][0] == '-' && argv[1][1] == 'c')
validate_with_codec = true;
- if (argv[1][0] == '-' && argv[1][1] == 'm')
+ else if (argv[1][0] == '-' && argv[1][1] == 'm')
validate_multitrack = true;
+ else if (argv[1][0] == '-' && argv[1][1] == 'd')
+ validate_with_demux = true;
}
displaymenu();
projects / platform / core / api / mediamuxer.git / commitdiff