| /* $Id$ */ |
| /* |
| * Copyright (C) 2011-2011 Teluu Inc. (http://www.teluu.com) |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| #include <pjsua-lib/pjsua.h> |
| #include <pjsua-lib/pjsua_internal.h> |
| |
| #if defined(PJSUA_MEDIA_HAS_PJMEDIA) && PJSUA_MEDIA_HAS_PJMEDIA != 0 |
| # error The PJSUA_MEDIA_HAS_PJMEDIA should be declared as zero |
| #endif |
| |
| #if PJSUA_HAS_VIDEO |
| |
| #define THIS_FILE "alt_pjsua_vid.c" |
| #define UNIMPLEMENTED(func) PJ_LOG(2,(THIS_FILE, "*** Call to unimplemented function %s ***", #func)); |
| |
| /***************************************************************************** |
| * Our video codec descriptors |
| */ |
| struct alt_codec_desc |
| { |
| /* Predefined info */ |
| pjmedia_vid_codec_info info; |
| pjmedia_format_id base_fmt_id; |
| pj_uint32_t avg_bps; |
| pj_uint32_t max_bps; |
| pjmedia_codec_fmtp dec_fmtp; |
| } alt_vid_codecs[] = |
| { |
| /* H.263+ */ |
| { |
| {PJMEDIA_FORMAT_H263P, PJMEDIA_RTP_PT_H263P, {"H263-1998",9}, |
| {"H.263 codec", 11}, 90000, PJMEDIA_DIR_ENCODING_DECODING, |
| 0, {PJMEDIA_FORMAT_RGB24}, PJMEDIA_VID_PACKING_PACKETS |
| }, |
| PJMEDIA_FORMAT_H263, 256000, 512000, |
| {2, { {{"CIF",3}, {"1",1}}, |
| {{"QCIF",4}, {"1",1}}, } }, |
| } |
| }; |
| |
| static const struct alt_codec_desc* find_codec_desc_by_info(const pjmedia_vid_codec_info *info) |
| { |
| unsigned i; |
| for (i=0; i<PJ_ARRAY_SIZE(alt_vid_codecs); ++i) { |
| struct alt_codec_desc *desc = &alt_vid_codecs[i]; |
| if ((desc->info.fmt_id == info->fmt_id) && |
| ((desc->info.dir & info->dir) == info->dir) && |
| (desc->info.pt == info->pt) && |
| (desc->info.packings & info->packings)) |
| { |
| return desc; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| static pj_status_t alt_vid_codec_test_alloc( pjmedia_vid_codec_factory *factory, |
| const pjmedia_vid_codec_info *id ) |
| { |
| const struct alt_codec_desc *desc = find_codec_desc_by_info(id); |
| return desc? PJ_SUCCESS : PJMEDIA_CODEC_EUNSUP; |
| } |
| |
| static pj_status_t alt_vid_codec_default_attr( pjmedia_vid_codec_factory *factory, |
| const pjmedia_vid_codec_info *info, |
| pjmedia_vid_codec_param *attr ) |
| { |
| const struct alt_codec_desc *desc = find_codec_desc_by_info(info); |
| unsigned i; |
| |
| if (!desc) |
| return PJMEDIA_CODEC_EUNSUP; |
| |
| pj_bzero(attr, sizeof(pjmedia_vid_codec_param)); |
| |
| /* Scan the requested packings and use the lowest number */ |
| attr->packing = 0; |
| for (i=0; i<15; ++i) { |
| unsigned packing = (1 << i); |
| if ((desc->info.packings & info->packings) & packing) { |
| attr->packing = (pjmedia_vid_packing)packing; |
| break; |
| } |
| } |
| if (attr->packing == 0) { |
| /* No supported packing in info */ |
| return PJMEDIA_CODEC_EUNSUP; |
| } |
| |
| /* Direction */ |
| attr->dir = desc->info.dir; |
| |
| /* Encoded format */ |
| pjmedia_format_init_video(&attr->enc_fmt, desc->info.fmt_id, |
| 720, 480, 30000, 1001); |
| |
| /* Decoded format */ |
| pjmedia_format_init_video(&attr->dec_fmt, desc->info.dec_fmt_id[0], |
| //352, 288, 30000, 1001); |
| 720, 576, 30000, 1001); |
| |
| /* Decoding fmtp */ |
| attr->dec_fmtp = desc->dec_fmtp; |
| |
| /* Bitrate */ |
| attr->enc_fmt.det.vid.avg_bps = desc->avg_bps; |
| attr->enc_fmt.det.vid.max_bps = desc->max_bps; |
| |
| /* MTU */ |
| attr->enc_mtu = PJMEDIA_MAX_MTU; |
| |
| return PJ_SUCCESS; |
| } |
| |
| |
| static pj_status_t alt_vid_codec_enum_codecs( pjmedia_vid_codec_factory *factory, |
| unsigned *count, |
| pjmedia_vid_codec_info codecs[]) |
| { |
| unsigned i, max_cnt; |
| |
| PJ_ASSERT_RETURN(codecs && *count > 0, PJ_EINVAL); |
| |
| max_cnt = PJ_MIN(*count, PJ_ARRAY_SIZE(alt_vid_codecs)); |
| *count = 0; |
| |
| for (i=0; i<max_cnt; ++i) { |
| pj_memcpy(&codecs[*count], &alt_vid_codecs[i].info, |
| sizeof(pjmedia_vid_codec_info)); |
| (*count)++; |
| } |
| |
| return PJ_SUCCESS; |
| } |
| |
| |
| static pj_status_t alt_vid_codec_alloc_codec( pjmedia_vid_codec_factory *factory, |
| const pjmedia_vid_codec_info *info, |
| pjmedia_vid_codec **p_codec) |
| { |
| /* This will never get called since we won't be using this codec */ |
| UNIMPLEMENTED(alt_vid_codec_alloc_codec) |
| return PJ_ENOTSUP; |
| } |
| |
| |
| static pj_status_t alt_vid_codec_dealloc_codec( pjmedia_vid_codec_factory *factory, |
| pjmedia_vid_codec *codec ) |
| { |
| /* This will never get called since we won't be using this codec */ |
| UNIMPLEMENTED(alt_vid_codec_dealloc_codec) |
| return PJ_ENOTSUP; |
| } |
| |
| static pjmedia_vid_codec_factory_op alt_vid_codec_factory_op = |
| { |
| &alt_vid_codec_test_alloc, |
| &alt_vid_codec_default_attr, |
| &alt_vid_codec_enum_codecs, |
| &alt_vid_codec_alloc_codec, |
| &alt_vid_codec_dealloc_codec |
| }; |
| |
| static struct alt_vid_codec_factory { |
| pjmedia_vid_codec_factory base; |
| } alt_vid_codec_factory; |
| |
| /***************************************************************************** |
| * Video API implementation |
| */ |
| |
| /* Initialize the video library */ |
| pj_status_t pjsua_vid_subsys_init(void) |
| { |
| pjmedia_vid_codec_mgr *mgr; |
| pj_status_t status; |
| |
| /* Format manager singleton is needed */ |
| status = pjmedia_video_format_mgr_create(pjsua_var.pool, 64, 0, NULL); |
| if (status != PJ_SUCCESS) { |
| PJ_PERROR(1,(THIS_FILE, status, |
| "Error creating PJMEDIA video format manager")); |
| return status; |
| } |
| |
| /* Create video codec manager singleton */ |
| status = pjmedia_vid_codec_mgr_create(pjsua_var.pool, &mgr); |
| if (status != PJ_SUCCESS) { |
| PJ_PERROR(1,(THIS_FILE, status, |
| "Error creating PJMEDIA video codec manager")); |
| return status; |
| } |
| |
| /* Register our codecs */ |
| alt_vid_codec_factory.base.op = &alt_vid_codec_factory_op; |
| alt_vid_codec_factory.base.factory_data = NULL; |
| |
| status = pjmedia_vid_codec_mgr_register_factory(mgr, &alt_vid_codec_factory.base); |
| if (status != PJ_SUCCESS) |
| return status; |
| |
| /* |
| * TODO: put your 3rd party library initialization routine here |
| */ |
| |
| return PJ_SUCCESS; |
| } |
| |
| /* Start the video library */ |
| pj_status_t pjsua_vid_subsys_start(void) |
| { |
| /* |
| * TODO: put your 3rd party library startup routine here |
| */ |
| return PJ_SUCCESS; |
| } |
| |
| /* Cleanup and deinitialize the video library */ |
| pj_status_t pjsua_vid_subsys_destroy(void) |
| { |
| if (pjmedia_vid_codec_mgr_instance()) |
| pjmedia_vid_codec_mgr_destroy(NULL); |
| |
| if (pjmedia_video_format_mgr_instance()) |
| pjmedia_video_format_mgr_destroy(NULL); |
| |
| /* |
| * TODO: put your 3rd party library cleanup routine here |
| */ |
| return PJ_SUCCESS; |
| } |
| |
| /* Initialize video call media */ |
| pj_status_t pjsua_vid_channel_init(pjsua_call_media *call_med) |
| { |
| /* |
| * TODO: put call media initialization |
| */ |
| return PJ_SUCCESS; |
| } |
| |
| /* Internal function to stop video stream */ |
| void pjsua_vid_stop_stream(pjsua_call_media *call_med) |
| { |
| PJ_LOG(4,(THIS_FILE, "Stopping video stream..")); |
| |
| if (call_med->tp) { |
| pjmedia_transport_detach(call_med->tp, call_med); |
| } |
| |
| /* |
| * TODO: |
| * - stop your video stream here |
| */ |
| |
| } |
| |
| /* Our callback to receive incoming RTP packets */ |
| static void vid_rtp_cb(void *user_data, void *pkt, pj_ssize_t size) |
| { |
| pjsua_call_media *call_med = (pjsua_call_media*) user_data; |
| |
| /* TODO: Do something with the packet */ |
| PJ_LOG(4,(THIS_FILE, "RX %d bytes video RTP packet", (int)size)); |
| } |
| |
| /* Our callback to receive RTCP packets */ |
| static void vid_rtcp_cb(void *user_data, void *pkt, pj_ssize_t size) |
| { |
| pjsua_call_media *call_med = (pjsua_call_media*) user_data; |
| |
| /* TODO: Do something with the packet here */ |
| PJ_LOG(4,(THIS_FILE, "RX %d bytes video RTCP packet", (int)size)); |
| } |
| |
| /* A demo function to send dummy "RTP" packets periodically. You would not |
| * need to have this function in the real app! |
| */ |
| static void timer_to_send_vid_rtp(void *user_data) |
| { |
| pjsua_call_media *call_med = (pjsua_call_media*) user_data; |
| const char *pkt = "Not RTP packet"; |
| |
| if (!call_med->call || !call_med->call->inv || !call_med->tp) { |
| /* Call has been disconnected. There is race condition here as |
| * this cb may be called sometime after call has been disconnected */ |
| return; |
| } |
| |
| pjmedia_transport_send_rtp(call_med->tp, pkt, strlen(pkt)); |
| |
| pjsua_schedule_timer2(&timer_to_send_vid_rtp, call_med, 2000); |
| } |
| |
| static void timer_to_send_vid_rtcp(void *user_data) |
| { |
| pjsua_call_media *call_med = (pjsua_call_media*) user_data; |
| const char *pkt = "Not RTCP packet"; |
| |
| if (!call_med->call || !call_med->call->inv || !call_med->tp) { |
| /* Call has been disconnected. There is race condition here as |
| * this cb may be called sometime after call has been disconnected */ |
| return; |
| } |
| |
| pjmedia_transport_send_rtcp(call_med->tp, pkt, strlen(pkt)); |
| |
| pjsua_schedule_timer2(&timer_to_send_vid_rtcp, call_med, 5000); |
| } |
| |
| /* update video channel after SDP negotiation */ |
| pj_status_t pjsua_vid_channel_update(pjsua_call_media *call_med, |
| pj_pool_t *tmp_pool, |
| pjmedia_vid_stream_info *si, |
| const pjmedia_sdp_session *local_sdp, |
| const pjmedia_sdp_session *remote_sdp) |
| { |
| pj_status_t status; |
| |
| PJ_LOG(4,(THIS_FILE, "Video channel update..")); |
| pj_log_push_indent(); |
| |
| /* Check if no media is active */ |
| if (si->dir != PJMEDIA_DIR_NONE) { |
| /* Attach our RTP and RTCP callbacks to the media transport */ |
| status = pjmedia_transport_attach(call_med->tp, call_med, |
| &si->rem_addr, &si->rem_rtcp, |
| pj_sockaddr_get_len(&si->rem_addr), |
| &vid_rtp_cb, &vid_rtcp_cb); |
| /* |
| * TODO: |
| * - Create and start your video stream based on the parameters |
| * in si |
| */ |
| |
| /* For a demonstration, let's use a timer to send "RTP" packet |
| * periodically. |
| */ |
| pjsua_schedule_timer2(&timer_to_send_vid_rtp, call_med, 1000); |
| pjsua_schedule_timer2(&timer_to_send_vid_rtcp, call_med, 3500); |
| } |
| |
| pj_log_pop_indent(); |
| return PJ_SUCCESS; |
| } |
| |
| |
| /***************************************************************************** |
| * Preview |
| */ |
| |
| PJ_DEF(void) |
| pjsua_call_vid_strm_op_param_default(pjsua_call_vid_strm_op_param *param) |
| { |
| pj_bzero(param, sizeof(*param)); |
| param->med_idx = -1; |
| param->dir = PJMEDIA_DIR_ENCODING_DECODING; |
| param->cap_dev = PJMEDIA_VID_DEFAULT_CAPTURE_DEV; |
| } |
| |
| PJ_DEF(void) pjsua_vid_preview_param_default(pjsua_vid_preview_param *p) |
| { |
| p->rend_id = PJMEDIA_VID_DEFAULT_RENDER_DEV; |
| p->show = PJ_TRUE; |
| } |
| |
| PJ_DEF(pjsua_vid_win_id) pjsua_vid_preview_get_win(pjmedia_vid_dev_index id) |
| { |
| UNIMPLEMENTED(pjsua_vid_preview_get_win) |
| return PJSUA_INVALID_ID; |
| } |
| |
| /* Reset internal window structure. Not sure if this is needed?. */ |
| PJ_DEF(void) pjsua_vid_win_reset(pjsua_vid_win_id wid) |
| { |
| pjsua_vid_win *w = &pjsua_var.win[wid]; |
| pj_pool_t *pool = w->pool; |
| |
| pj_bzero(w, sizeof(*w)); |
| if (pool) pj_pool_reset(pool); |
| w->ref_cnt = 0; |
| w->pool = pool; |
| w->preview_cap_id = PJMEDIA_VID_INVALID_DEV; |
| } |
| |
| /* Does it have built-in preview support. */ |
| PJ_DEF(pj_bool_t) pjsua_vid_preview_has_native(pjmedia_vid_dev_index id) |
| { |
| UNIMPLEMENTED(pjsua_vid_preview_has_native) |
| return PJ_FALSE; |
| } |
| |
| /* Start video preview window for the specified capture device. */ |
| PJ_DEF(pj_status_t) pjsua_vid_preview_start(pjmedia_vid_dev_index id, |
| const pjsua_vid_preview_param *prm) |
| { |
| UNIMPLEMENTED(pjsua_vid_preview_start) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Stop video preview. */ |
| PJ_DEF(pj_status_t) pjsua_vid_preview_stop(pjmedia_vid_dev_index id) |
| { |
| UNIMPLEMENTED(pjsua_vid_preview_stop) |
| return PJ_ENOTSUP; |
| } |
| |
| |
| /***************************************************************************** |
| * Devices. |
| */ |
| |
| /* Get the number of video devices installed in the system. */ |
| PJ_DEF(unsigned) pjsua_vid_dev_count(void) |
| { |
| UNIMPLEMENTED(pjsua_vid_dev_count) |
| return 0; |
| } |
| |
| /* Retrieve the video device info for the specified device index. */ |
| PJ_DEF(pj_status_t) pjsua_vid_dev_get_info(pjmedia_vid_dev_index id, |
| pjmedia_vid_dev_info *vdi) |
| { |
| UNIMPLEMENTED(pjsua_vid_dev_get_info) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Enum all video devices installed in the system. */ |
| PJ_DEF(pj_status_t) pjsua_vid_enum_devs(pjmedia_vid_dev_info info[], |
| unsigned *count) |
| { |
| UNIMPLEMENTED(pjsua_vid_enum_devs) |
| return PJ_ENOTSUP; |
| } |
| |
| |
| /***************************************************************************** |
| * Codecs. |
| */ |
| |
| /* Enum all supported video codecs in the system. */ |
| PJ_DEF(pj_status_t) pjsua_vid_enum_codecs( pjsua_codec_info id[], |
| unsigned *p_count ) |
| { |
| pjmedia_vid_codec_info info[32]; |
| unsigned i, j, count, prio[32]; |
| pj_status_t status; |
| |
| count = PJ_ARRAY_SIZE(info); |
| status = pjmedia_vid_codec_mgr_enum_codecs(NULL, &count, info, prio); |
| if (status != PJ_SUCCESS) { |
| *p_count = 0; |
| return status; |
| } |
| for (i=0, j=0; i<count && j<*p_count; ++i) { |
| if (info[i].packings & PJMEDIA_VID_PACKING_PACKETS) { |
| pj_bzero(&id[j], sizeof(pjsua_codec_info)); |
| |
| pjmedia_vid_codec_info_to_id(&info[i], id[j].buf_, sizeof(id[j].buf_)); |
| id[j].codec_id = pj_str(id[j].buf_); |
| id[j].priority = (pj_uint8_t) prio[i]; |
| |
| if (id[j].codec_id.slen < sizeof(id[j].buf_)) { |
| id[j].desc.ptr = id[j].codec_id.ptr + id[j].codec_id.slen + 1; |
| pj_strncpy(&id[j].desc, &info[i].encoding_desc, |
| sizeof(id[j].buf_) - id[j].codec_id.slen - 1); |
| } |
| |
| ++j; |
| } |
| } |
| |
| *p_count = j; |
| return PJ_SUCCESS; |
| } |
| |
| /* Change video codec priority. */ |
| PJ_DEF(pj_status_t) pjsua_vid_codec_set_priority( const pj_str_t *codec_id, |
| pj_uint8_t priority ) |
| { |
| UNIMPLEMENTED(pjsua_vid_codec_set_priority) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Get video codec parameters. */ |
| PJ_DEF(pj_status_t) pjsua_vid_codec_get_param( |
| const pj_str_t *codec_id, |
| pjmedia_vid_codec_param *param) |
| { |
| UNIMPLEMENTED(pjsua_vid_codec_get_param) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Set video codec parameters. */ |
| PJ_DEF(pj_status_t) pjsua_vid_codec_set_param( |
| const pj_str_t *codec_id, |
| const pjmedia_vid_codec_param *param) |
| { |
| UNIMPLEMENTED(pjsua_vid_codec_set_param) |
| return PJ_ENOTSUP; |
| } |
| |
| |
| /***************************************************************************** |
| * Window |
| */ |
| |
| /* Enumerates all video windows. */ |
| PJ_DEF(pj_status_t) pjsua_vid_enum_wins( pjsua_vid_win_id wids[], |
| unsigned *count) |
| { |
| UNIMPLEMENTED(pjsua_vid_enum_wins) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Get window info. */ |
| PJ_DEF(pj_status_t) pjsua_vid_win_get_info( pjsua_vid_win_id wid, |
| pjsua_vid_win_info *wi) |
| { |
| UNIMPLEMENTED(pjsua_vid_win_get_info) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Show or hide window. */ |
| PJ_DEF(pj_status_t) pjsua_vid_win_set_show( pjsua_vid_win_id wid, |
| pj_bool_t show) |
| { |
| UNIMPLEMENTED(pjsua_vid_win_set_show) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Set video window position. */ |
| PJ_DEF(pj_status_t) pjsua_vid_win_set_pos( pjsua_vid_win_id wid, |
| const pjmedia_coord *pos) |
| { |
| UNIMPLEMENTED(pjsua_vid_win_set_pos) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Resize window. */ |
| PJ_DEF(pj_status_t) pjsua_vid_win_set_size( pjsua_vid_win_id wid, |
| const pjmedia_rect_size *size) |
| { |
| UNIMPLEMENTED(pjsua_vid_win_set_size) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Set video orientation. */ |
| PJ_DEF(pj_status_t) pjsua_vid_win_rotate( pjsua_vid_win_id wid, |
| int angle) |
| { |
| UNIMPLEMENTED(pjsua_vid_win_rotate) |
| return PJ_ENOTSUP; |
| } |
| |
| /* Start, stop, and/or manipulate video transmission for the specified call. */ |
| PJ_DEF(pj_status_t) pjsua_call_set_vid_strm ( |
| pjsua_call_id call_id, |
| pjsua_call_vid_strm_op op, |
| const pjsua_call_vid_strm_op_param *param) |
| { |
| UNIMPLEMENTED(pjsua_call_set_vid_strm) |
| return PJ_ENOTSUP; |
| } |
| |
| |
| /* Get the media stream index of the default video stream in the call. */ |
| PJ_DEF(int) pjsua_call_get_vid_stream_idx(pjsua_call_id call_id) |
| { |
| UNIMPLEMENTED(pjsua_call_get_vid_stream_idx) |
| return -1; |
| } |
| |
| /* Determine if video stream for the specified call is currently running |
| * for the specified direction. |
| */ |
| PJ_DEF(pj_bool_t) pjsua_call_vid_stream_is_running( pjsua_call_id call_id, |
| int med_idx, |
| pjmedia_dir dir) |
| { |
| UNIMPLEMENTED(pjsua_call_vid_stream_is_running) |
| return PJ_FALSE; |
| } |
| |
| #endif /* PJSUA_HAS_VIDEO */ |
| |