/**
* Free and wipe memory associated with a cipher_ctx
*/
static void cipher_ctx_free(cipher_ctx **iCtx) {
cipher_ctx *ctx = *iCtx;
CODEC_TRACE(("cipher_ctx_free: entered iCtx=%d\n", iCtx));
codec_free(ctx->key, ctx->key_sz);
codec_free(ctx->pass, ctx->pass_sz);
codec_free(ctx, sizeof(cipher_ctx));
}
static int stream_es_release(play_para_t *p_para)
{
int r = -1;
if (p_para->acodec) {
r = codec_close(p_para->acodec);
if (r < 0) {
log_error("[stream_es_release]close acodec failed, r= %x\n", r);
return r;
}
codec_free(p_para->acodec);
p_para->acodec = NULL;
}
if (p_para->vcodec) {
r = codec_close(p_para->vcodec);
if (r < 0) {
log_error("[stream_es_release]close vcodec failed, r= %x\n", r);
return r;
}
codec_free(p_para->vcodec);
p_para->vcodec = NULL;
}
if (p_para->scodec) {
r = codec_close(p_para->scodec);
if (r < 0) {
log_error("[stream_es_release]close scodec failed, r= %x\n", r);
return r;
}
codec_free(p_para->scodec);
p_para->scodec = NULL;
}
p_para->codec = NULL;
return 0;
}
/**
* Free and wipe memory associated with a cipher_ctx, including the allocated
* read_ctx and write_ctx.
*/
static void codec_ctx_free(codec_ctx **iCtx) {
codec_ctx *ctx = *iCtx;
CODEC_TRACE(("codec_ctx_free: entered iCtx=%d\n", iCtx));
codec_free(ctx->kdf_salt, ctx->kdf_salt_sz);
codec_free(ctx->buffer, 0);
cipher_ctx_free(&ctx->read_ctx);
cipher_ctx_free(&ctx->write_ctx);
codec_free(ctx, sizeof(codec_ctx));
}
static int stream_video_init(play_para_t *p_para)
{
int ret = -1;
v_stream_info_t *vinfo=&p_para->vstream_info;
codec_para_t *codec ;
codec=codec_alloc();
if(!codec)
return PLAYER_EMPTY_P;
MEMSET(codec, 0, sizeof(codec_para_t));
if (codec_init_cntl(codec) != 0)
goto error1;
if(vinfo->has_video)
{
codec->has_video = 1;
codec->video_type = vinfo->video_format;
codec->video_pid = vinfo->video_pid;
}
codec->stream_type= stream_type_convert(p_para->stream_type, codec->has_video, codec->has_audio);
ret = codec_init(codec);
if(ret != 0)
goto error1;
p_para->vcodec = codec;
return PLAYER_SUCCESS;
error1:
log_print("[video]codec_init failed!ret=%x stream_type=%d\n",ret,codec->stream_type);
codec_free(codec);
return DECODER_INIT_FAILED;
}
static int stream_video_init(play_para_t *p_para)
{
int ret = CODEC_ERROR_NONE;
v_stream_info_t *vinfo = &p_para->vstream_info;
codec_para_t *codec ;
codec = codec_alloc();
if (!codec) {
return PLAYER_EMPTY_P;
}
MEMSET(codec, 0, sizeof(codec_para_t));
if (vinfo->has_video) {
codec->has_video = 1;
codec->video_type = vinfo->video_format;
codec->video_pid = vinfo->video_pid;
}
codec->stream_type = stream_type_convert(p_para->stream_type, codec->has_video, codec->has_audio);
codec->noblock = !!p_para->buffering_enable;
ret = codec_init(codec);
if (ret != CODEC_ERROR_NONE) {
if (ret != CODEC_OPEN_HANDLE_FAILED) {
codec_close(codec);
}
goto error1;
}
p_para->vcodec = codec;
return PLAYER_SUCCESS;
error1:
log_print("[video]codec_init failed!ret=%x stream_type=%d\n", ret, codec->stream_type);
codec_free(codec);
return DECODER_INIT_FAILED;
}
void* codec_realloc(void* ptr, size_t size)
{
void* x;
x = codec_malloc(size);
ci->memcpy(x, ptr, size);
codec_free(ptr);
return(x);
}
static int stream_ts_release(play_para_t *p_para)
{
if (p_para->codec) {
codec_close(p_para->codec);
codec_free(p_para->codec);
}
p_para->codec = NULL;
return 0;
}
static int stream_audio_release(play_para_t *p_para)
{
if (p_para->acodec) {
codec_close(p_para->acodec);
codec_free(p_para->acodec);
}
p_para->acodec = NULL;
p_para->codec = NULL;
return PLAYER_SUCCESS;
}
static int stream_video_release(play_para_t *p_para)
{
if(p_para->vcodec)
{
codec_close_cntl(p_para->vcodec);
codec_close(p_para->vcodec);
codec_free(p_para->vcodec);
}
p_para->vcodec=NULL;
return 0;
}
/**
* Set the raw password / key data for a cipher context
*
* returns SQLITE_OK if assignment was successfull
* returns SQLITE_NOMEM if an error occured allocating memory
* returns SQLITE_ERROR if the key couldn't be set because the pass was null or size was zero
*/
static int cipher_ctx_set_pass(cipher_ctx *ctx, const void *zKey, int nKey) {
codec_free(ctx->pass, ctx->pass_sz);
ctx->pass_sz = nKey;
if(zKey && nKey) {
ctx->pass = sqlite3Malloc(nKey);
if(ctx->pass == NULL) return SQLITE_NOMEM;
memcpy(ctx->pass, zKey, nKey);
return SQLITE_OK;
}
return SQLITE_ERROR;
}
static int stream_ts_release(play_para_t *p_para)
{
if (p_para->codec) {
if (p_para->codec->audio_utils_handle >= 0) {
codec_set_audio_resample_ena(p_para->codec, 0);
}
codec_close(p_para->codec);
codec_free(p_para->codec);
}
p_para->codec = NULL;
return 0;
}
/**
* Copy one cipher_ctx to another. For instance, assuming that read_ctx is a
* fully initialized context, you could copy it to write_ctx and all yet data
* and pass information across
*
* returns SQLITE_OK if initialization was successful
* returns SQLITE_NOMEM if an error occured allocating memory
*/
static int cipher_ctx_copy(cipher_ctx *target, cipher_ctx *source) {
void *key = target->key;
CODEC_TRACE(("cipher_ctx_copy: entered target=%d, source=%d\n", target, source));
codec_free(target->pass, target->pass_sz);
memcpy(target, source, sizeof(cipher_ctx));
target->key = key; //restore pointer to previously allocated key data
memcpy(target->key, source->key, EVP_MAX_KEY_LENGTH);
target->pass = sqlite3Malloc(source->pass_sz);
if(target->pass == NULL) return SQLITE_NOMEM;
memcpy(target->pass, source->pass, source->pass_sz);
return SQLITE_OK;
}
static int codec_release(codec_para_t *codec)
{
int r = CODEC_ERROR_NONE;
if (codec) {
r = codec_close(codec);
if (r < 0) {
log_error("[stream_es_init]close codec failed, r= %x\n", r);
return r;
}
codec_free(codec);
codec = NULL;
}
return r;
}
static int print_var_definition(parser_t *p, int comp, const char *varname,
const char *buf, size_t bufsz)
{
codec_t *zip = NULL;
io_t *ios = NULL;
int rc, i;
unsigned char c;
dbg_err_if(p == NULL);
dbg_err_if(varname == NULL);
dbg_err_if(buf == NULL);
/* create an io_t around the HTML block */
dbg_err_if(io_mem_create((char*)buf, bufsz, 0, &ios));
#ifdef HAVE_LIBZ
/* if compression is enabled zip the data block */
if(comp)
{
/* apply a gzip codec */
dbg_err_if(codec_gzip_create(GZIP_COMPRESS, &zip));
dbg_err_if(io_codec_add_tail(ios, zip));
zip = NULL; /* io_free() will free the codec */
}
#endif
io_printf(p->out, "static const char %s[] = {\n", varname);
for(i = 1; (rc = io_getc(ios, (char*)&c)) > 0; ++i)
{
io_printf(p->out, "0x%02X, ", c);
if(i % 12 == 0)
io_printf(p->out, "\n");
}
dbg_err_if(rc < 0); /* input stream error */
io_printf(p->out, "};\n");
io_free(ios);
return 0;
err:
if(zip)
codec_free(zip);
if(ios)
io_free(ios);
return ~0;
}
static int stream_es_init(play_para_t *p_para)
{
v_stream_info_t *vinfo = &p_para->vstream_info;
a_stream_info_t *ainfo = &p_para->astream_info;
s_stream_info_t *sinfo = &p_para->sstream_info;
codec_para_t *v_codec = NULL, *a_codec = NULL, *s_codec = NULL;
int ret = CODEC_ERROR_NONE;
if (vinfo->has_video) {
v_codec = codec_alloc();
if (!v_codec) {
return PLAYER_EMPTY_P;
}
MEMSET(v_codec, 0, sizeof(codec_para_t));
vcodec_info_init(p_para, v_codec);
ret = codec_init(v_codec);
if (ret != CODEC_ERROR_NONE) {
if (ret != CODEC_OPEN_HANDLE_FAILED) {
codec_close(v_codec);
}
goto error1;
}
p_para->vcodec = v_codec;
}
if (ainfo->has_audio) {
a_codec = codec_alloc();
if (!a_codec) {
if (vinfo->has_video && v_codec) {
codec_release(v_codec);
}
return PLAYER_EMPTY_P;
}
MEMSET(a_codec, 0, sizeof(codec_para_t));
acodec_info_init(p_para, a_codec);
ret = codec_init(a_codec);
if (ret != CODEC_ERROR_NONE) {
if (ret != CODEC_OPEN_HANDLE_FAILED) {
codec_close(a_codec);
}
goto error2;
}
p_para->acodec = a_codec;
}
if (!p_para->vcodec && !p_para->acodec) {
log_print("[stream_es_init] no audio and no video codec init!\n");
return DECODER_INIT_FAILED;
}
if (sinfo->has_sub) {
s_codec = codec_alloc();
if (!s_codec) {
if (vinfo->has_video && v_codec) {
codec_release(v_codec);
}
if (ainfo->has_audio && a_codec) {
codec_release(a_codec);
}
return PLAYER_EMPTY_P;
}
MEMSET(s_codec, 0, sizeof(codec_para_t));
scodec_info_init(p_para, s_codec);
if (codec_init(s_codec) != 0) {
goto error3;
}
p_para->scodec = s_codec;
}
if (v_codec) {
codec_set_freerun_mode(v_codec, p_para->playctrl_info.freerun_mode);
codec_set_vsync_upint(v_codec, p_para->playctrl_info.vsync_upint);
}
return PLAYER_SUCCESS;
error1:
codec_free(v_codec);
return DECODER_INIT_FAILED;
error2:
if (vinfo->has_video && v_codec) {
codec_release(v_codec);
}
codec_free(a_codec);
return DECODER_INIT_FAILED;
error3:
if (vinfo->has_video && v_codec) {
codec_release(v_codec);
}
if (ainfo->has_audio && a_codec) {
codec_release(a_codec);
}
codec_free(s_codec);
return DECODER_INIT_FAILED;
}
static int stream_audio_init(play_para_t *p_para)
{
int ret = CODEC_ERROR_NONE;
a_stream_info_t *ainfo = &p_para->astream_info;
codec_para_t *codec ;
AVCodecContext *pCodecCtx;
codec = codec_alloc();
if (!codec) {
return PLAYER_EMPTY_P;
}
MEMSET(codec, 0, sizeof(codec_para_t));
codec->noblock = !!p_para->buffering_enable;
if (ainfo->has_audio) {
codec->has_audio = 1;
codec->audio_type = ainfo->audio_format;
codec->audio_pid = ainfo->audio_pid;
codec->audio_channels = ainfo->audio_channel;
codec->audio_samplerate = ainfo->audio_samplerate;
codec->switch_audio_flag = 0;
}
codec->stream_type = stream_type_convert(p_para->stream_type, codec->has_video, codec->has_audio);
pCodecCtx = p_para->pFormatCtx->streams[p_para->astream_info.audio_index]->codec;
/*if ((codec->audio_type == AFORMAT_ADPCM) || (codec->audio_type == AFORMAT_WMA) || (codec->audio_type == AFORMAT_WMAPRO) || (codec->audio_type == AFORMAT_PCM_S16BE) || (codec->audio_type == AFORMAT_PCM_S16LE) || (codec->audio_type == AFORMAT_PCM_U8) \
||(codec->audio_type == AFORMAT_AMR)) {*/
if (IS_AUIDO_NEED_EXT_INFO(codec->audio_type)) {
codec->audio_info.bitrate = pCodecCtx->sample_fmt;
codec->audio_info.sample_rate = pCodecCtx->sample_rate;
codec->audio_info.channels = pCodecCtx->channels;
codec->audio_info.codec_id = pCodecCtx->codec_id;
codec->audio_info.block_align = pCodecCtx->block_align;
codec->audio_info.extradata_size = pCodecCtx->extradata_size;
if (codec->audio_info.extradata_size > 0) {
if (codec->audio_info.extradata_size > AUDIO_EXTRA_DATA_SIZE) {
log_print("[%s:%d],extra data size exceed max extra data buffer,cut it to max buffer size ", __FUNCTION__, __LINE__);
codec->audio_info.extradata_size = AUDIO_EXTRA_DATA_SIZE;
}
memcpy((char*)codec->audio_info.extradata, pCodecCtx->extradata, codec->audio_info.extradata_size);
}
codec->audio_info.valid = 1;
log_print("[%s:%d]block_align=%d,,sample_rate=%d,,channels=%d,,bitrate=%d,,codec_id=%d,extra size %d,SessionID=%d\n", __FUNCTION__, __LINE__, codec->audio_info.block_align,
codec->audio_info.sample_rate, codec->audio_info.channels , codec->audio_info.extradata_size, codec->audio_info.codec_id, codec->audio_info.extradata_size, codec->SessionID);
}
codec->SessionID = p_para->start_param->SessionID;
if(IS_AUDIO_NOT_SUPPORTED_BY_AUDIODSP(codec->audio_type,pCodecCtx)){
codec->dspdec_not_supported = 1;
log_print("main profile aac not supported by dsp decoder,so set dspdec_not_supported flag\n");
}
ret = codec_init(codec);
if (ret != CODEC_ERROR_NONE) {
if (ret != CODEC_OPEN_HANDLE_FAILED) {
codec_close(codec);
}
goto error1;
}
log_print("[%s:%d]codec init finished! mute_on:%d\n", __FUNCTION__, __LINE__, p_para->playctrl_info.audio_mute);
/*ret = codec_set_mute(codec, p_para->playctrl_info.audio_mute);
if (ret != CODEC_ERROR_NONE) {
codec_close(codec);
goto error1;
}*/
p_para->acodec = codec;
return PLAYER_SUCCESS;
error1:
log_print("[audio]codec_init failed!ret=%x stream_type=%d\n", ret, codec->stream_type);
codec_free(codec);
return DECODER_INIT_FAILED;
}
static int stream_ts_init(play_para_t *p_para)
{
v_stream_info_t *vinfo = &p_para->vstream_info;
a_stream_info_t *ainfo = &p_para->astream_info;
s_stream_info_t *sinfo = &p_para->sstream_info;
AVCodecContext *pCodecCtx;
codec_para_t *codec ;
int ret = CODEC_ERROR_NONE;
codec = codec_alloc();
if (!codec) {
return PLAYER_EMPTY_P;
}
MEMSET(codec, 0, sizeof(codec_para_t));
codec->noblock = !!p_para->buffering_enable;
if (vinfo->has_video) {
codec->has_video = 1;
codec->video_type = vinfo->video_format;
codec->video_pid = vinfo->video_pid;
if ((codec->video_type == VFORMAT_H264) || (codec->video_type == VFORMAT_H264MVC)) {
codec->am_sysinfo.format = vinfo->video_codec_type;
codec->am_sysinfo.width = vinfo->video_width;
codec->am_sysinfo.height = vinfo->video_height;
} else if (codec->video_type == VFORMAT_VC1) {
codec->am_sysinfo.format = vinfo->video_codec_type;
codec->am_sysinfo.width = vinfo->video_width;
codec->am_sysinfo.height = vinfo->video_height;
codec->am_sysinfo.rate = vinfo->video_rate;
}
}
if (ainfo->has_audio) {
codec->has_audio = 1;
codec->audio_type = ainfo->audio_format;
codec->audio_pid = ainfo->audio_pid;
codec->audio_channels = ainfo->audio_channel;
codec->audio_samplerate = ainfo->audio_samplerate;
pCodecCtx = p_para->pFormatCtx->streams[p_para->astream_info.audio_index]->codec;
/*if ((codec->audio_type == AFORMAT_ADPCM) || (codec->audio_type == AFORMAT_WMA)
|| (codec->audio_type == AFORMAT_WMAPRO) || (codec->audio_type == AFORMAT_PCM_S16BE)
|| (codec->audio_type == AFORMAT_PCM_S16LE) || (codec->audio_type == AFORMAT_PCM_U8)
|| (codec->audio_type == AFORMAT_PCM_BLURAY)||(codec->audio_type == AFORMAT_AMR)) {*/
if(IS_AUIDO_NEED_EXT_INFO(codec->audio_type)){
codec->audio_info.bitrate = pCodecCtx->sample_fmt;
codec->audio_info.sample_rate = pCodecCtx->sample_rate;
codec->audio_info.channels = pCodecCtx->channels;
codec->audio_info.codec_id = pCodecCtx->codec_id;
codec->audio_info.block_align = pCodecCtx->block_align;
codec->audio_info.extradata_size = pCodecCtx->extradata_size;
if (codec->audio_info.extradata_size > 0) {
if(codec->audio_info.extradata_size > AUDIO_EXTRA_DATA_SIZE)
{
log_print("[%s:%d],extra data size exceed max extra data buffer,cut it to max buffer size ", __FUNCTION__, __LINE__);
codec->audio_info.extradata_size = AUDIO_EXTRA_DATA_SIZE;
}
memcpy((char*)codec->audio_info.extradata, pCodecCtx->extradata, codec->audio_info.extradata_size);
}
codec->audio_info.valid = 1;
}
codec->avsync_threshold = p_para->start_param->avsync_threshold;
log_print("[%s:%d]audio bitrate=%d sample_rate=%d channels=%d codec_id=%x block_align=%d,extra size\n",
__FUNCTION__, __LINE__, codec->audio_info.bitrate, codec->audio_info.sample_rate, codec->audio_info.channels,
codec->audio_info.codec_id, codec->audio_info.block_align,codec->audio_info.extradata_size);
}
if (sinfo->has_sub) {
codec->has_sub = 1;
codec->sub_pid = sinfo->sub_pid;
codec->sub_type = sinfo->sub_type;
}
codec->stream_type = stream_type_convert(p_para->stream_type, codec->has_video, codec->has_audio);
codec->packet_size = p_para->pFormatCtx->orig_packet_size;
ret = codec_init(codec);
if (ret != CODEC_ERROR_NONE) {
if (ret != CODEC_OPEN_HANDLE_FAILED) {
codec_close(codec);
}
goto error1;
}
p_para->codec = codec;
return PLAYER_SUCCESS;
error1:
log_print("[ts]codec_init failed!\n");
codec_free(codec);
return DECODER_INIT_FAILED;
}
