| /* $Id$ */ |
| /* |
| * Copyright (C) 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 <pjmedia/vid_tee.h> |
| #include <pjmedia/converter.h> |
| #include <pjmedia/errno.h> |
| #include <pj/array.h> |
| #include <pj/log.h> |
| #include <pj/pool.h> |
| |
| |
| #if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0) |
| |
| |
| #define TEE_PORT_NAME "vid_tee" |
| #define TEE_PORT_SIGN PJMEDIA_SIG_PORT_VID_TEE |
| |
| #define THIS_FILE "vid_tee.c" |
| |
| typedef struct vid_tee_dst_port |
| { |
| pjmedia_port *dst; |
| unsigned option; |
| } vid_tee_dst_port; |
| |
| |
| typedef struct vid_tee_port |
| { |
| pjmedia_port base; |
| pj_pool_t *pool; |
| pj_pool_factory *pf; |
| pj_pool_t *buf_pool; |
| void *buf[2]; |
| unsigned buf_cnt; |
| pj_size_t buf_size; |
| unsigned dst_port_maxcnt; |
| unsigned dst_port_cnt; |
| vid_tee_dst_port *dst_ports; |
| pj_uint8_t *put_frm_flag; |
| |
| struct vid_tee_conv_t { |
| pjmedia_converter *conv; |
| pj_size_t conv_buf_size; |
| } *tee_conv; |
| } vid_tee_port; |
| |
| |
| static pj_status_t tee_put_frame(pjmedia_port *port, pjmedia_frame *frame); |
| static pj_status_t tee_get_frame(pjmedia_port *port, pjmedia_frame *frame); |
| static pj_status_t tee_destroy(pjmedia_port *port); |
| |
| /* |
| * Create a video tee port with the specified source media port. |
| */ |
| PJ_DEF(pj_status_t) pjmedia_vid_tee_create( pj_pool_t *pool, |
| const pjmedia_format *fmt, |
| unsigned max_dst_cnt, |
| pjmedia_port **p_vid_tee) |
| { |
| vid_tee_port *tee; |
| pj_str_t name_st; |
| const pjmedia_video_format_info *vfi; |
| pjmedia_video_apply_fmt_param vafp; |
| pj_status_t status; |
| |
| PJ_ASSERT_RETURN(pool && fmt && p_vid_tee, PJ_EINVAL); |
| PJ_ASSERT_RETURN(fmt->type == PJMEDIA_TYPE_VIDEO, PJ_EINVAL); |
| |
| /* Allocate video tee structure */ |
| tee = PJ_POOL_ZALLOC_T(pool, vid_tee_port); |
| tee->pf = pool->factory; |
| tee->pool = pj_pool_create(tee->pf, "video tee", 500, 500, NULL); |
| |
| /* Initialize video tee structure */ |
| tee->dst_port_maxcnt = max_dst_cnt; |
| tee->dst_ports = (vid_tee_dst_port*) |
| pj_pool_calloc(pool, max_dst_cnt, |
| sizeof(vid_tee_dst_port)); |
| tee->tee_conv = (struct vid_tee_conv_t *) |
| pj_pool_calloc(pool, max_dst_cnt, |
| sizeof(struct vid_tee_conv_t)); |
| tee->put_frm_flag = (pj_uint8_t*) |
| pj_pool_calloc(pool, max_dst_cnt, |
| sizeof(tee->put_frm_flag[0])); |
| |
| /* Initialize video tee buffer, its size is one frame */ |
| vfi = pjmedia_get_video_format_info(NULL, fmt->id); |
| if (vfi == NULL) |
| return PJMEDIA_EBADFMT; |
| |
| pj_bzero(&vafp, sizeof(vafp)); |
| vafp.size = fmt->det.vid.size; |
| status = vfi->apply_fmt(vfi, &vafp); |
| if (status != PJ_SUCCESS) |
| return status; |
| |
| tee->buf_size = vafp.framebytes; |
| |
| /* Initialize video tee port */ |
| status = pjmedia_port_info_init2(&tee->base.info, |
| pj_strset2(&name_st, (char*)TEE_PORT_NAME), |
| TEE_PORT_SIGN, |
| PJMEDIA_DIR_ENCODING, |
| fmt); |
| if (status != PJ_SUCCESS) |
| return status; |
| |
| tee->base.get_frame = &tee_get_frame; |
| tee->base.put_frame = &tee_put_frame; |
| tee->base.on_destroy = &tee_destroy; |
| |
| /* Done */ |
| *p_vid_tee = &tee->base; |
| |
| return PJ_SUCCESS; |
| } |
| |
| static void realloc_buf(vid_tee_port *vid_tee, |
| unsigned buf_cnt, pj_size_t buf_size) |
| { |
| unsigned i; |
| |
| if (buf_cnt > vid_tee->buf_cnt) |
| vid_tee->buf_cnt = buf_cnt; |
| |
| if (buf_size > vid_tee->buf_size) { |
| /* We need a larger buffer here. */ |
| vid_tee->buf_size = buf_size; |
| if (vid_tee->buf_pool) { |
| pj_pool_release(vid_tee->buf_pool); |
| vid_tee->buf_pool = NULL; |
| } |
| vid_tee->buf[0] = vid_tee->buf[1] = NULL; |
| } |
| |
| if (!vid_tee->buf_pool) { |
| vid_tee->buf_pool = pj_pool_create(vid_tee->pf, "video tee buffer", |
| 1000, 1000, NULL); |
| } |
| |
| for (i = 0; i < vid_tee->buf_cnt; i++) { |
| if (!vid_tee->buf[i]) |
| vid_tee->buf[i] = pj_pool_alloc(vid_tee->buf_pool, |
| vid_tee->buf_size); |
| } |
| } |
| |
| /* |
| * Add a destination media port to the video tee. |
| */ |
| PJ_DEF(pj_status_t) pjmedia_vid_tee_add_dst_port(pjmedia_port *vid_tee, |
| unsigned option, |
| pjmedia_port *port) |
| { |
| vid_tee_port *tee = (vid_tee_port*)vid_tee; |
| pjmedia_video_format_detail *vfd; |
| |
| PJ_ASSERT_RETURN(vid_tee && vid_tee->info.signature==TEE_PORT_SIGN, |
| PJ_EINVAL); |
| |
| if (tee->dst_port_cnt >= tee->dst_port_maxcnt) |
| return PJ_ETOOMANY; |
| |
| if (vid_tee->info.fmt.id != port->info.fmt.id) |
| return PJMEDIA_EBADFMT; |
| |
| vfd = pjmedia_format_get_video_format_detail(&port->info.fmt, PJ_TRUE); |
| if (vfd->size.w != vid_tee->info.fmt.det.vid.size.w || |
| vfd->size.h != vid_tee->info.fmt.det.vid.size.h) |
| { |
| return PJMEDIA_EBADFMT; |
| } |
| |
| realloc_buf(tee, (option & PJMEDIA_VID_TEE_DST_DO_IN_PLACE_PROC)? |
| 1: 0, tee->buf_size); |
| |
| pj_bzero(&tee->tee_conv[tee->dst_port_cnt], sizeof(tee->tee_conv[0])); |
| tee->dst_ports[tee->dst_port_cnt].dst = port; |
| tee->dst_ports[tee->dst_port_cnt].option = option; |
| ++tee->dst_port_cnt; |
| |
| return PJ_SUCCESS; |
| } |
| |
| |
| /* |
| * Add a destination media port to the video tee. Create a converter if |
| * necessary. |
| */ |
| PJ_DEF(pj_status_t) pjmedia_vid_tee_add_dst_port2(pjmedia_port *vid_tee, |
| unsigned option, |
| pjmedia_port *port) |
| { |
| vid_tee_port *tee = (vid_tee_port*)vid_tee; |
| pjmedia_video_format_detail *vfd; |
| |
| PJ_ASSERT_RETURN(vid_tee && vid_tee->info.signature==TEE_PORT_SIGN, |
| PJ_EINVAL); |
| |
| if (tee->dst_port_cnt >= tee->dst_port_maxcnt) |
| return PJ_ETOOMANY; |
| |
| pj_bzero(&tee->tee_conv[tee->dst_port_cnt], sizeof(tee->tee_conv[0])); |
| |
| /* Check if we need to create a converter. */ |
| vfd = pjmedia_format_get_video_format_detail(&port->info.fmt, PJ_TRUE); |
| if (vid_tee->info.fmt.id != port->info.fmt.id || |
| vfd->size.w != vid_tee->info.fmt.det.vid.size.w || |
| vfd->size.h != vid_tee->info.fmt.det.vid.size.h) |
| { |
| const pjmedia_video_format_info *vfi; |
| pjmedia_video_apply_fmt_param vafp; |
| pjmedia_conversion_param conv_param; |
| pj_status_t status; |
| |
| vfi = pjmedia_get_video_format_info(NULL, port->info.fmt.id); |
| if (vfi == NULL) |
| return PJMEDIA_EBADFMT; |
| |
| pj_bzero(&vafp, sizeof(vafp)); |
| vafp.size = port->info.fmt.det.vid.size; |
| status = vfi->apply_fmt(vfi, &vafp); |
| if (status != PJ_SUCCESS) |
| return status; |
| |
| realloc_buf(tee, (option & PJMEDIA_VID_TEE_DST_DO_IN_PLACE_PROC)? |
| 2: 1, vafp.framebytes); |
| |
| pjmedia_format_copy(&conv_param.src, &vid_tee->info.fmt); |
| pjmedia_format_copy(&conv_param.dst, &port->info.fmt); |
| |
| status = pjmedia_converter_create( |
| NULL, tee->pool, &conv_param, |
| &tee->tee_conv[tee->dst_port_cnt].conv); |
| if (status != PJ_SUCCESS) |
| return status; |
| |
| tee->tee_conv[tee->dst_port_cnt].conv_buf_size = vafp.framebytes; |
| } else { |
| realloc_buf(tee, (option & PJMEDIA_VID_TEE_DST_DO_IN_PLACE_PROC)? |
| 1: 0, tee->buf_size); |
| } |
| |
| tee->dst_ports[tee->dst_port_cnt].dst = port; |
| tee->dst_ports[tee->dst_port_cnt].option = option; |
| ++tee->dst_port_cnt; |
| |
| return PJ_SUCCESS; |
| } |
| |
| |
| /* |
| * Remove a destination media port from the video tee. |
| */ |
| PJ_DEF(pj_status_t) pjmedia_vid_tee_remove_dst_port(pjmedia_port *vid_tee, |
| pjmedia_port *port) |
| { |
| vid_tee_port *tee = (vid_tee_port*)vid_tee; |
| unsigned i; |
| |
| PJ_ASSERT_RETURN(vid_tee && vid_tee->info.signature==TEE_PORT_SIGN, |
| PJ_EINVAL); |
| |
| for (i = 0; i < tee->dst_port_cnt; ++i) { |
| if (tee->dst_ports[i].dst == port) { |
| if (tee->tee_conv[i].conv) |
| pjmedia_converter_destroy(tee->tee_conv[i].conv); |
| |
| pj_array_erase(tee->dst_ports, sizeof(tee->dst_ports[0]), |
| tee->dst_port_cnt, i); |
| pj_array_erase(tee->tee_conv, sizeof(tee->tee_conv[0]), |
| tee->dst_port_cnt, i); |
| --tee->dst_port_cnt; |
| return PJ_SUCCESS; |
| } |
| } |
| |
| return PJ_ENOTFOUND; |
| } |
| |
| |
| static pj_status_t tee_put_frame(pjmedia_port *port, pjmedia_frame *frame) |
| { |
| vid_tee_port *tee = (vid_tee_port*)port; |
| unsigned i, j; |
| const pj_uint8_t PUT_FRM_DONE = 1; |
| |
| pj_bzero(tee->put_frm_flag, tee->dst_port_cnt * |
| sizeof(tee->put_frm_flag[0])); |
| |
| for (i = 0; i < tee->dst_port_cnt; ++i) { |
| pjmedia_frame frame_ = *frame; |
| |
| if (tee->put_frm_flag[i]) |
| continue; |
| |
| if (tee->tee_conv[i].conv) { |
| pj_status_t status; |
| |
| frame_.buf = tee->buf[0]; |
| frame_.size = tee->tee_conv[i].conv_buf_size; |
| status = pjmedia_converter_convert(tee->tee_conv[i].conv, |
| frame, &frame_); |
| if (status != PJ_SUCCESS) { |
| PJ_LOG(3, (THIS_FILE, |
| "Failed to convert frame for destination" |
| " port %d (%.*s)", i, |
| tee->dst_ports[i].dst->info.name.slen, |
| tee->dst_ports[i].dst->info.name.ptr)); |
| continue; |
| } |
| } |
| |
| /* Find other destination ports which has the same format so |
| * we don't need to do the same conversion twice. |
| */ |
| for (j = i; j < tee->dst_port_cnt; ++j) { |
| pjmedia_frame framep; |
| |
| if (tee->put_frm_flag[j] || |
| (tee->dst_ports[j].dst->info.fmt.id != |
| tee->dst_ports[i].dst->info.fmt.id) || |
| (tee->dst_ports[j].dst->info.fmt.det.vid.size.w != |
| tee->dst_ports[i].dst->info.fmt.det.vid.size.w) || |
| (tee->dst_ports[j].dst->info.fmt.det.vid.size.h != |
| tee->dst_ports[i].dst->info.fmt.det.vid.size.h)) |
| { |
| continue; |
| } |
| |
| framep = frame_; |
| /* For dst_ports that do in-place processing, we need to duplicate |
| * the data source first. |
| */ |
| if (tee->dst_ports[j].option & PJMEDIA_VID_TEE_DST_DO_IN_PLACE_PROC) |
| { |
| PJ_ASSERT_RETURN(tee->buf_size <= frame_.size, PJ_ETOOBIG); |
| framep.buf = tee->buf[tee->buf_cnt-1]; |
| framep.size = frame_.size; |
| pj_memcpy(framep.buf, frame_.buf, frame_.size); |
| } |
| |
| /* Deliver the data */ |
| pjmedia_port_put_frame(tee->dst_ports[j].dst, &framep); |
| tee->put_frm_flag[j] = PUT_FRM_DONE; |
| |
| if (!tee->tee_conv[i].conv) |
| break; |
| } |
| } |
| |
| return PJ_SUCCESS; |
| } |
| |
| static pj_status_t tee_get_frame(pjmedia_port *port, pjmedia_frame *frame) |
| { |
| PJ_UNUSED_ARG(port); |
| PJ_UNUSED_ARG(frame); |
| |
| pj_assert(!"Bug! Tee port get_frame() shouldn't be called."); |
| |
| return PJ_EBUG; |
| } |
| |
| static pj_status_t tee_destroy(pjmedia_port *port) |
| { |
| vid_tee_port *tee = (vid_tee_port*)port; |
| |
| PJ_ASSERT_RETURN(port && port->info.signature==TEE_PORT_SIGN, PJ_EINVAL); |
| |
| pj_pool_release(tee->pool); |
| if (tee->buf_pool) |
| pj_pool_release(tee->buf_pool); |
| |
| pj_bzero(tee, sizeof(*tee)); |
| |
| return PJ_SUCCESS; |
| } |
| |
| |
| #endif /* PJMEDIA_HAS_VIDEO */ |