#include "assert.h"
#include <media/mediamuxer.h>
#include <storage.h>
-#include <dlog.h>
#include <glib.h>
#include "tct_common.h"
-//#include <media_packet.h>
-//#include <media_format.h>
-// #include <media_packet_internal.h>
-
//& set: Mediamuxer
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-
-#define LOG_TAG "UTC_MUX"
#define API_NAMESPACE "[MEDIAMUXER]"
-
//& set: Mediamuxer
static mediamuxer_h g_media_muxer = NULL;
char *uri=NULL;
-static char* file_path = NULL;
-static char* file = "sample.mp4";
+static char *file_path = NULL;
+static char *file = "sample.mp4";
-static char* h264_path = NULL;
-static char* h264_file = "output3.h264";
+static char *h264_path = NULL;
+static char *h264_file = "output3.h264";
-static char* h264_data_path = NULL;
-static char* h264_data_file = "h264info3.txt";
+static char *h264_data_path = NULL;
+static char *h264_data_file = "h264info3.txt";
static bool _is_broken = false;
media_format_h media_format = NULL;
void utc_mediamuxer_startup(void)
{
int ret = 0;
- LOGI("%s ENTER ________________________________\n",__func__);
mediamuxer_output_format_e format = MEDIAMUXER_CONTAINER_FORMAT_MP4;
char pszValue[CONFIG_VALUE_LEN_MAX] = {0,};
PRINT_UTC_LOG("[Line : %d][%s] 'DEVICE_SUITE_TARGET_30' Values Received = %s\\n", __LINE__, API_NAMESPACE, pszValue);
if(h264_path == NULL) {
- h264_path = (char*)malloc(strlen(pszValue) + strlen(h264_file) + 6);
+ h264_path = (char *)malloc(strlen(pszValue) + strlen(h264_file) + 6);
snprintf(h264_path, strlen(pszValue) + strlen(h264_file) + 6, "%s/res/%s", pszValue, h264_file );
}
if(h264_data_path == NULL) {
- h264_data_path = (char*)malloc(strlen(pszValue) + strlen(h264_data_file) + 6);
+ h264_data_path = (char *)malloc(strlen(pszValue) + strlen(h264_data_file) + 6);
snprintf(h264_data_path, strlen(pszValue) + strlen(h264_data_file) + 6, "%s/res/%s", pszValue, h264_data_file );
}
if(file_path == NULL){
- file_path = (char*)malloc(strlen(pszValue)+ strlen(file) + 6);
+ file_path = (char *)malloc(strlen(pszValue)+ strlen(file) + 6);
snprintf(file_path, strlen(pszValue)+ strlen(file) + 6, "%s/res/%s", pszValue, file );
}
- }
- else
- {
+ } else {
PRINT_UTC_LOG("[Line : %d][%s] GetValueForTCTSetting returned error for 'DEVICE_SUITE_TARGET_30'\\n", __LINE__, API_NAMESPACE);
}
- if(g_media_muxer == NULL) {
- ret = mediamuxer_create(&g_media_muxer);
- if (ret != MEDIAMUXER_ERROR_NONE)
- {
- _is_broken = true;
- LOGI("mediamuxer create is failed\n");
- return;
- }
- }
-
- if(uri == NULL)
- uri = file_path;
-
- /* Create video format */
- if(media_format == NULL){
+ if (g_media_muxer == NULL) {
+ ret = mediamuxer_create(&g_media_muxer);
+ if (ret != MEDIAMUXER_ERROR_NONE) {
+ _is_broken = true;
+ return;
+ }
+ }
+
+ if (uri == NULL)
+ uri = file_path;
+
+ /* Create video format */
+ if (media_format == NULL) {
media_format_create(&media_format);
- //LOGI("call media_format_set_video_mime\n");
ret = media_format_set_video_mime(media_format, MEDIA_FORMAT_H264_SP);
- if (ret != MEDIA_FORMAT_ERROR_NONE) {
- LOGI("media_format_set_video_mime failed. API returned %d. Invalid=%d, invalid ope=%d\n",\
- ret,MEDIA_FORMAT_ERROR_INVALID_PARAMETER,MEDIA_FORMAT_ERROR_INVALID_OPERATION);
- }
-
+ if (ret != MEDIA_FORMAT_ERROR_NONE) {
+ PRINT_UTC_LOG("[Line : %d][%s] media_format_set_video_mime failed, API returned %d. Invalid=%d, invalid ope=%d",
+ __LINE__, API_NAMESPACE, ret, MEDIA_FORMAT_ERROR_INVALID_PARAMETER, MEDIA_FORMAT_ERROR_INVALID_OPERATION);
+ }
media_format_set_video_width(media_format, 640);
media_format_set_video_height(media_format, 480);
media_format_set_video_avg_bps(media_format, 10);
media_format_set_video_max_bps(media_format, 10);
- }
+ }
mediamuxer_set_data_sink(g_media_muxer, uri, format);
- LOGI("%s EXIT ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",__func__);
}
/**
*/
void utc_mediamuxer_cleanup(void)
{
- int ret;
- mediamuxer_state_e state;
- LOGI("%s ENTER ++++++++++++++++++++++++++++++\n",__func__);
+ int ret;
+ mediamuxer_state_e state;
- if(mediamuxer_get_state(g_media_muxer, &state) == MEDIAMUXER_ERROR_NONE) {
- if(state == MEDIAMUXER_STATE_MUXING ||
- state == MEDIAMUXER_STATE_PAUSED ||
- state == MEDIAMUXER_STATE_READY){
+ if(mediamuxer_get_state(g_media_muxer, &state) == MEDIAMUXER_ERROR_NONE) {
+ if (state == MEDIAMUXER_STATE_MUXING || state == MEDIAMUXER_STATE_PAUSED ||
+ state == MEDIAMUXER_STATE_READY) {
ret = mediamuxer_stop(g_media_muxer);
+ if (ret != MEDIAMUXER_ERROR_NONE)
+ PRINT_UTC_LOG("[Line : %d][%s] Failed stop mediamuxer\n", __LINE__, API_NAMESPACE);
}
}
- if(mediamuxer_get_state(g_media_muxer, &state) == MEDIAMUXER_ERROR_NONE) {
- if(state == MEDIAMUXER_STATE_READY){
+ if(mediamuxer_get_state(g_media_muxer, &state) == MEDIAMUXER_ERROR_NONE) {
+ if(state == MEDIAMUXER_STATE_READY) {
ret = mediamuxer_unprepare(g_media_muxer);
+ if (ret != MEDIAMUXER_ERROR_NONE)
+ PRINT_UTC_LOG("[Line : %d][%s] Failed unprepare mediamuxer\n", __LINE__, API_NAMESPACE);
}
}
- if(g_media_muxer != NULL) {
- //LOGI("Call create for _destroy\n");
+ if (g_media_muxer != NULL) {
ret = mediamuxer_destroy(g_media_muxer);
+ if (ret != MEDIAMUXER_ERROR_NONE)
+ PRINT_UTC_LOG("[Line : %d][%s] Failed destroy mediamuxer\n", __LINE__, API_NAMESPACE);
g_media_muxer = NULL;
}
- if(h264_path)
- {
+ if (h264_path) {
free(h264_path);
h264_path = NULL;
}
- if(h264_data_path)
- {
+ if (h264_data_path) {
free(h264_data_path);
h264_data_path = NULL;
}
- if(file_path)
- {
+ if (file_path) {
free(file_path);
file_path = NULL;
uri = NULL;
}
- LOGI("%s EXIT -------------------------------\n",__func__);
}
//& purpose: A purpose of a first positive TC.
-
-//& purpose: A purpose of a first negative TC.
-
-
/**
* @testcase utc_mediamuxer_create_p
* @since_tizen 3.0
int utc_mediamuxer_create_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
- if(g_media_muxer != NULL)
- {
+ if(g_media_muxer != NULL) {
ret = mediamuxer_destroy(g_media_muxer);
g_media_muxer = NULL;
}
ret = mediamuxer_create(&g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_neq(g_media_muxer, NULL);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
int utc_mediamuxer_create_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
ret = mediamuxer_create(NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_set_data_sink_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
- mediamuxer_output_format_e format = MEDIAMUXER_CONTAINER_FORMAT_MP4;
+ mediamuxer_output_format_e format = MEDIAMUXER_CONTAINER_FORMAT_MP4;
ret = mediamuxer_set_data_sink(g_media_muxer, uri, format);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_set_data_sink_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
- mediamuxer_output_format_e format = MEDIAMUXER_CONTAINER_FORMAT_MP4;
+ mediamuxer_output_format_e format = MEDIAMUXER_CONTAINER_FORMAT_MP4;
ret = mediamuxer_set_data_sink(NULL, NULL, format);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_add_track_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
int track_index = -1;
ret = mediamuxer_add_track(g_media_muxer, media_format, &track_index);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_add_track_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
- mediamuxer_output_format_e format = MEDIAMUXER_CONTAINER_FORMAT_MP4;
int track_index = -1;
ret = mediamuxer_add_track(NULL, NULL, &track_index);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_prepare_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
int track_index = -1;
ret = mediamuxer_add_track(g_media_muxer, media_format, &track_index);
ret = mediamuxer_prepare(g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_prepare_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = mediamuxer_prepare(NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_start_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
int track_index = -1;
ret = mediamuxer_add_track(g_media_muxer, media_format, &track_index);
ret = mediamuxer_prepare(g_media_muxer);
ret = mediamuxer_start(g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_start_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
ret = mediamuxer_start(NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_write_sample_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
FILE *pvFile = NULL;
unsigned int vcap_size;
unsigned char *dptr;
- LOGI("%s : ENTER\n",__func__);
-
mediamuxer_add_track(g_media_muxer, media_format, &track_index_vid);
mediamuxer_prepare(g_media_muxer);
mediamuxer_start(g_media_muxer);
- LOGI("h264_data_path=%s\n",h264_data_path);
pvFile = fopen(h264_path, "rb");
if (pvFile == NULL) {
g_print("\ndata file cant be loaded...\n");
is_video_flag_readable = fscanf(pvFileInfo, "%u\n", &flg_vid);
is_video_key_readable = fscanf(pvFileInfo, "%d\n", &key_vid);
- LOGI("\nV_Caps = %s\n", vid_caps);
- LOGI("is_video_readable =%d is_video_pts_readable == %d is_video_dts_readable = %d \
- is_video_duration_readable == %d is_video_flag_readable = %d \
- is_video_key_readable == %d\n",
- is_video_readable,is_video_pts_readable,is_video_dts_readable,
- is_video_duration_readable, is_video_flag_readable,
- is_video_key_readable);
-
if (is_video_readable == 1 && is_video_pts_readable == 1 && is_video_dts_readable == 1
&& is_video_duration_readable == 1 && is_video_flag_readable == 1
&& is_video_key_readable == 1) {
g_print("V write sample call. packet add:%x\n", (unsigned int)vid_pkt);
ret = mediamuxer_write_sample(g_media_muxer, track_index_vid, vid_pkt);
+ free(vid_caps);
media_packet_destroy(vid_pkt);
}
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
fclose(pvFile);
fclose(pvFileInfo);
int utc_mediamuxer_write_sample_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
int track_index = -1;
ret = mediamuxer_write_sample(g_media_muxer, track_index, NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_close_track_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
int track_index = 1;
ret = mediamuxer_add_track(g_media_muxer, media_format, &track_index);
ret = mediamuxer_close_track(g_media_muxer, track_index);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_close_track_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
int track_index = -1;
ret = mediamuxer_close_track(NULL, track_index);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_pause_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
utc_mediamuxer_write_sample_p();
ret = mediamuxer_pause(g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_pause_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
ret = mediamuxer_pause(NULL);
- LOGI("%s compare_eq %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_resume_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
utc_mediamuxer_write_sample_p();
ret = mediamuxer_pause(g_media_muxer);
ret = mediamuxer_resume(g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_resume_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
ret = mediamuxer_resume(NULL);
- LOGI("%s compare_eq %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_stop_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
ret = mediamuxer_prepare(g_media_muxer);
ret = mediamuxer_start(g_media_muxer);
ret = mediamuxer_stop(g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_stop_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
ret = mediamuxer_stop(NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_unprepare_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
ret = mediamuxer_prepare(g_media_muxer);
ret = mediamuxer_start(g_media_muxer);
ret = mediamuxer_stop(g_media_muxer);
ret = mediamuxer_unprepare(g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_unprepare_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = mediamuxer_unprepare(NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_destroy_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
ret = mediamuxer_destroy(g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_destroy_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
ret = mediamuxer_destroy(NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_get_state_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
mediamuxer_state_e state;
ret = mediamuxer_get_state(g_media_muxer, &state);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_get_state_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
ret = mediamuxer_get_state(g_media_muxer, NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_OPERATION);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_OPERATION);
return 0;
}
int utc_mediamuxer_set_error_cb_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
- ret = mediamuxer_set_error_cb(g_media_muxer, (mediamuxer_error_cb) app_err_cb, g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
+ ret = mediamuxer_set_error_cb(g_media_muxer, (mediamuxer_error_cb)app_err_cb, g_media_muxer);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_set_error_cb_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
ret = mediamuxer_set_error_cb(NULL, NULL, NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
int utc_mediamuxer_unset_error_cb_p(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_INVALID_PARAMETER;
ret = mediamuxer_unset_error_cb(g_media_muxer);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_NONE);
assert_eq(ret, MEDIAMUXER_ERROR_NONE);
return 0;
}
int utc_mediamuxer_unset_error_cb_n(void)
{
assert(!_is_broken);
- LOGI("%s ENTER\n",__func__);
int ret = MEDIAMUXER_ERROR_NONE;
ret = mediamuxer_unset_error_cb(NULL);
- LOGI("%s compare %d to %d\n",__func__,ret,MEDIAMUXER_ERROR_INVALID_PARAMETER);
assert_eq(ret, MEDIAMUXER_ERROR_INVALID_PARAMETER);
return 0;
}
projects / test / tct / native / api.git / commitdiff