static int decode_params(struct aucodec_st *st, const char *fmtp)
{
struct pl params;
pl_set_str(¶ms, fmtp);
fmt_param_apply(¶ms, decode_param, st);
return 0;
}
int gst_video1_encoder_set(struct videnc_state **stp,
const struct vidcodec *vc,
struct videnc_param *prm, const char *fmtp,
videnc_packet_h *pkth, void *arg)
{
struct videnc_state *st = *stp;
int err = 0;
if (!stp || !vc || !prm || !pkth)
return EINVAL;
if (!st) {
err = allocate_resources(stp);
if (err) {
warning("gst_video: resource allocation failed\n");
return err;
}
st = *stp;
st->pkth = pkth;
st->arg = arg;
}
else {
if (!st->streamer.valid) {
warning("gst_video codec: trying to work"
" with invalid pipeline\n");
return EINVAL;
}
if ((st->encoder.bitrate != prm->bitrate ||
st->encoder.pktsize != prm->pktsize ||
st->encoder.fps != prm->fps)) {
pipeline_close(st);
}
}
st->encoder.bitrate = prm->bitrate;
st->encoder.pktsize = prm->pktsize;
st->encoder.fps = prm->fps;
if (str_isset(fmtp)) {
struct pl sdp_fmtp;
pl_set_str(&sdp_fmtp, fmtp);
/* store new parameters */
fmt_param_apply(&sdp_fmtp, param_handler, st);
}
info("gst_video: video encoder %s: %d fps, %d bit/s, pktsize=%u\n",
vc->name, st->encoder.fps,
st->encoder.bitrate, st->encoder.pktsize);
return err;
}
static int encode_update(struct auenc_state **aesp, const struct aucodec *ac,
struct auenc_param *prm, const char *fmtp)
{
struct auenc_state *st;
int ret, err = 0;
if (!aesp || !ac || !prm)
return EINVAL;
if (prm->ptime != SPEEX_PTIME)
return EPROTO;
if (*aesp)
return 0;
st = mem_zalloc(sizeof(*st), encode_destructor);
if (!st)
return ENOMEM;
st->frame_size = ac->srate * SPEEX_PTIME / 1000;
st->channels = ac->ch;
/* Encoder */
st->enc = speex_encoder_init(resolve_mode(ac->srate));
if (!st->enc) {
err = ENOMEM;
goto out;
}
speex_bits_init(&st->bits);
encoder_config(st->enc);
ret = speex_encoder_ctl(st->enc, SPEEX_GET_FRAME_SIZE,
&st->frame_size);
if (ret) {
warning("speex: SPEEX_GET_FRAME_SIZE: %d\n", ret);
}
if (str_isset(fmtp)) {
struct pl params;
pl_set_str(¶ms, fmtp);
fmt_param_apply(¶ms, param_handler, st);
}
out:
if (err)
mem_deref(st);
else
*aesp = st;
return err;
}
int gst_video_encode_update(struct videnc_state **vesp,
const struct vidcodec *vc,
struct videnc_param *prm, const char *fmtp,
videnc_packet_h *pkth, void *arg)
{
struct videnc_state *ves;
int err = 0;
if (!vesp || !vc || !prm)
return EINVAL;
ves = *vesp;
if (!ves) {
ves = mem_zalloc(sizeof(*ves), encode_destructor);
if (!ves)
return ENOMEM;
*vesp = ves;
}
else {
if (ves->gst_inited && (ves->bitrate != prm->bitrate ||
ves->pktsize != prm->pktsize ||
ves->fps != prm->fps)) {
gst_encoder_close(ves);
}
}
if (str_isset(fmtp)) {
struct pl sdp_fmtp;
pl_set_str(&sdp_fmtp, fmtp);
fmt_param_apply(&sdp_fmtp, param_handler, ves);
}
ves->bitrate = prm->bitrate;
ves->pktsize = prm->pktsize;
ves->fps = prm->fps;
ves->pkth = pkth;
ves->pkth_arg = arg;
info("gst_video: video encoder %s: %d fps, %d bit/s, pktsize=%u\n",
vc->name, prm->fps, prm->bitrate, prm->pktsize);
return err;
}
int encode_update(struct videnc_state **vesp, const struct vidcodec *vc,
struct videnc_param *prm, const char *fmtp,
videnc_packet_h *pkth, void *arg)
{
struct videnc_state *st;
int err = 0;
if (!vesp || !vc || !prm || !pkth)
return EINVAL;
if (*vesp)
return 0;
st = mem_zalloc(sizeof(*st), destructor);
if (!st)
return ENOMEM;
st->encprm = *prm;
st->pkth = pkth;
st->arg = arg;
st->codec_id = avcodec_resolve_codecid(vc->name);
if (st->codec_id == AV_CODEC_ID_NONE) {
err = EINVAL;
goto out;
}
st->mb = mbuf_alloc(FF_MIN_BUFFER_SIZE * 20);
st->mb_frag = mbuf_alloc(1024);
if (!st->mb || !st->mb_frag) {
err = ENOMEM;
goto out;
}
st->sz_max = st->mb->size;
if (st->codec_id == AV_CODEC_ID_H264) {
#ifndef USE_X264
err = init_encoder(st);
#endif
}
else
err = init_encoder(st);
if (err) {
warning("avcodec: %s: could not init encoder\n", vc->name);
goto out;
}
if (str_isset(fmtp)) {
struct pl sdp_fmtp;
pl_set_str(&sdp_fmtp, fmtp);
fmt_param_apply(&sdp_fmtp, param_handler, st);
}
debug("avcodec: video encoder %s: %d fps, %d bit/s, pktsize=%u\n",
vc->name, prm->fps, prm->bitrate, prm->pktsize);
out:
if (err)
mem_deref(st);
else
*vesp = st;
return err;
}
static int alloc(struct vidcodec_st **stp, struct vidcodec *vc,
const char *name, struct vidcodec_prm *encp,
const char *fmtp, vidcodec_enq_h *enqh,
vidcodec_send_h *sendh, void *arg)
{
struct vidcodec_st *st;
int err = 0;
if (!encp)
return EINVAL;
st = mem_zalloc(sizeof(*st), destructor);
if (!st)
return ENOMEM;
st->vc = mem_ref(vc);
st->encprm = *encp;
if (0 == str_casecmp(name, "H263"))
st->codec_id = CODEC_ID_H263;
else if (0 == str_casecmp(name, "H264"))
st->codec_id = CODEC_ID_H264;
else if (0 == str_casecmp(name, "MP4V-ES"))
st->codec_id = CODEC_ID_MPEG4;
else {
err = EINVAL;
goto out;
}
st->enc.mb = mbuf_alloc(FF_MIN_BUFFER_SIZE * 20);
st->dec.mb = mbuf_alloc(1024);
st->mb_frag = mbuf_alloc(1024);
if (!st->enc.mb || !st->dec.mb || !st->mb_frag) {
err = ENOMEM;
goto out;
}
st->enc.sz_max = st->enc.mb->size;
st->dec.sz_max = st->dec.mb->size;
if (st->codec_id == CODEC_ID_H264) {
#ifndef USE_X264
err = init_encoder(st);
#endif
}
else
err = init_encoder(st);
if (err) {
DEBUG_WARNING("%s: could not init encoder\n", name);
goto out;
}
err = init_decoder(st);
if (err) {
DEBUG_WARNING("%s: could not init decoder\n", name);
goto out;
}
if (str_isset(fmtp)) {
struct pl sdp_fmtp;
pl_set_str(&sdp_fmtp, fmtp);
fmt_param_apply(&sdp_fmtp, param_handler, st);
}
st->enqh = enqh;
st->sendh = sendh;
st->arg = arg;
re_printf("video codec %s: %d fps, %d bit/s\n", name,
encp->fps, encp->bitrate);
out:
if (err)
mem_deref(st);
else
*stp = st;
return err;
}