vod_status_t
mp4_aes_ctr_init(
mp4_aes_ctr_state_t* state,
request_context_t* request_context,
u_char* key)
{
vod_pool_cleanup_t *cln;
state->request_context = request_context;
cln = vod_pool_cleanup_add(request_context->pool, 0);
if (cln == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"mp4_aes_ctr_init: vod_pool_cleanup_add failed");
return VOD_ALLOC_FAILED;
}
cln->handler = (vod_pool_cleanup_pt)mp4_aes_ctr_cleanup;
cln->data = state;
EVP_CIPHER_CTX_init(&state->cipher);
if (1 != EVP_EncryptInit_ex(&state->cipher, EVP_aes_128_ecb(), NULL, key, NULL))
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"mp4_aes_ctr_init: EVP_EncryptInit_ex failed");
return VOD_ALLOC_FAILED;
}
return VOD_OK;
}
vod_status_t
aes_cbc_encrypt_init(
aes_cbc_encrypt_context_t** context,
request_context_t* request_context,
write_callback_t callback,
void* callback_context,
const u_char* key,
const u_char* iv)
{
aes_cbc_encrypt_context_t* state;
vod_pool_cleanup_t *cln;
state = vod_alloc(request_context->pool, sizeof(*state));
if (state == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"aes_cbc_encrypt_init: vod_alloc failed");
return VOD_ALLOC_FAILED;
}
cln = vod_pool_cleanup_add(request_context->pool, 0);
if (cln == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"aes_cbc_encrypt_init: vod_pool_cleanup_add failed");
return VOD_ALLOC_FAILED;
}
cln->handler = (vod_pool_cleanup_pt)aes_cbc_encrypt_cleanup;
cln->data = state;
state->callback = callback;
state->callback_context = callback_context;
state->request_context = request_context;
EVP_CIPHER_CTX_init(&state->cipher);
if (1 != EVP_EncryptInit_ex(&state->cipher, EVP_aes_128_cbc(), NULL, key, iv))
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"aes_cbc_encrypt_init: EVP_EncryptInit_ex failed");
return VOD_ALLOC_FAILED;
}
*context = state;
return VOD_OK;
}
vod_status_t
sample_aes_avc_filter_init(
void** context,
request_context_t* request_context,
media_filter_write_t write_callback,
void* write_context,
u_char* key,
u_char* iv)
{
sample_aes_avc_filter_state_t* state;
vod_pool_cleanup_t *cln;
state = vod_alloc(request_context->pool, sizeof(*state));
if (state == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"sample_aes_avc_filter_init: vod_alloc failed");
return VOD_ALLOC_FAILED;
}
cln = vod_pool_cleanup_add(request_context->pool, 0);
if (cln == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"sample_aes_avc_filter_init: vod_pool_cleanup_add failed");
return VOD_ALLOC_FAILED;
}
cln->handler = (vod_pool_cleanup_pt)sample_aes_avc_cleanup;
cln->data = state;
state->request_context = request_context;
state->write_callback = write_callback;
state->write_context = write_context;
vod_memcpy(state->iv, iv, sizeof(state->iv));
vod_memcpy(state->key, key, sizeof(state->key));
state->encrypt = FALSE;
EVP_CIPHER_CTX_init(&state->cipher);
*context = state;
return VOD_OK;
}
void*
buffer_pool_alloc(request_context_t* request_context, buffer_pool_t* buffer_pool, size_t* buffer_size)
{
buffer_pool_cleanup_t* buf_cln;
vod_pool_cleanup_t* cln;
void* result;
if (buffer_pool == NULL)
{
return vod_alloc(request_context->pool, *buffer_size);
}
if (buffer_pool->head == NULL)
{
*buffer_size = buffer_pool->size;
return vod_alloc(request_context->pool, *buffer_size);
}
cln = vod_pool_cleanup_add(request_context->pool, sizeof(buffer_pool_cleanup_t));
if (cln == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"buffer_pool_alloc: vod_pool_cleanup_add failed");
return NULL;
}
result = buffer_pool->head;
buffer_pool->head = next_buffer(result);
cln->handler = buffer_pool_buffer_cleanup;
buf_cln = cln->data;
buf_cln->buffer = result;
buf_cln->buffer_pool = buffer_pool;
*buffer_size = buffer_pool->size;
return result;
}
vod_status_t
audio_filter_alloc_state(
request_context_t* request_context,
media_sequence_t* sequence,
media_clip_t* clip,
media_track_t* output_track,
size_t* cache_buffer_count,
void** result)
{
audio_filter_init_context_t init_context;
u_char filter_name[VOD_INT32_LEN + 1];
audio_filter_state_t* state;
vod_pool_cleanup_t *cln;
AVFilterInOut *outputs = NULL;
AVFilterInOut *inputs = NULL;
uint32_t initial_alloc_size;
vod_status_t rc;
int avrc;
if (!initialized)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: module failed to initialize successfully");
return VOD_UNEXPECTED;
}
// get the source count and graph desc size
init_context.request_context = request_context;
init_context.graph_desc_size = 0;
init_context.source_count = 0;
init_context.output_frame_count = 0;
rc = audio_filter_walk_filters_prepare_init(&init_context, &clip, 100, 100);
if (rc != VOD_OK)
{
return rc;
}
if (clip == NULL || init_context.source_count <= 0)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: unexpected - no sources found");
return VOD_UNEXPECTED;
}
if (clip->type == MEDIA_CLIP_SOURCE)
{
// got left with a source, following a mix of a single source, nothing to do
return VOD_OK;
}
if (init_context.output_frame_count > MAX_FRAME_COUNT)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: expected output frame count %uD too big", init_context.output_frame_count);
return VOD_BAD_REQUEST;
}
// allocate the state
state = vod_alloc(request_context->pool, sizeof(*state));
if (state == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_alloc failed");
return VOD_ALLOC_FAILED;
}
vod_memzero(state, sizeof(*state));
// add to the cleanup pool
cln = vod_pool_cleanup_add(request_context->pool, 0);
if (cln == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_pool_cleanup_add failed");
return VOD_ALLOC_FAILED;
}
cln->handler = audio_filter_free_state;
cln->data = state;
// allocate the filter graph
state->filter_graph = avfilter_graph_alloc();
if (state->filter_graph == NULL)
{
vod_log_error(VOD_LOG_ERR, state->request_context->log, 0,
"audio_filter_alloc_state: avfilter_graph_alloc failed");
return VOD_ALLOC_FAILED;
}
// allocate the graph desc and sources
init_context.graph_desc = vod_alloc(request_context->pool, init_context.graph_desc_size +
sizeof(state->sources[0]) * init_context.source_count);
if (init_context.graph_desc == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_alloc failed (1)");
return VOD_ALLOC_FAILED;
}
state->sources = (void*)(init_context.graph_desc + init_context.graph_desc_size);
state->sources_end = state->sources + init_context.source_count;
vod_memzero(state->sources, (u_char*)state->sources_end - (u_char*)state->sources);
// initialize the sources and the graph description
init_context.filter_graph = state->filter_graph;
init_context.outputs = &outputs;
init_context.cur_source = state->sources;
init_context.graph_desc_pos = init_context.graph_desc;
init_context.max_frame_size = 0;
init_context.cache_slot_id = 0;
rc = audio_filter_init_sources_and_graph_desc(&init_context, clip);
if (rc != VOD_OK)
{
goto end;
}
*init_context.graph_desc_pos = '\0';
// initialize the sink
vod_sprintf(filter_name, "%uD%Z", clip->id);
rc = audio_filter_init_sink(
request_context,
state->filter_graph,
output_track,
filter_name,
&state->sink,
&inputs);
if (rc != VOD_OK)
{
goto end;
}
// parse the graph description
avrc = avfilter_graph_parse_ptr(state->filter_graph, (char*)init_context.graph_desc, &inputs, &outputs, NULL);
if (avrc < 0)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: avfilter_graph_parse_ptr failed %d", avrc);
rc = VOD_UNEXPECTED;
goto end;
}
// validate and configure the graph
avrc = avfilter_graph_config(state->filter_graph, NULL);
if (avrc < 0)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: avfilter_graph_config failed %d", avrc);
rc = VOD_UNEXPECTED;
goto end;
}
// set the buffer sink frame size
if ((state->sink.encoder->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE) == 0)
{
av_buffersink_set_frame_size(state->sink.buffer_sink, state->sink.encoder->frame_size);
}
// allocate frames
state->decoded_frame = av_frame_alloc();
if (state->decoded_frame == NULL)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: av_frame_alloc failed (1)");
return VOD_ALLOC_FAILED;
}
state->filtered_frame = av_frame_alloc();
if (state->filtered_frame == NULL)
{
vod_log_error(VOD_LOG_ERR, request_context->log, 0,
"audio_filter_alloc_state: av_frame_alloc failed (2)");
return VOD_ALLOC_FAILED;
}
// allocate the frame buffer
state->frame_buffer = vod_alloc(request_context->pool, init_context.max_frame_size);
if (state->frame_buffer == NULL)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_alloc failed (2)");
rc = VOD_ALLOC_FAILED;
goto end;
}
// initialize the output arrays
initial_alloc_size = init_context.output_frame_count + 10;
if (vod_array_init(&state->frames_array, request_context->pool, initial_alloc_size, sizeof(input_frame_t)) != VOD_OK)
{
vod_log_debug0(VOD_LOG_DEBUG_LEVEL, request_context->log, 0,
"audio_filter_alloc_state: vod_array_init failed (1)");
return VOD_ALLOC_FAILED;
}
state->request_context = request_context;
state->sequence = sequence;
state->output = output_track;
state->cur_frame_pos = 0;
state->first_time = TRUE;
state->cur_source = NULL;
*cache_buffer_count = init_context.cache_slot_id;
*result = state;
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return rc;
}