/* reset dev info */
static void reset_dev_info(struct avi_dev_info *adi)
{
/* Close avi streams */
if (adi->avi) {
unsigned i, cnt;
cnt = pjmedia_avi_streams_get_num_streams(adi->avi);
for (i=0; i<cnt; ++i) {
pjmedia_avi_stream *as;
as = pjmedia_avi_streams_get_stream(adi->avi, i);
if (as) {
pjmedia_port *port;
port = pjmedia_avi_stream_get_port(as);
pjmedia_port_destroy(port);
}
}
adi->avi = NULL;
}
if (adi->codec) {
pjmedia_vid_codec_close(adi->codec);
adi->codec = NULL;
}
if (adi->pool)
pj_pool_release(adi->pool);
pj_bzero(adi, sizeof(*adi));
/* Fill up with *dummy" device info */
pj_ansi_strncpy(adi->info.name, "AVI Player", sizeof(adi->info.name)-1);
pj_ansi_strncpy(adi->info.driver, DRIVER_NAME, sizeof(adi->info.driver)-1);
adi->info.dir = PJMEDIA_DIR_CAPTURE;
adi->info.has_callback = PJ_FALSE;
}
static int aviplay(pj_pool_t *pool, const char *fname)
{
pjmedia_vid_port *renderer=NULL;
pjmedia_vid_port_param param;
const pjmedia_video_format_info *vfi;
pjmedia_video_format_detail *vfd;
pjmedia_snd_port *snd_port = NULL;
pj_status_t status;
int rc = 0;
pjmedia_avi_streams *avi_streams;
pjmedia_avi_stream *vid_stream, *aud_stream;
pjmedia_port *vid_port = NULL, *aud_port = NULL;
pjmedia_vid_codec *codec=NULL;
avi_port_t avi_port;
pj_bzero(&avi_port, sizeof(avi_port));
status = pjmedia_avi_player_create_streams(pool, fname, 0, &avi_streams);
if (status != PJ_SUCCESS) {
PJ_PERROR(2,("", status, " Error playing %s", fname));
rc = 210;
goto on_return;
}
vid_stream = pjmedia_avi_streams_get_stream_by_media(avi_streams,
0,
PJMEDIA_TYPE_VIDEO);
vid_port = pjmedia_avi_stream_get_port(vid_stream);
if (vid_port) {
pjmedia_vid_port_param_default(¶m);
status = pjmedia_vid_dev_default_param(pool,
PJMEDIA_VID_DEFAULT_RENDER_DEV,
¶m.vidparam);
if (status != PJ_SUCCESS) {
rc = 220;
goto on_return;
}
/* Create renderer, set it to active */
param.active = PJ_TRUE;
param.vidparam.dir = PJMEDIA_DIR_RENDER;
vfd = pjmedia_format_get_video_format_detail(&vid_port->info.fmt,
PJ_TRUE);
pjmedia_format_init_video(¶m.vidparam.fmt,
vid_port->info.fmt.id,
vfd->size.w, vfd->size.h,
vfd->fps.num, vfd->fps.denum);
vfi = pjmedia_get_video_format_info(
pjmedia_video_format_mgr_instance(),
vid_port->info.fmt.id);
/* Check whether the frame is encoded */
if (!vfi || vfi->bpp == 0) {
/* Yes, prepare codec */
pj_str_t codec_id_st;
unsigned info_cnt = 1, i, k;
const pjmedia_vid_codec_info *codec_info;
pj_str_t port_name = {"codec", 5};
pj_uint8_t *enc_buf = NULL;
pj_size_t enc_buf_size = 0;
pjmedia_vid_dev_info rdr_info;
pjmedia_port codec_port;
codec_port_data_t codec_port_data;
pjmedia_vid_codec_param codec_param;
struct codec_fmt *codecp = NULL;
/* Lookup codec */
for (i = 0; i < sizeof(codec_fmts)/sizeof(codec_fmts[0]); i++) {
if (vid_port->info.fmt.id == codec_fmts[i].pjmedia_id) {
codecp = &codec_fmts[i];
break;
}
}
if (!codecp) {
rc = 242;
goto on_return;
}
pj_cstr(&codec_id_st, codecp->codec_id);
status = pjmedia_vid_codec_mgr_find_codecs_by_id(NULL,
&codec_id_st,
&info_cnt,
&codec_info,
NULL);
if (status != PJ_SUCCESS) {
rc = 245;
goto on_return;
}
status = pjmedia_vid_codec_mgr_get_default_param(NULL, codec_info,
&codec_param);
if (status != PJ_SUCCESS) {
rc = 246;
goto on_return;
}
pjmedia_format_copy(&codec_param.enc_fmt, ¶m.vidparam.fmt);
pjmedia_vid_dev_get_info(param.vidparam.rend_id, &rdr_info);
for (i=0; i<codec_info->dec_fmt_id_cnt; ++i) {
for (k=0; k<rdr_info.fmt_cnt; ++k) {
if (codec_info->dec_fmt_id[i]==(int)rdr_info.fmt[k].id)
{
param.vidparam.fmt.id = codec_info->dec_fmt_id[i];
i = codec_info->dec_fmt_id_cnt;
break;
}
}
}
/* Open codec */
status = pjmedia_vid_codec_mgr_alloc_codec(NULL, codec_info,
&codec);
if (status != PJ_SUCCESS) {
rc = 250;
goto on_return;
}
status = pjmedia_vid_codec_init(codec, pool);
if (status != PJ_SUCCESS) {
rc = 251;
goto on_return;
}
pjmedia_format_copy(&codec_param.dec_fmt, ¶m.vidparam.fmt);
codec_param.dir = PJMEDIA_DIR_DECODING;
codec_param.packing = PJMEDIA_VID_PACKING_WHOLE;
status = pjmedia_vid_codec_open(codec, &codec_param);
if (status != PJ_SUCCESS) {
rc = 252;
goto on_return;
}
/* Alloc encoding buffer */
enc_buf_size = codec_param.dec_fmt.det.vid.size.w *
codec_param.dec_fmt.det.vid.size.h * 4
+ 16; /*< padding, just in case */
enc_buf = pj_pool_alloc(pool,enc_buf_size);
/* Init codec port */
pj_bzero(&codec_port, sizeof(codec_port));
status = pjmedia_port_info_init2(&codec_port.info, &port_name,
0x1234,
PJMEDIA_DIR_ENCODING,
&codec_param.dec_fmt);
if (status != PJ_SUCCESS) {
rc = 260;
goto on_return;
}
pj_bzero(&codec_port_data, sizeof(codec_port_data));
codec_port_data.codec = codec;
codec_port_data.src_port = vid_port;
codec_port_data.enc_buf = enc_buf;
codec_port_data.enc_buf_size = enc_buf_size;
codec_port.get_frame = &codec_get_frame;
codec_port.port_data.pdata = &codec_port_data;
/* Check whether we need to convert the decoded frame */
if (codecp->need_conversion) {
pjmedia_conversion_param conv_param;
pjmedia_format_copy(&conv_param.src, ¶m.vidparam.fmt);
pjmedia_format_copy(&conv_param.dst, ¶m.vidparam.fmt);
conv_param.dst.id = codecp->dst_fmt;
param.vidparam.fmt.id = conv_param.dst.id;
status = pjmedia_converter_create(NULL, pool, &conv_param,
&codec_port_data.conv);
if (status != PJ_SUCCESS) {
rc = 270;
goto on_return;
}
}
status = pjmedia_vid_port_create(pool, ¶m, &renderer);
if (status != PJ_SUCCESS) {
rc = 230;
goto on_return;
}
status = pjmedia_vid_port_connect(renderer, &codec_port,
PJ_FALSE);
} else {
status = pjmedia_vid_port_create(pool, ¶m, &renderer);
if (status != PJ_SUCCESS) {
rc = 230;
goto on_return;
}
/* Connect avi port to renderer */
status = pjmedia_vid_port_connect(renderer, vid_port,
PJ_FALSE);
}
if (status != PJ_SUCCESS) {
rc = 240;
goto on_return;
}
}
aud_stream = pjmedia_avi_streams_get_stream_by_media(avi_streams,
0,
PJMEDIA_TYPE_AUDIO);
aud_port = pjmedia_avi_stream_get_port(aud_stream);
if (aud_port) {
/* Create sound player port. */
status = pjmedia_snd_port_create_player(
pool, /* pool */
-1, /* use default dev. */
PJMEDIA_PIA_SRATE(&aud_port->info),/* clock rate. */
PJMEDIA_PIA_CCNT(&aud_port->info), /* # of channels. */
PJMEDIA_PIA_SPF(&aud_port->info), /* samples per frame. */
PJMEDIA_PIA_BITS(&aud_port->info), /* bits per sample. */
0, /* options */
&snd_port /* returned port */
);
if (status != PJ_SUCCESS) {
rc = 310;
goto on_return;
}
/* Connect file port to the sound player.
* Stream playing will commence immediately.
*/
status = pjmedia_snd_port_connect(snd_port, aud_port);
if (status != PJ_SUCCESS) {
rc = 330;
goto on_return;
}
}
if (vid_port) {
pjmedia_vid_dev_cb cb;
pj_bzero(&cb, sizeof(cb));
avi_port.snd_port = snd_port;
avi_port.vid_port = renderer;
avi_port.is_running = PJ_TRUE;
pjmedia_vid_port_set_cb(renderer, &cb, &avi_port);
/* subscribe events */
pjmedia_event_subscribe(NULL, &avi_event_cb, &avi_port,
renderer);
if (snd_port) {
/* Synchronize video rendering and audio playback */
pjmedia_vid_port_set_clock_src(
renderer,
pjmedia_snd_port_get_clock_src(
snd_port, PJMEDIA_DIR_PLAYBACK));
}
/* Start video streaming.. */
status = pjmedia_vid_port_start(renderer);
if (status != PJ_SUCCESS) {
rc = 270;
goto on_return;
}
}
while (!avi_port.is_quitting) {
pj_thread_sleep(100);
}
on_return:
if (snd_port) {
pjmedia_snd_port_disconnect(snd_port);
/* Without this sleep, Windows/DirectSound will repeteadly
* play the last frame during destroy.
*/
pj_thread_sleep(100);
pjmedia_snd_port_destroy(snd_port);
}
if (renderer) {
pjmedia_event_unsubscribe(NULL, &avi_event_cb, &avi_port,
renderer);
pjmedia_vid_port_destroy(renderer);
}
if (aud_port)
pjmedia_port_destroy(aud_port);
if (vid_port)
pjmedia_port_destroy(vid_port);
if (codec) {
pjmedia_vid_codec_close(codec);
pjmedia_vid_codec_mgr_dealloc_codec(NULL, codec);
}
return rc;
}
/*
* main()
*/
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pjmedia_endpt *med_endpt;
pj_pool_t *pool;
pj_status_t status;
/* Codec */
char *codec_id = (char*)"H264";
const pjmedia_vid_codec_info *codec_info;
pjmedia_vid_codec_param codec_param;
pjmedia_vid_codec *codec = NULL;
//const char *save_filename =
// "/home/bennylp/Desktop/opt/src/openh264-svn/testbin/test.264";
const char *save_filename = NULL;
/* File */
enum
{
WIDTH = 320,
HEIGHT = 192,
FPS = 12,
YUV_SIZE = WIDTH * HEIGHT * 3 >> 1,
YUV_BUF_SIZE = YUV_SIZE + WIDTH,
MAX_FRAMES = 32,
MTU = 1500
};
FILE *fyuv = NULL;
FILE *f264 = NULL;
typedef pj_uint8_t enc_buf_type[MTU];
pj_uint8_t yuv_frame[YUV_BUF_SIZE];
enc_buf_type enc_buf[MAX_FRAMES];
unsigned read_cnt = 0,
pkt_cnt = 0,
dec_cnt = 0,
enc_cnt;
if (0) {
diff_file();
return 1;
}
/* init PJLIB : */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/* Initialize media endpoint. */
status = pjmedia_endpt_create(&cp.factory, NULL, 1, &med_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Create memory pool for application purpose */
pool = pj_pool_create( &cp.factory, /* pool factory */
"app", /* pool name. */
4000, /* init size */
4000, /* increment size */
NULL /* callback on error */
);
/* Init video format manager */
pjmedia_video_format_mgr_create(pool, 64, 0, NULL);
/* Init video converter manager */
pjmedia_converter_mgr_create(pool, NULL);
/* Init event manager */
pjmedia_event_mgr_create(pool, 0, NULL);
/* Init video codec manager */
pjmedia_vid_codec_mgr_create(pool, NULL);
/* Register all supported codecs */
status = init_codecs(&cp.factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Open YUV file */
fyuv = fopen("pjsip-apps/bin/CiscoVT2people_320x192_12fps.yuv", "rb");
if (!fyuv) {
puts("Unable to open ../CiscoVT2people_320x192_12fps.yuv");
status = -1;
goto on_exit;
}
/* Write 264 file if wanted */
if (save_filename) {
f264 = fopen(save_filename, "wb");
}
/* Find which codec to use. */
if (codec_id) {
unsigned count = 1;
pj_str_t str_codec_id = pj_str(codec_id);
status = pjmedia_vid_codec_mgr_find_codecs_by_id(NULL,
&str_codec_id, &count,
&codec_info, NULL);
if (status != PJ_SUCCESS) {
printf("Error: unable to find codec %s\n", codec_id);
return 1;
}
} else {
static pjmedia_vid_codec_info info[1];
unsigned count = PJ_ARRAY_SIZE(info);
/* Default to first codec */
pjmedia_vid_codec_mgr_enum_codecs(NULL, &count, info, NULL);
codec_info = &info[0];
}
/* Get codec default param for info */
status = pjmedia_vid_codec_mgr_get_default_param(NULL, codec_info,
&codec_param);
pj_assert(status == PJ_SUCCESS);
/* Alloc encoder */
status = pjmedia_vid_codec_mgr_alloc_codec(NULL, codec_info, &codec);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Error allocating codec"));
goto on_exit;
}
codec_param.dir = PJMEDIA_DIR_ENCODING_DECODING;
codec_param.packing = PJMEDIA_VID_PACKING_PACKETS;
codec_param.enc_mtu = MTU;
codec_param.enc_fmt.det.vid.size.w = WIDTH;
codec_param.enc_fmt.det.vid.size.h = HEIGHT;
codec_param.enc_fmt.det.vid.fps.num = FPS;
codec_param.enc_fmt.det.vid.avg_bps = WIDTH * HEIGHT * FPS;
status = pjmedia_vid_codec_init(codec, pool);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Error initializing codec"));
goto on_exit;
}
status = pjmedia_vid_codec_open(codec, &codec_param);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Error opening codec"));
goto on_exit;
}
while (fread(yuv_frame, 1, YUV_SIZE, fyuv) == YUV_SIZE) {
pjmedia_frame frm_yuv, frm_enc[MAX_FRAMES];
pj_bool_t has_more = PJ_FALSE;
const pj_uint8_t start_nal[] = { 0, 0, 1 };
unsigned i;
++ read_cnt;
pj_bzero(&frm_enc, sizeof(frm_enc));
pj_bzero(&frm_yuv, sizeof(frm_yuv));
frm_yuv.buf = yuv_frame;
frm_yuv.size = YUV_SIZE;
enc_cnt = 0;
frm_enc[enc_cnt].buf = enc_buf[enc_cnt];
frm_enc[enc_cnt].size = MTU;
status = pjmedia_vid_codec_encode_begin(codec, NULL, &frm_yuv,
MTU, &frm_enc[enc_cnt],
&has_more);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Codec encode error"));
goto on_exit;
}
if (frm_enc[enc_cnt].size) {
if (f264) {
fwrite(start_nal, 1, sizeof(start_nal), f264);
fwrite(frm_enc[enc_cnt].buf, 1, frm_enc[enc_cnt].size, f264);
}
++pkt_cnt;
++enc_cnt;
}
while (has_more) {
if (enc_cnt >= MAX_FRAMES) {
status = -1;
puts("Error: too many encoded frames");
goto on_exit;
}
has_more = PJ_FALSE;
frm_enc[enc_cnt].buf = enc_buf[enc_cnt];
frm_enc[enc_cnt].size = MTU;
status = pjmedia_vid_codec_encode_more(codec, MTU,
&frm_enc[enc_cnt],
&has_more);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Codec encode error"));
goto on_exit;
}
if (frm_enc[enc_cnt].size) {
if (f264) {
fwrite(start_nal, 1, sizeof(start_nal), f264);
fwrite(frm_enc[enc_cnt].buf, 1, frm_enc[enc_cnt].size,
f264);
}
++pkt_cnt;
++enc_cnt;
}
}
if (enc_cnt) {
frm_yuv.buf = yuv_frame;
frm_yuv.size = YUV_BUF_SIZE;
status = pjmedia_vid_codec_decode(codec, enc_cnt,
frm_enc,
YUV_BUF_SIZE,
&frm_yuv);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Codec decode error"));
goto on_exit;
}
if (frm_yuv.size != 0) {
++dec_cnt;
}
}
}
printf("Done.\n"
" Read YUV frames: %d\n"
" Encoded packets: %d\n"
" Decoded YUV frames: %d\n",
read_cnt, pkt_cnt, dec_cnt);
/* Start deinitialization: */
on_exit:
if (codec) {
pjmedia_vid_codec_close(codec);
pjmedia_vid_codec_mgr_dealloc_codec(NULL, codec);
}
if (f264)
fclose(f264);
if (fyuv)
fclose(fyuv);
/* Deinit codecs */
deinit_codecs();
/* Destroy event manager */
pjmedia_event_mgr_destroy(NULL);
/* Release application pool */
pj_pool_release( pool );
/* Destroy media endpoint. */
pjmedia_endpt_destroy( med_endpt );
/* Destroy pool factory */
pj_caching_pool_destroy( &cp );
/* Shutdown PJLIB */
pj_shutdown();
return (status == PJ_SUCCESS) ? 0 : 1;
}
#else
int main(int argc, char *argv[])
{
PJ_UNUSED_ARG(argc);
PJ_UNUSED_ARG(argv);
puts("Error: this sample requires video capability "
"(PJMEDIA_HAS_VIDEO == 1)");
return -1;
}
static int encode_decode_test(pj_pool_t *pool, const char *codec_id,
pjmedia_vid_packing packing)
{
const pj_str_t port_name = {"codec", 5};
pjmedia_vid_codec *codec=NULL;
pjmedia_port codec_port;
codec_port_data_t codec_port_data;
pjmedia_vid_codec_param codec_param;
const pjmedia_vid_codec_info *codec_info;
const char *packing_name;
pjmedia_vid_dev_index cap_idx, rdr_idx;
pjmedia_vid_port *capture=NULL, *renderer=NULL;
pjmedia_vid_port_param vport_param;
pjmedia_video_format_detail *vfd;
char codec_name[5];
pj_status_t status;
int rc = 0;
switch (packing) {
case PJMEDIA_VID_PACKING_PACKETS:
packing_name = "framed";
break;
case PJMEDIA_VID_PACKING_WHOLE:
packing_name = "whole";
break;
default:
packing_name = "unknown";
break;
}
PJ_LOG(3, (THIS_FILE, " encode decode test: codec=%s, packing=%s",
codec_id, packing_name));
/* Lookup codec */
{
pj_str_t codec_id_st;
unsigned info_cnt = 1;
/* Lookup codec */
pj_cstr(&codec_id_st, codec_id);
status = pjmedia_vid_codec_mgr_find_codecs_by_id(NULL, &codec_id_st,
&info_cnt,
&codec_info, NULL);
if (status != PJ_SUCCESS) {
rc = 205;
goto on_return;
}
}
#if CAPTURE_DEV == -1
/* Lookup colorbar source */
status = pjmedia_vid_dev_lookup("Colorbar", "Colorbar generator", &cap_idx);
if (status != PJ_SUCCESS) {
rc = 206;
goto on_return;
}
#elif CAPTURE_DEV == -2
/* Lookup any first non-colorbar source */
{
unsigned i, cnt;
pjmedia_vid_dev_info info;
cap_idx = -1;
cnt = pjmedia_vid_dev_count();
for (i = 0; i < cnt; ++i) {
status = pjmedia_vid_dev_get_info(i, &info);
if (status != PJ_SUCCESS) {
rc = 206;
goto on_return;
}
if (info.dir & PJMEDIA_DIR_CAPTURE &&
pj_ansi_stricmp(info.driver, "Colorbar"))
{
cap_idx = i;
break;
}
}
if (cap_idx == -1) {
status = PJ_ENOTFOUND;
rc = 206;
goto on_return;
}
}
#else
cap_idx = CAPTURE_DEV;
#endif
/* Lookup SDL renderer */
status = pjmedia_vid_dev_lookup("SDL", "SDL renderer", &rdr_idx);
if (status != PJ_SUCCESS) {
rc = 207;
goto on_return;
}
/* Prepare codec */
{
pj_str_t codec_id_st;
unsigned info_cnt = 1;
const pjmedia_vid_codec_info *codec_info;
/* Lookup codec */
pj_cstr(&codec_id_st, codec_id);
status = pjmedia_vid_codec_mgr_find_codecs_by_id(NULL, &codec_id_st,
&info_cnt,
&codec_info, NULL);
if (status != PJ_SUCCESS) {
rc = 245;
goto on_return;
}
status = pjmedia_vid_codec_mgr_get_default_param(NULL, codec_info,
&codec_param);
if (status != PJ_SUCCESS) {
rc = 246;
goto on_return;
}
codec_param.packing = packing;
/* Open codec */
status = pjmedia_vid_codec_mgr_alloc_codec(NULL, codec_info,
&codec);
if (status != PJ_SUCCESS) {
rc = 250;
goto on_return;
}
status = pjmedia_vid_codec_init(codec, pool);
if (status != PJ_SUCCESS) {
rc = 251;
goto on_return;
}
status = pjmedia_vid_codec_open(codec, &codec_param);
if (status != PJ_SUCCESS) {
rc = 252;
goto on_return;
}
/* After opened, codec will update the param, let's sync encoder &
* decoder format detail.
*/
codec_param.dec_fmt.det = codec_param.enc_fmt.det;
/* Subscribe to codec events */
pjmedia_event_subscribe(NULL, &codec_on_event, &codec_port_data,
codec);
}
pjmedia_vid_port_param_default(&vport_param);
/* Create capture, set it to active (master) */
status = pjmedia_vid_dev_default_param(pool, cap_idx,
&vport_param.vidparam);
if (status != PJ_SUCCESS) {
rc = 220;
goto on_return;
}
pjmedia_format_copy(&vport_param.vidparam.fmt, &codec_param.dec_fmt);
vport_param.vidparam.dir = PJMEDIA_DIR_CAPTURE;
vport_param.active = PJ_TRUE;
if (vport_param.vidparam.fmt.detail_type != PJMEDIA_FORMAT_DETAIL_VIDEO) {
rc = 221;
goto on_return;
}
vfd = pjmedia_format_get_video_format_detail(&vport_param.vidparam.fmt,
PJ_TRUE);
if (vfd == NULL) {
rc = 225;
goto on_return;
}
status = pjmedia_vid_port_create(pool, &vport_param, &capture);
if (status != PJ_SUCCESS) {
rc = 226;
goto on_return;
}
/* Create renderer, set it to passive (slave) */
vport_param.active = PJ_FALSE;
vport_param.vidparam.dir = PJMEDIA_DIR_RENDER;
vport_param.vidparam.rend_id = rdr_idx;
vport_param.vidparam.disp_size = vfd->size;
status = pjmedia_vid_port_create(pool, &vport_param, &renderer);
if (status != PJ_SUCCESS) {
rc = 230;
goto on_return;
}
/* Init codec port */
pj_bzero(&codec_port, sizeof(codec_port));
status = pjmedia_port_info_init2(&codec_port.info, &port_name, 0x1234,
PJMEDIA_DIR_ENCODING,
&codec_param.dec_fmt);
if (status != PJ_SUCCESS) {
rc = 260;
goto on_return;
}
codec_port_data.codec = codec;
codec_port_data.rdr_port = renderer;
codec_port_data.enc_buf_size = codec_param.dec_fmt.det.vid.size.w *
codec_param.dec_fmt.det.vid.size.h * 4;
codec_port_data.enc_buf = pj_pool_alloc(pool,
codec_port_data.enc_buf_size);
codec_port_data.pack_buf_size = codec_port_data.enc_buf_size;
codec_port_data.pack_buf = pj_pool_alloc(pool,
codec_port_data.pack_buf_size);
codec_port.put_frame = &codec_put_frame;
codec_port.port_data.pdata = &codec_port_data;
/* Connect capture to codec port */
status = pjmedia_vid_port_connect(capture,
&codec_port,
PJ_FALSE);
if (status != PJ_SUCCESS) {
rc = 270;
goto on_return;
}
PJ_LOG(3, (THIS_FILE, " starting codec test: %s<->%.*s %dx%d",
pjmedia_fourcc_name(codec_param.dec_fmt.id, codec_name),
codec_info->encoding_name.slen,
codec_info->encoding_name.ptr,
codec_param.dec_fmt.det.vid.size.w,
codec_param.dec_fmt.det.vid.size.h
));
/* Start streaming.. */
status = pjmedia_vid_port_start(renderer);
if (status != PJ_SUCCESS) {
rc = 275;
goto on_return;
}
status = pjmedia_vid_port_start(capture);
if (status != PJ_SUCCESS) {
rc = 280;
goto on_return;
}
/* Sleep while the video is being displayed... */
pj_thread_sleep(10000);
on_return:
if (status != PJ_SUCCESS) {
PJ_PERROR(3, (THIS_FILE, status, " error"));
}
if (capture)
pjmedia_vid_port_stop(capture);
if (renderer)
pjmedia_vid_port_stop(renderer);
if (capture)
pjmedia_vid_port_destroy(capture);
if (renderer)
pjmedia_vid_port_destroy(renderer);
if (codec) {
pjmedia_event_unsubscribe(NULL, &codec_on_event, &codec_port_data,
codec);
pjmedia_vid_codec_close(codec);
pjmedia_vid_codec_mgr_dealloc_codec(NULL, codec);
}
return rc;
}
/* API: configure the AVI */
PJ_DEF(pj_status_t) pjmedia_avi_dev_alloc( pjmedia_vid_dev_factory *f,
pjmedia_avi_dev_param *p,
pjmedia_vid_dev_index *p_id)
{
pjmedia_vid_dev_index id;
struct avi_factory *cf = (struct avi_factory*)f;
unsigned local_idx;
struct avi_dev_info *adi = NULL;
pjmedia_format avi_fmt;
const pjmedia_video_format_info *vfi;
pj_status_t status;
PJ_ASSERT_RETURN(f && p && p_id, PJ_EINVAL);
if (p_id)
*p_id = PJMEDIA_VID_INVALID_DEV;
/* Get a free dev */
for (local_idx=0; local_idx<cf->dev_count; ++local_idx) {
if (cf->dev_info[local_idx].avi == NULL) {
adi = &cf->dev_info[local_idx];
break;
}
}
if (!adi)
return PJ_ETOOMANY;
/* Convert local ID to global id */
status = pjmedia_vid_dev_get_global_index(&cf->base, local_idx, &id);
if (status != PJ_SUCCESS)
return status;
/* Reset */
if (adi->pool) {
pj_pool_release(adi->pool);
}
pj_bzero(adi, sizeof(*adi));
/* Reinit */
PJ_ASSERT_RETURN(p->path.slen, PJ_EINVAL);
adi->pool = pj_pool_create(cf->pf, "avidi%p", 512, 512, NULL);
/* Open the AVI */
pj_strdup_with_null(adi->pool, &adi->fpath, &p->path);
status = pjmedia_avi_player_create_streams(adi->pool, adi->fpath.ptr, 0,
&adi->avi);
if (status != PJ_SUCCESS) {
goto on_error;
}
adi->vid = pjmedia_avi_streams_get_stream_by_media(adi->avi, 0,
PJMEDIA_TYPE_VIDEO);
if (!adi->vid) {
status = PJMEDIA_EVID_BADFORMAT;
PJ_LOG(4,(THIS_FILE, "Error: cannot find video in AVI %s",
adi->fpath.ptr));
goto on_error;
}
pjmedia_format_copy(&avi_fmt, &adi->vid->info.fmt);
vfi = pjmedia_get_video_format_info(NULL, avi_fmt.id);
/* Check whether the frame is encoded. */
if (!vfi || vfi->bpp == 0) {
/* Yes, prepare codec */
const pjmedia_vid_codec_info *codec_info;
pjmedia_vid_codec_param codec_param;
pjmedia_video_apply_fmt_param vafp;
/* Lookup codec */
status = pjmedia_vid_codec_mgr_get_codec_info2(NULL,
avi_fmt.id,
&codec_info);
if (status != PJ_SUCCESS || !codec_info)
goto on_error;
status = pjmedia_vid_codec_mgr_get_default_param(NULL, codec_info,
&codec_param);
if (status != PJ_SUCCESS)
goto on_error;
/* Open codec */
status = pjmedia_vid_codec_mgr_alloc_codec(NULL, codec_info,
&adi->codec);
if (status != PJ_SUCCESS)
goto on_error;
status = pjmedia_vid_codec_init(adi->codec, adi->pool);
if (status != PJ_SUCCESS)
goto on_error;
codec_param.dir = PJMEDIA_DIR_DECODING;
codec_param.packing = PJMEDIA_VID_PACKING_WHOLE;
status = pjmedia_vid_codec_open(adi->codec, &codec_param);
if (status != PJ_SUCCESS)
goto on_error;
/* Allocate buffer */
avi_fmt.id = codec_info->dec_fmt_id[0];
vfi = pjmedia_get_video_format_info(NULL, avi_fmt.id);
pj_bzero(&vafp, sizeof(vafp));
vafp.size = avi_fmt.det.vid.size;
status = vfi->apply_fmt(vfi, &vafp);
if (status != PJ_SUCCESS)
goto on_error;
adi->enc_buf = pj_pool_alloc(adi->pool, vafp.framebytes);
adi->enc_buf_size = vafp.framebytes;
}
/* Calculate title */
if (p->title.slen) {
pj_strdup_with_null(adi->pool, &adi->title, &p->title);
} else {
char *start = p->path.ptr + p->path.slen;
pj_str_t tmp;
while (start >= p->path.ptr) {
if (*start == '/' || *start == '\\')
break;
--start;
}
tmp.ptr = start + 1;
tmp.slen = p->path.ptr + p->path.slen - tmp.ptr;
pj_strdup_with_null(adi->pool, &adi->title, &tmp);
}
/* Init device info */
pj_ansi_strncpy(adi->info.name, adi->title.ptr, sizeof(adi->info.name)-1);
pj_ansi_strncpy(adi->info.driver, DRIVER_NAME, sizeof(adi->info.driver)-1);
adi->info.dir = PJMEDIA_DIR_CAPTURE;
adi->info.has_callback = PJ_FALSE;
adi->info.caps = PJMEDIA_VID_DEV_CAP_FORMAT;
adi->info.fmt_cnt = 1;
pjmedia_format_copy(&adi->info.fmt[0], &avi_fmt);
/* Set out vars */
if (p_id)
*p_id = id;
p->avi_streams = adi->avi;
if (p->title.slen == 0)
p->title = adi->title;
return PJ_SUCCESS;
on_error:
if (adi->codec) {
pjmedia_vid_codec_close(adi->codec);
adi->codec = NULL;
}
if (adi->pool) {
pj_pool_release(adi->pool);
adi->pool = NULL;
}
pjmedia_avi_dev_free(id);
return status;
}
