static void ei_x_print_msg(ei_x_buff *buf, erlang_pid *pid, int send) {
char *pbuf = NULL;
int i = 0;
ei_x_buff pidbuf;
ei_x_new(&pidbuf);
ei_x_encode_pid(&pidbuf, pid);
ei_s_print_term(&pbuf, pidbuf.buff, &i);
ei_x_print_reg_msg(buf, pbuf, send);
free(pbuf);
}
void ei_x_print_reg_msg(ei_x_buff * buf, char *dest, int send)
{
char *mbuf = NULL;
int i = 1;
ei_s_print_term(&mbuf, buf->buff, &i);
if (send) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Sending %s to %s\n", mbuf, dest);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Received %s from %s\n", mbuf, dest);
}
free(mbuf);
}
static void ei_x_print_reg_msg(ei_x_buff *buf, char *dest, int send) {
char *mbuf = NULL;
int i = 1;
ei_s_print_term(&mbuf, buf->buff, &i);
if (send) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Encoded term %s to '%s'\n", mbuf, dest);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Decoded term %s for '%s'\n", mbuf, dest);
}
free(mbuf);
}
/* Return values:
* - -1 error
* - 0 nothing
* - 1 detach */
int cnode_read(int fd, char **ret_str) {
ei_x_buff x;
erlang_msg msg;
int result, index, o_index, arity, type, size, ver, rv = CNODE_IGNORE;
const char *str;
char *s;
char atom[MAXATOMLEN];
ei_x_new(&x);
/* We don't use xreceive because we're not expecting any big
messages and we don't want a huge term to cause our memory
usage to blow out and crash us. */
/* Use a timeout of 1 millisecond even though we know we'll
be able to read at least some bytes, just to be sure we
do not get blocked (for long). Really we want to specify
"no timeout but don't block" to ei_receive_msg but it
doesn't provide that functionality. */
result = ei_receive_msg_tmo(fd, &msg, &x, 1);
if (result < 0) {
LOG_V("ei_receive_msg_tmo failed (%d): %s", erl_errno, strerror(erl_errno));
switch (erl_errno) {
case ETIMEDOUT:
DEBUG("ei_receive_msg_tmo: timed out.");
break;
case EAGAIN:
DEBUG("ei_receive_msg_tmo: try again");
break;
case EMSGSIZE:
DEBUG("ei_receive_msg_tmo: message too big");
rv = CNODE_ERROR;
break;
case EIO:
LOG_V("ei_receive_msg_tmo: IO error (%d: %s)", errno, strerror(errno));
if (errno != EAGAIN)
rv = CNODE_ERROR;
break;
}
}
else {
if (result == ERL_TICK) { /* nothing to do */
DEBUG("node tick message");
}
else {
switch (msg.msgtype) {
case ERL_SEND: str = "SEND"; break;
case ERL_REG_SEND: str = "REG_SEND"; break;
case ERL_LINK: str = "LINK"; break;
case ERL_UNLINK: str = "UNLINK"; break;
default: str = "unknown";
}
if (msg.msgtype == ERL_REG_SEND) {
index = 0;
if (ei_decode_version(x.buff, &index, &ver) == 0) {
// DEBUG_V("data ver %d", ver);
}
o_index = index;
if (ei_decode_atom(x.buff, &index, atom) == 0) {
// DEBUG_V("atom %s", atom);
if (!strcmp(atom, "detach")) {
DEBUG("got detach message");
rv = CNODE_DETACH;
}
else if (!strcmp(atom, "thump")) {
rv = CNODE_THUMP;
}
else {
DEBUG("message is unknown");
}
}
else if (ei_decode_tuple_header(x.buff, &index, &arity) == 0) {
if ((arity == 2)
&& !ei_decode_atom(x.buff, &index, atom) && !strcmp(atom, "stdout")
&& !ei_get_type(x.buff, &index, &type, &size)
&& (type == ERL_STRING_EXT)) {
*ret_str = (char *)malloc(size + 1);
if (ei_decode_string(x.buff, &index, *ret_str)) {
LOG("Failed to decode string for stdout message.");
free(*ret_str);
rv = CNODE_ERROR;
}
else
rv = CNODE_STR;
}
else {
index = o_index; // Re-set index to beginning of term.
s = 0;
ei_s_print_term(&s, x.buff, &index);
LOG_V("Unknown tuple (arity %d): %s", arity, s);
free(s);
}
}
else {
s = 0;
ei_s_print_term(&s, x.buff, &index);
LOG_V("Unknown message: %s", s);
free(s);
}
}
else {
DEBUG_V("received %s message", str);
}
}
}
ei_x_free(&x);
return rv;
}
int main(void)
#endif
{
ErlConnect conp;
Erl_IpAddr thisipaddr = (Erl_IpAddr)0;
FILE *fp = (FILE *)0;
char* charp = "foo";
double *doublep = NULL;
double doublex = 0.0;
ei_cnode xec;
ei_reg *ei_regp = NULL;
ei_term eterm;
ei_x_buff eix;
erlang_big *bigp = NULL;
erlang_fun efun;
erlang_msg *msgp = NULL;
erlang_msg emsg;
erlang_pid *pidp = NULL;
erlang_pid epid;
erlang_port eport;
erlang_ref eref;
erlang_trace etrace;
int *intp = NULL;
int intx = 0;
long *longp = NULL;
long longx = 0;
short creation = 0;
struct ei_reg_stat *ei_reg_statp = NULL;
struct ei_reg_tabstat *ei_reg_tabstatp = NULL;
struct hostent *hostp = NULL;
unsigned char * ucharp = (unsigned char *)"foo";
unsigned long *ulongp = NULL;
unsigned long ulongx = 0;
void *voidp = NULL;
#ifndef VXWORKS
EI_LONGLONG *longlongp = (EI_LONGLONG*)NULL;
EI_LONGLONG longlongx = 0;
EI_ULONGLONG *ulonglongp = (EI_ULONGLONG*)NULL;
EI_ULONGLONG ulonglongx = 0;
#endif
enum erlang_char_encoding enc;
intx = erl_errno;
ei_connect_init(&xec, charp, charp, creation);
ei_connect_xinit (&xec, charp, charp, charp, thisipaddr, charp, creation);
ei_connect(&xec, charp);
ei_xconnect (&xec, thisipaddr, charp);
ei_receive(intx, ucharp, intx);
ei_receive_msg(intx, &emsg, &eix);
ei_xreceive_msg(intx, &emsg, &eix);
ei_send(intx, &epid, charp, intx);
ei_reg_send(&xec, intx, charp, charp, intx);
ei_rpc(&xec, intx, charp, charp, charp, intx, &eix);
ei_rpc_to(&xec, intx, charp, charp, charp, intx);
ei_rpc_from(&xec, intx, intx, &emsg, &eix);
ei_publish(&xec, intx);
ei_accept(&xec, intx, &conp);
ei_unpublish(&xec);
ei_thisnodename(&xec);
ei_thishostname(&xec);
ei_thisalivename(&xec);
ei_self(&xec);
ei_gethostbyname(charp);
ei_gethostbyaddr(charp, intx, intx);
ei_gethostbyname_r(charp, hostp, charp, intx, intp);
ei_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp);
ei_encode_version(charp, intp);
ei_x_encode_version(&eix);
ei_encode_long(charp, intp, longx);
ei_x_encode_long(&eix, longx);
ei_encode_ulong(charp, intp, ulongx);
ei_x_encode_ulong(&eix, ulongx);
ei_encode_double(charp, intp, doublex);
ei_x_encode_double(&eix, doublex);
ei_encode_boolean(charp, intp, intx);
ei_x_encode_boolean(&eix, intx);
ei_encode_char(charp, intp, 'a');
ei_x_encode_char(&eix, 'a');
ei_encode_string(charp, intp, charp);
ei_encode_string_len(charp, intp, charp, intx);
ei_x_encode_string(&eix, charp);
ei_x_encode_string_len(&eix, charp, intx);
ei_encode_atom(charp, intp, charp);
ei_encode_atom_as(charp, intp, charp, ERLANG_LATIN1, ERLANG_UTF8);
ei_encode_atom_len(charp, intp, charp, intx);
ei_encode_atom_len_as(charp, intp, charp, intx, ERLANG_ASCII, ERLANG_LATIN1);
ei_x_encode_atom(&eix, charp);
ei_x_encode_atom_as(&eix, charp, ERLANG_LATIN1, ERLANG_UTF8);
ei_x_encode_atom_len(&eix, charp, intx);
ei_x_encode_atom_len_as(&eix, charp, intx, ERLANG_LATIN1, ERLANG_UTF8);
ei_encode_binary(charp, intp, (void *)0, longx);
ei_x_encode_binary(&eix, (void*)0, intx);
ei_encode_pid(charp, intp, &epid);
ei_x_encode_pid(&eix, &epid);
ei_encode_fun(charp, intp, &efun);
ei_x_encode_fun(&eix, &efun);
ei_encode_port(charp, intp, &eport);
ei_x_encode_port(&eix, &eport);
ei_encode_ref(charp, intp, &eref);
ei_x_encode_ref(&eix, &eref);
ei_encode_trace(charp, intp, &etrace);
ei_x_encode_trace(&eix, &etrace);
ei_encode_tuple_header(charp, intp, intx);
ei_x_encode_tuple_header(&eix, longx);
ei_encode_list_header(charp, intp, intx);
ei_x_encode_list_header(&eix, longx);
/* #define ei_encode_empty_list(buf,i) ei_encode_list_header(buf,i,0) */
ei_x_encode_empty_list(&eix);
ei_get_type(charp, intp, intp, intp);
ei_get_type_internal(charp, intp, intp, intp);
ei_decode_version(charp, intp, intp);
ei_decode_long(charp, intp, longp);
ei_decode_ulong(charp, intp, ulongp);
ei_decode_double(charp, intp, doublep);
ei_decode_boolean(charp, intp, intp);
ei_decode_char(charp, intp, charp);
ei_decode_string(charp, intp, charp);
ei_decode_atom(charp, intp, charp);
ei_decode_atom_as(charp, intp, charp, MAXATOMLEN_UTF8, ERLANG_WHATEVER, &enc, &enc);
ei_decode_binary(charp, intp, (void *)0, longp);
ei_decode_fun(charp, intp, &efun);
free_fun(&efun);
ei_decode_pid(charp, intp, &epid);
ei_decode_port(charp, intp, &eport);
ei_decode_ref(charp, intp, &eref);
ei_decode_trace(charp, intp, &etrace);
ei_decode_tuple_header(charp, intp, intp);
ei_decode_list_header(charp, intp, intp);
ei_decode_ei_term(charp, intp, &eterm);
ei_print_term(fp, charp, intp);
ei_s_print_term(&charp, charp, intp);
ei_x_format(&eix, charp);
ei_x_format_wo_ver(&eix, charp);
ei_x_new(&eix);
ei_x_new_with_version(&eix);
ei_x_free(&eix);
ei_x_append(&eix, &eix);
ei_x_append_buf(&eix, charp, intx);
ei_skip_term(charp, intp);
ei_reg_open(intx);
ei_reg_resize(ei_regp, intx);
ei_reg_close(ei_regp);
ei_reg_setival(ei_regp, charp, longx);
ei_reg_setfval(ei_regp, charp, doublex);
ei_reg_setsval(ei_regp, charp, charp);
ei_reg_setpval(ei_regp, charp, voidp, intx);
ei_reg_setval(ei_regp, charp, intx);
ei_reg_getival(ei_regp, charp);
ei_reg_getfval(ei_regp, charp);
ei_reg_getsval(ei_regp, charp);
ei_reg_getpval(ei_regp, charp, intp);
ei_reg_getval(ei_regp, charp, intx);
ei_reg_markdirty(ei_regp, charp);
ei_reg_delete(ei_regp, charp);
ei_reg_stat(ei_regp, charp, ei_reg_statp);
ei_reg_tabstat(ei_regp, ei_reg_tabstatp);
ei_reg_dump(intx, ei_regp, charp, intx);
ei_reg_restore(intx, ei_regp, charp);
ei_reg_purge(ei_regp);
#if defined(HAVE_GMP_H) && defined(HAVE_LIBGMP)
{
mpz_t obj;
ei_decode_bignum(charp, intp, obj);
ei_encode_bignum(charp, intp, obj);
ei_x_encode_bignum(&eix, obj);
}
#endif /* HAVE_GMP_H && HAVE_LIBGMP */
#ifndef VXWORKS
ei_decode_longlong(charp, intp, longlongp);
ei_decode_ulonglong(charp, intp, ulonglongp);
ei_encode_longlong(charp, intp, longlongx);
ei_encode_ulonglong(charp, intp, ulonglongx);
ei_x_encode_longlong(&eix, longlongx);
ei_x_encode_ulonglong(&eix, ulonglongx);
#endif
#ifdef USE_EI_UNDOCUMENTED
ei_decode_intlist(charp, intp, longp, intp);
ei_receive_encoded(intx, &charp, intp, msgp, intp);
ei_send_encoded(intx, pidp, charp, intx);
ei_send_reg_encoded(intx, pidp, charp, charp, intx);
ei_decode_big(charp, intp, bigp);
ei_big_comp(bigp, bigp);
ei_big_to_double(bigp, doublep);
ei_small_to_big(intx, bigp);
ei_alloc_big(intx);
ei_free_big(bigp);
#endif /* USE_EI_UNDOCUMENTED */
return
BUFSIZ +
EAGAIN +
EHOSTUNREACH +
EIO +
EI_BIN +
EI_DELET +
EI_DIRTY +
EI_FLT +
EI_FORCE +
EI_INT +
EI_NOPURGE +
EI_STR +
EMSGSIZE +
ENOMEM +
ERL_ERROR +
ERL_EXIT +
ERL_LINK +
ERL_MSG +
ERL_NO_TIMEOUT +
ERL_REG_SEND +
ERL_SEND +
ERL_TICK +
ERL_TIMEOUT +
ERL_UNLINK +
ETIMEDOUT +
MAXATOMLEN;
}
int erlang_srdb2_cmd_exec(db_res_t* res, db_cmd_t* cmd) {
LM_DBG("erlang_srdb2_cmd_exec %p %p\n",res ,cmd);
db_fld_t* fld;
ei_x_buff argbuf;
int i,cnt;
char *pbuf=NULL;
static str con=STR_STATIC_INIT("con1");
static str regname=STR_STATIC_INIT("echo_server");
LM_DBG("erlang_srdb2_cmd %p\n",cmd);
// for(i = 0, fld = cmd->vals; !DB_FLD_EMPTY(fld) && !DB_FLD_LAST(fld[i]); i++) {
// rv |= sb_add(&sql_buf, set_str(&tmpstr, fld[i].name));
// if (!DB_FLD_LAST(fld[i + 1])) rv |= sb_add(&sql_buf, set_str(&tmpstr, ","));
// }
ei_x_new(&argbuf);
//encode tuple {db_op, table, [cols], [params]}
ei_x_encode_tuple_header(&argbuf, 5);
switch(cmd->type) {
case DB_PUT: ei_x_encode_atom(&argbuf,"insert"); break;
case DB_DEL: ei_x_encode_atom(&argbuf,"delete"); break;
case DB_GET: ei_x_encode_atom(&argbuf,"select"); break;
case DB_UPD: ei_x_encode_atom(&argbuf,"update"); break;
case DB_SQL: ei_x_encode_atom(&argbuf,"rawquery"); break;
}
ei_x_encode_atom_len(&argbuf,cmd->table.s,cmd->table.len);
for(i = 0, fld = cmd->result; !DB_FLD_LAST(fld[i]); i++) {}
ei_x_encode_list_header(&argbuf, i);
for(i = 0, fld = cmd->result; !DB_FLD_LAST(fld[i]); i++) {
ei_x_encode_atom(&argbuf,fld[i].name);
}
ei_x_encode_empty_list(&argbuf);
if(cmd->match) {
for(i = 0, fld = cmd->match; !DB_FLD_LAST(fld[i]); i++) {}
ei_x_encode_list_header(&argbuf, i);
for(i = 0, fld = cmd->match; !DB_FLD_LAST(fld[i]); i++) {
ei_x_encode_tuple_header(&argbuf, 3);
ei_x_encode_atom(&argbuf,fld[i].name);
switch(fld[i].op) {
case DB_EQ: ei_x_encode_atom(&argbuf,"="); break;
case DB_NE: ei_x_encode_atom(&argbuf,"!="); break;
case DB_LT: ei_x_encode_atom(&argbuf,"<"); break;
case DB_GT: ei_x_encode_atom(&argbuf,">"); break;
case DB_LEQ: ei_x_encode_atom(&argbuf,"<="); break;
case DB_GEQ: ei_x_encode_atom(&argbuf,">="); break;
}
ei_x_encode_atom_len(&argbuf,fld[i].v.lstr.s,fld[i].v.lstr.len);
}
ei_x_encode_empty_list(&argbuf);
} else {
ei_x_encode_list_header(&argbuf, 0);
}
if(cmd->vals) {
for(i = 0, fld = cmd->vals; !DB_FLD_LAST(fld[i]); i++) {}
ei_x_encode_list_header(&argbuf, i);
for(i = 0, fld = cmd->result; !DB_FLD_LAST(fld[i]); i++) {
ei_x_encode_atom(&argbuf,fld[i].name);
}
ei_x_encode_empty_list(&argbuf);
} else {
ei_x_encode_list_header(&argbuf, 0);
}
i=0;
ei_s_print_term(&pbuf, argbuf.buff, &i);
LM_DBG("message is pbuf='%s' buf.buffsz=%d buf.index=%d i=%d\n", pbuf, argbuf.buffsz,argbuf.index,i );
free(pbuf);pbuf=NULL;
erl_bind.do_erlang_call(&con,®name, &argbuf, NULL);
ei_x_free(&argbuf);
return 0;
};
void loop() {
int64_t dts_shift = AV_NOPTS_VALUE;
uint32_t buf_size = 10240;
char *buf = (char *)malloc(buf_size);
while(1) {
uint32_t len;
int idx = 0;
int read_bytes = 0;
if((read_bytes = read1(in_fd, &len, 4)) != 4) {
if(read_bytes == 0) {
_exit(0);
}
error("Can't read input length: %d", read_bytes);
}
len = ntohl(len);
if(len > buf_size) {
buf_size = len;
free(buf);
buf = (char *)malloc(buf_size);
}
if((read_bytes = read1(in_fd, buf, len)) != len) error("Can't read %d bytes from input: %d", len, read_bytes);
int version = 0;
ei_decode_version(buf, &idx, &version);
int command_idx = idx;
int arity = 0;
if(ei_decode_tuple_header(buf, &idx, &arity) == -1) error("must pass tuple");
int t = 0;
int size = 0;
ei_get_type(buf, &idx, &t, &size);
if(t != ERL_ATOM_EXT) error("first element must be atom");
char command[MAXATOMLEN+1];
ei_decode_atom(buf, &idx, command); arity--;
if(!strcmp(command, "ping")) {
pong();
continue;
}
if(!strcmp(command, "exit")) {
return;
}
if(!strcmp(command, "init_input")) {
if(arity != 3) error("Must provide 3 arguments to init_input command");
char content[1024];
char codec[1024];
if(ei_decode_atom(buf, &idx, content) == -1) error("Must provide content as an atom");
if(ei_decode_atom(buf, &idx, codec) == -1) error("Must provide codec as an atom");
int decoder_config_len = 0;
ei_get_type(buf, &idx, &t, &decoder_config_len);
if(t != ERL_BINARY_EXT) error("decoder config must be a binary");
uint8_t *decoder_config = av_mallocz(decoder_config_len + FF_INPUT_BUFFER_PADDING_SIZE);
long bin_len = 0;
ei_decode_binary(buf, &idx, decoder_config, &bin_len);
Track *t = NULL;
if(!strcmp(content, "video")) {
t = &input_video;
} else if(!strcmp(content, "audio")) {
t = &input_audio;
} else {
error("Unknown media content: '%s'", content);
}
if(t->codec) error("Double initialization of media '%s'", content);
t->codec = avcodec_find_decoder_by_name(codec);
t->ctx = avcodec_alloc_context3(t->codec);
if(!t->codec || !t->ctx)
error("Unknown %s decoder '%s'", content, codec);
t->ctx->time_base = (AVRational){1, 90};
t->ctx->extradata_size = decoder_config_len;
t->ctx->extradata = decoder_config;
if(avcodec_open2(t->ctx, t->codec, NULL) < 0)
error("failed to allocate %s decoder", content);
reply_atom("ready");
continue;
}
if(!strcmp(command, "init_output")) {
if(arity != 4) error("Must provide 4 arguments to init_output command");
char content[1024];
char codec[1024];
if(ei_decode_atom(buf, &idx, content) == -1) error("Must provide content as an atom");
if(ei_decode_atom(buf, &idx, codec) == -1) error("Must provide codec as an atom");
long track_id = -1;
if(ei_decode_long(buf, &idx, &track_id) == -1) error("track_id must be integer");
if(track_id < 1 || track_id > MAX_OUTPUT_TRACKS+1) error("track_id must be from 1 to %d", MAX_OUTPUT_TRACKS+1);
track_id--;
Track *t = NULL;
if(!strcmp(content, "audio")) {
t = &output_audio[out_audio_count++];
} else if(!strcmp(content, "video")) {
t = &output_video[out_video_count++];
} else {
error("invalid_content '%s'", content);
}
t->track_id = track_id;
t->codec = avcodec_find_encoder_by_name(codec);
t->ctx = avcodec_alloc_context3(t->codec);
if(!t->codec || !t->ctx) error("Unknown encoder '%s'", codec);
AVCodecContext* ctx = t->ctx;
AVDictionary *opts = NULL;
int options_count = 0;
if(ei_decode_list_header(buf, &idx, &options_count) < 0) error("options must be a proplist");
while(options_count > 0) {
int arity1 = 0;
int t,s;
ei_get_type(buf, &idx, &t, &s);
if(t == ERL_NIL_EXT) {
ei_skip_term(buf, &idx);
break;
}
if(ei_decode_tuple_header(buf, &idx, &arity1) < 0) error("options must be a proper proplist");
if(arity1 != 2) error("tuples in options proplist must be arity 2");
char key[MAXATOMLEN];
if(ei_decode_atom(buf, &idx, key) == 0) {
if(!strcmp(key, "width")) {
long w = 0;
if(ei_decode_long(buf, &idx, &w) < 0) error("width must be integer");
ctx->width = w;
continue;
}
if(!strcmp(key, "height")) {
long h = 0;
if(ei_decode_long(buf, &idx, &h) < 0) error("height must be integer");
ctx->height = h;
continue;
}
if(!strcmp(key, "bitrate")) {
long b = 0;
if(ei_decode_long(buf, &idx, &b) < 0) error("bitrate must be integer");
ctx->bit_rate = b;
continue;
}
if(!strcmp(key, "sample_rate")) {
long sr = 0;
if(ei_decode_long(buf, &idx, &sr) < 0) error("sample_rate must be integer");
ctx->sample_rate = sr;
continue;
}
if(!strcmp(key, "channels")) {
long ch = 0;
if(ei_decode_long(buf, &idx, &ch) < 0) error("channels must be integer");
ctx->channels = ch;
continue;
}
fprintf(stderr, "Unknown key: '%s'\r\n", key);
ei_skip_term(buf, &idx);
continue;
} else if(ei_decode_string(buf, &idx, key) == 0) {
char value[MAXATOMLEN];
if(ei_decode_string(buf, &idx, value) < 0) error("key-value must be strings");
av_dict_set(&opts, key, value, 0);
} else {
error("Invalid options proplist");
}
}
if(!strcmp(content, "video")) {
ctx->pix_fmt = AV_PIX_FMT_YUV420P;
}
if(!strcmp(content, "audio")) {
ctx->sample_fmt = AV_SAMPLE_FMT_S16;
ctx->profile = FF_PROFILE_AAC_MAIN;
}
ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
ctx->time_base = (AVRational){1,90};
if(avcodec_open2(ctx, t->codec, &opts) < 0) error("failed to allocate video encoder");
AVPacket config;
config.dts = config.pts = 0;
config.flags = CODEC_FLAG_GLOBAL_HEADER;
config.data = ctx->extradata;
config.size = ctx->extradata_size;
reply_avframe(&config, t->codec);
continue;
}
if(!strcmp(command, "video_frame")) {
idx = command_idx;
struct video_frame *fr = read_video_frame(buf, &idx);
AVPacket packet;
av_new_packet(&packet, fr->body.size);
memcpy(packet.data, fr->body.data, fr->body.size);
packet.size = fr->body.size;
packet.dts = fr->dts*90;
packet.pts = fr->pts*90;
packet.stream_index = fr->track_id;
// if(packet_size != pkt_size) error("internal error in reading frame body");
if(fr->content == frame_content_audio) {
if(!input_audio.ctx) error("input audio uninitialized");
AVFrame *decoded_frame = avcodec_alloc_frame();
int got_output = 0;
int ret = avcodec_decode_audio4(input_audio.ctx, decoded_frame, &got_output, &packet);
if(got_output) {
reply_atom("ok");
} else {
error("Got: %d, %d\r\n", ret, got_output);
}
free(fr);
continue;
}
if(fr->content == frame_content_video) {
if(!input_video.ctx) error("input video uninitialized");
AVFrame *decoded_frame = avcodec_alloc_frame();
int could_decode = 0;
int ret = avcodec_decode_video2(input_video.ctx, decoded_frame, &could_decode, &packet);
if(ret < 0) {
error("failed to decode video");
}
if(could_decode) {
decoded_frame->pts = av_frame_get_best_effort_timestamp(decoded_frame);
int sent_config = 0;
AVPacket pkt;
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
int could_encode = 0;
if(out_video_count <= 0) error("trying to transcode uninitialized video");
if(avcodec_encode_video2(output_video[0].ctx, &pkt, decoded_frame, &could_encode) != 0)
error("Failed to encode h264");
if(could_encode) {
if(dts_shift == AV_NOPTS_VALUE) {
dts_shift = -pkt.dts;
}
pkt.dts += dts_shift;
reply_avframe(&pkt, output_video[0].codec);
} else if(!sent_config) {
reply_atom("ok");
}
free(fr);
continue;
} else {
reply_atom("ok");
free(fr);
continue;
}
}
error("Unknown content");
}
// AVCodecContext
// AVPacket
// AVFrame
char *s = (char *)malloc(1024);
ei_s_print_term(&s, buf, &command_idx);
error("Unknown command: %s", s);
}
}
