/**
* Open an output file and the required encoder.
* Also set some basic encoder parameters.
* Some of these parameters are based on the input file's parameters.
*/
static int open_output_file(const char *filename,
AVCodecContext *input_codec_context,
AVFormatContext **output_format_context,
AVCodecContext **output_codec_context)
{
AVIOContext *output_io_context = NULL;
AVStream *stream = NULL;
AVCodec *output_codec = NULL;
int error;
/** Open the output file to write to it. */
if ((error = avio_open(&output_io_context, filename, AVIO_FLAG_WRITE)) < 0) {
fprintf(stderr, "Could not open output file '%s' (error '%s')\n", filename, get_error_text(error));
return error;
}
/** Create a new format context for the output container format. */
if (!(*output_format_context = avformat_alloc_context())) {
fprintf(stderr, "Could not allocate output format context\n");
return AVERROR(ENOMEM);
}
/** Associate the output file (pointer) with the container format context. */
(*output_format_context)->pb = output_io_context;
/** Guess the desired container format based on the file extension. */
if (!((*output_format_context)->oformat = av_guess_format(NULL, filename, NULL))) {
fprintf(stderr, "Could not find output file format\n");
goto cleanup;
}
av_strlcpy((*output_format_context)->filename, filename, sizeof((*output_format_context)->filename));
/** Find the encoder to be used by its name. */
if (!(output_codec = avcodec_find_encoder(AV_CODEC_ID_AAC))) {
fprintf(stderr, "Could not find an AAC encoder.\n");
goto cleanup;
}
/** Create a new audio stream in the output file container. */
if (!(stream = avformat_new_stream(*output_format_context, output_codec))) {
fprintf(stderr, "Could not create new stream\n");
error = AVERROR(ENOMEM);
goto cleanup;
}
/** Save the encoder context for easier access later. */
*output_codec_context = stream->codec;
/**
* Set the basic encoder parameters.
* The input file's sample rate is used to avoid a sample rate conversion.
*/
(*output_codec_context)->channels = 1;
(*output_codec_context)->channel_layout = av_get_default_channel_layout(1);
(*output_codec_context)->sample_rate = input_codec_context->sample_rate;
(*output_codec_context)->sample_fmt = output_codec->sample_fmts[0];
(*output_codec_context)->bit_rate = output_bit_rate;
/** Set the sample rate for the container. */
stream->time_base.den = input_codec_context->sample_rate;
stream->time_base.num = 1;
/**
* Some container formats (like MP4) require global headers to be present
* Mark the encoder so that it behaves accordingly.
*/
if ((*output_format_context)->oformat->flags & AVFMT_GLOBALHEADER)
(*output_codec_context)->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
/** Open the encoder for the audio stream to use it later. */
if ((error = avcodec_open2(*output_codec_context, output_codec, NULL)) < 0) {
fprintf(stderr, "Could not open output codec (error '%s')\n", get_error_text(error));
goto cleanup;
}
return 0;
cleanup:
avio_closep(&(*output_format_context)->pb);
avformat_free_context(*output_format_context);
*output_format_context = NULL;
return error < 0 ? error : AVERROR_EXIT;
}
NET_API_STATUS
RetrieveList(LPTSTR wcMachineName,
LPTSTR wcTestedTransport,
LPVOID *ppvList,
LPDWORD pdwEntriesInList,
LPDWORD pdwTotalEntries,
DWORD Flag,
LPTSTR wcDomain,
LPDWORD pdwHandle,
BOOL ErrMsg
)
{
DWORD dwStartTime;
DWORD dwEndTime;
TCHAR wcTmpName[CNSLASHLEN+1];
NET_API_STATUS Status;
if(_wcsnicmp(wcMachineName, L"\\\\", 2) != 0) {
wcscpy(wcTmpName, L"\\\\");
wcscat(wcTmpName, wcMachineName);
} else {
wcscpy(wcTmpName, wcMachineName);
}
dwStartTime = GetTickCount();
Status = RxNetServerEnum(wcTmpName,
wcTestedTransport,
101,
(LPBYTE *)ppvList,
0xffffffff,
pdwEntriesInList,
pdwTotalEntries,
Flag,
wcDomain,
NULL
);
dwEndTime = GetTickCount();
if(ErrMsg){
if (Status != NERR_Success) {
sprintf(PrintBuf,"\nERROR[ER%ld]:Unable to retrieve List from %s ", ++ERRCOUNT, UnicodeToPrintfString(wcTmpName));
PrintString(TOALL, PrintBuf);
sprintf(PrintBuf,"on transport %s with Flag %lx. \nError: %s (%ld milliseconds)\n", UnicodeToPrintfString(wcTestedTransport), Flag, get_error_text(Status), dwEndTime - dwStartTime);
PrintString(TOALL, PrintBuf);
// if (Status != ERROR_MORE_DATA) {
// exit(1);
// }
} else {
sprintf(PrintBuf,"\nINFO:Retrieved List from %s ", UnicodeToPrintfString(wcTmpName));
PrintString(TOSCREENANDLOG, PrintBuf);
sprintf(PrintBuf,"on transport %s with Flag %lx: (%ld milliseconds).", UnicodeToPrintfString(wcTestedTransport), Flag, dwEndTime - dwStartTime);
PrintString(TOSCREENANDLOG, PrintBuf);
}
}
return Status;
}
void spawner_new_c::json_report(runner *runner_instance,
rapidjson::PrettyWriter<rapidjson::StringBuffer, rapidjson::UTF16<> > &writer) {
writer.StartObject();
//for {
report_class runner_report = runner_instance->get_report();
options_class runner_options = runner_instance->get_options();
//temporary
#define rapidjson_write(x) (writer.String(a2w(x)))
rapidjson_write("Application");
rapidjson_write(runner_report.application_name.c_str());
rapidjson_write("Arguments");
writer.StartArray();
for (size_t i = 0; i < runner_options.get_arguments_count(); ++i) {
rapidjson_write(runner_options.get_argument(i).c_str());
}
writer.EndArray();
rapidjson_write("Limit");
writer.StartObject();
restrictions_class runner_restrictions = ((secure_runner*)runner_instance)->get_restrictions();
struct {
const char *field;
unit_t unit;
degrees_enum degree;
restriction_kind_t restriction;
} restriction_items[] = {
{ "Time", unit_time_second, degree_micro, restriction_processor_time_limit },
{ "WallClockTime", unit_time_second, degree_micro, restriction_user_time_limit },
{ "Memory", unit_memory_byte, degree_default, restriction_memory_limit },
{ "SecurityLevel", unit_no_unit, degree_default, restriction_security_limit },
{ "IOBytes", unit_memory_byte, degree_default, restriction_write_limit },
{ "IdlenessTime", unit_time_second, degree_micro, restriction_idle_time_limit },
{ "IdlenessProcessorLoad", unit_no_unit, degree_centi, restriction_load_ratio },
{ NULL, unit_no_unit, degree_default, restriction_max },
};
for (int i = 0; restriction_items[i].field; ++i) {
if (runner_restrictions[restriction_items[i].restriction] == restriction_no_limit) {
continue;
}
rapidjson_write(restriction_items[i].field);
if (restriction_items[i].degree == degree_default) {
writer.Uint64(runner_restrictions[restriction_items[i].restriction]);
}
else {
writer.Double((double)convert(
value_t(restriction_items[i].unit, restriction_items[i].degree),
value_t(restriction_items[i].unit),
(long double)runner_restrictions[restriction_items[i].restriction]
));
}
}
writer.EndObject();
rapidjson_write("Options");
writer.StartObject();
rapidjson_write("SearchInPath");
writer.Bool(runner_options.use_cmd);
writer.EndObject();
rapidjson_write("Result");
writer.StartObject();
struct {
const char *field;
uint64_t value;
unit_t unit;
degrees_enum degree;
} result_items[] = {
{ "Time", runner_report.processor_time, unit_time_second, degree_micro },
{ "WallClockTime", runner_report.user_time, unit_time_second, degree_micro },
{ "Memory", runner_report.peak_memory_used, unit_memory_byte, degree_default },
{ "BytesWritten", runner_report.write_transfer_count, unit_memory_byte, degree_default },
{ "KernelTime", runner_report.kernel_time, unit_time_second, degree_micro },
{ "ProcessorLoad", (uint64_t)(runner_report.load_ratio * 100), unit_no_unit, degree_centi },
{ NULL, 0, unit_no_unit, degree_default },
};
for (int i = 0; result_items[i].field; ++i) {
rapidjson_write(result_items[i].field);
if (result_items[i].degree == degree_default) {
writer.Uint64(result_items[i].value);
}
else {
writer.Double((double)convert(
value_t(result_items[i].unit, result_items[i].degree),
value_t(result_items[i].unit),
(long double)result_items[i].value
));
}
}
rapidjson_write("WorkingDirectory");
rapidjson_write(runner_report.working_directory.c_str());
writer.EndObject();
rapidjson_write("StdOut");
writer.StartArray();
for (uint i = 0; i < runner_options.stdoutput.size(); ++i) {
rapidjson_write(runner_options.stdoutput[i].c_str());
}
writer.EndArray();
rapidjson_write("StdErr");
writer.StartArray();
for (uint i = 0; i < runner_options.stderror.size(); ++i) {
rapidjson_write(runner_options.stderror[i].c_str());
}
writer.EndArray();
rapidjson_write("StdIn");
writer.StartArray();
for (uint i = 0; i < runner_options.stdinput.size(); ++i) {
rapidjson_write(runner_options.stdinput[i].c_str());
}
writer.EndArray();
rapidjson_write("CreateProcessMethod");
rapidjson_write(options.login == "" ? "CreateProcess" : "WithLogon");
rapidjson_write("UserName");
writer.String(runner_report.login.c_str());
rapidjson_write("TerminateReason");
rapidjson_write(get_terminate_reason(runner_report.terminate_reason).c_str());
rapidjson_write("ExitCode");
writer.Uint(runner_report.exit_code);
rapidjson_write("ExitStatus");
rapidjson_write(ExtractExitStatus(runner_report).c_str());
rapidjson_write("SpawnerError");
writer.StartArray();
std::vector<std::string> errors;
errors.push_back(get_error_text());
for (auto& error : errors) {
rapidjson_write(error.c_str());
}
writer.EndArray();
writer.EndObject();
}
int load_file(char* path, file_t* file)
{
int error;
file->path = (char*)malloc(strlen(path)+1);
strcpy(file->path,path);
file->format_context = NULL;
if(avformat_open_input(&(file->format_context), file->path, NULL, NULL) < 0)
{
free(file->path);
return -1;
}
if(avformat_find_stream_info(file->format_context, NULL) < 0)
{
free(file->path);
avformat_close_input(&file->format_context);
return -1;
}
int stream_no = av_find_best_stream(file->format_context,AVMEDIA_TYPE_AUDIO,-1,-1,NULL,0);
if(stream_no < 0)
{
free(file->path);
avformat_close_input(&file->format_context);
return -1;
}
file->stream = file->format_context->streams[stream_no];
if(!(file->codec = avcodec_find_decoder(file->stream->codec->codec_id)))
{
fprintf(stderr, "Could not find input codec\n");
free(file->path);
avformat_close_input(&file->format_context);
return -1;
}
if((error = avcodec_open2(file->stream->codec, file->codec, NULL)) < 0)
{
fprintf(stderr, "Could not open input codec (error '%s')\n",
get_error_text(error));
free(file->path);
avformat_close_input(&file->format_context);
return -1;
}
file->codec_context = file->stream->codec;
file->resample_context = avresample_alloc_context();
av_opt_set_int(file->resample_context, "in_channel_layout", file->codec_context->channel_layout,0);
av_opt_set_int(file->resample_context, "out_channel_layout", file->codec_context->channel_layout,0);
av_opt_set_int(file->resample_context, "in_sample_rate", file->codec_context->sample_rate, 0);
av_opt_set_int(file->resample_context, "out_sample_rate", file->codec_context->sample_rate, 0);
av_opt_set_int(file->resample_context, "in_sample_fmt", file->codec_context->sample_fmt, 0);
av_opt_set_int(file->resample_context, "out_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);
avresample_open(file->resample_context);
return 0;
}
static ngx_int_t
ngx_http_tnt_send_reply(ngx_http_request_t *r,
ngx_http_upstream_t *u,
ngx_http_tnt_ctx_t *ctx)
{
tp_transcode_t tc;
ngx_int_t rc;
ngx_http_tnt_loc_conf_t *tlcf;
ngx_buf_t *output;
size_t output_size;
tlcf = ngx_http_get_module_loc_conf(r, ngx_http_tnt_module);
output_size =
(ctx->tp_cache->end - ctx->tp_cache->start + ngx_http_tnt_overhead())
* tlcf->out_multiplier;
output = ngx_http_tnt_create_mem_buf(r, u, output_size);
if (output == NULL) {
return NGX_ERROR;
}
if (ctx->batch_size > 0
&& ctx->rest_batch_size == ctx->batch_size)
{
*output->pos = '[';
++output->pos;
}
tp_transcode_init_args_t args = {
.output = (char *)output->pos,
.output_size = output->end - output->pos,
.method = NULL, .method_len = 0,
.codec = TP_REPLY_TO_JSON,
.mf = NULL
};
rc = tp_transcode_init(&tc, &args);
if (rc == TP_TRANSCODE_ERROR) {
crit("[BUG] failed to call tp_transcode_init(output)");
return NGX_ERROR;
}
rc = tp_transcode(&tc, (char *)ctx->tp_cache->start,
ctx->tp_cache->end - ctx->tp_cache->start);
if (rc == TP_TRANSCODE_OK) {
size_t complete_msg_size = 0;
rc = tp_transcode_complete(&tc, &complete_msg_size);
if (rc == TP_TRANSCODE_ERROR) {
crit("[BUG] failed to complete output transcoding");
ngx_pfree(r->pool, output);
const ngx_http_tnt_error_t *e = get_error_text(UNKNOWN_PARSE_ERROR);
output = ngx_http_tnt_set_err(r, e->code, e->msg.data, e->msg.len);
if (output == NULL) {
goto error_exit;
}
goto done;
}
output->last = output->pos + complete_msg_size;
} else if (rc == TP_TRANSCODE_ERROR) {
crit("[BUG] failed to transcode output, err: '%s'", tc.errmsg);
ngx_pfree(r->pool, output);
output = ngx_http_tnt_set_err(r,
tc.errcode,
(u_char *)tc.errmsg,
ngx_strlen(tc.errmsg));
if (output == NULL) {
goto error_exit;
}
}
done:
tp_transcode_free(&tc);
if (ctx->batch_size > 0) {
if (ctx->rest_batch_size == 1)
{
*output->last = ']';
++output->last;
}
else if (ctx->rest_batch_size <= ctx->batch_size)
{
*output->last = ',';
++output->last;
}
}
return ngx_http_tnt_output(r, u, output);
error_exit:
tp_transcode_free(&tc);
return NGX_ERROR;
}
static ngx_int_t
ngx_http_tnt_filter_reply(ngx_http_request_t *r,
ngx_http_upstream_t *u,
ngx_buf_t *b)
{
ngx_http_tnt_ctx_t *ctx = ngx_http_get_module_ctx(r, ngx_http_tnt_module);
ssize_t bytes = b->last - b->pos;
dd("filter_reply -> recv bytes: %i, rest: %i", (int)bytes, (int)ctx->rest);
if (ctx->state == READ_PAYLOAD) {
ssize_t payload_rest = ngx_min(ctx->payload.e - ctx->payload.p, bytes);
if (payload_rest > 0) {
ctx->payload.p = ngx_copy(ctx->payload.p, b->pos, payload_rest);
bytes -= payload_rest;
b->pos += payload_rest;
payload_rest = ctx->payload.e - ctx->payload.p;
dd("filter_reply -> payload rest:%i", (int)payload_rest);
}
if (payload_rest == 0) {
ctx->payload_size = tp_read_payload((char *)&ctx->payload.mem[0],
(char *)ctx->payload.e);
if (ctx->payload_size <= 0) {
crit("[BUG] tp_read_payload failed, ret:%i",
(int)ctx->payload_size);
return NGX_ERROR;
}
ctx->rest = ctx->payload_size - 5 /* - header size */;
dd("filter_reply -> got header payload:%i, rest:%i",
(int)ctx->payload_size,
(int)ctx->rest);
ctx->tp_cache = ngx_create_temp_buf(r->pool, ctx->payload_size);
if (ctx->tp_cache == NULL) {
return NGX_ERROR;
}
ctx->tp_cache->pos = ctx->tp_cache->start;
ctx->tp_cache->memory = 1;
ctx->tp_cache->pos = ngx_copy(ctx->tp_cache->pos,
&ctx->payload.mem[0],
sizeof(ctx->payload.mem) - 1);
ctx->payload.p = &ctx->payload.mem[0];
ctx->state = READ_BODY;
} else {
return NGX_OK;
}
}
ngx_int_t rc = NGX_OK;
if (ctx->state == READ_BODY) {
ssize_t rest = ctx->rest - bytes, read_on = bytes;
if (rest < 0) {
rest *= -1;
read_on = bytes - rest;
ctx->rest = 0;
ctx->state = SEND_REPLY;
rc = NGX_AGAIN;
} else if (rest == 0) {
ctx->state = SEND_REPLY;
ctx->rest = 0;
} else {
ctx->rest -= bytes;
}
ctx->tp_cache->pos = ngx_copy(ctx->tp_cache->pos, b->pos, read_on);
b->pos += read_on;
dd("filter_reply -> read_on:%i, rest:%i, cache rest:%i, buf size:%i",
(int)read_on,
(int)ctx->rest,
(int)(ctx->tp_cache->end - ctx->tp_cache->pos),
(int)(b->last - b->pos));
}
if (ctx->state == SEND_REPLY) {
rc = ngx_http_tnt_send_reply(r, u, ctx);
ctx->state = READ_PAYLOAD;
ctx->rest = ctx->payload_size = 0;
--ctx->rest_batch_size;
if (ctx->rest_batch_size <= 0) {
u->length = 0;
ctx->rest_batch_size = 0;
ctx->batch_size = 0;
}
ngx_pfree(r->pool, ctx->tp_cache);
ctx->tp_cache = NULL;
if (b->last - b->pos > 0) {
rc = NGX_AGAIN;
}
}
return rc;
}
int AudioDecoder::initDecoder(AVCodecContext* context, AVCodec* dec_codec)
{
ELOG_DEBUG("initDecoder started");
codec_ = dec_codec;
input_codec_context = context; // ok? ok
if (avcodec_open2(input_codec_context, codec_, NULL) < 0) {
ELOG_DEBUG("AudioDecoder initDecoder Error open2 audio decoder");
return 0;
}
ELOG_DEBUG("input sample_fmts[0] is %s", av_get_sample_fmt_name(codec_->sample_fmts[0]));
ELOG_DEBUG("input sample_fmt is %s", av_get_sample_fmt_name(input_codec_context->sample_fmt));
ELOG_DEBUG("input frame size is %d, bitrate=%d", input_codec_context->frame_size, input_codec_context->bit_rate);
// Init output encoder as well.
AVCodec *output_codec = NULL;
int error;
if (!(output_codec = avcodec_find_encoder(OUTPUT_CODEC_ID))) {
ELOG_DEBUG( "Could not find the encoder.");
return 0;
}
output_codec_context = avcodec_alloc_context3(output_codec);
if (!output_codec_context)
{
ELOG_DEBUG( "Could not allocate an encoding context");
return 0;
}
/**
* Set the basic encoder parameters.
* The input file's sample rate is used to avoid a sample rate conversion.
*/
output_codec_context->channels = OUTPUT_CHANNELS;
output_codec_context->channel_layout = av_get_default_channel_layout(OUTPUT_CHANNELS);
output_codec_context->sample_rate = input_codec_context->sample_rate;
output_codec_context->sample_fmt = output_codec->sample_fmts[0]; //u8
output_codec_context->bit_rate = 510000;
/** Allow the use of the experimental feature */
output_codec_context->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
/** Open the encoder for the audio stream to use it later. */
if ((error = avcodec_open2(output_codec_context, output_codec, NULL)) < 0) {
ELOG_DEBUG("Could not open output codec %s", get_error_text(error));
return 0;
}
ELOG_DEBUG("output sample_fmts[0] is %s", av_get_sample_fmt_name(output_codec->sample_fmts[0]));
ELOG_DEBUG("output sample_fmt is %s", av_get_sample_fmt_name(output_codec_context->sample_fmt));
ELOG_DEBUG("output frame size is %d", output_codec_context->frame_size);
output_codec_context->frame_size = 960; //20ms. actually no need, as it already is
/** Initialize the resampler to be able to convert audio sample formats. */
if (init_resampler(input_codec_context, output_codec_context))
{
ELOG_DEBUG(" init resampleer failed !!");
return 0;
}
init_fifo(&fifo);
ELOG_DEBUG("initDecoder end");
return 1;
}
static SCM decode_video(struct ffmpeg_t *self, AVPacket *pkt, AVFrame *frame)
{
int got_frame;
int len = avcodec_decode_video2(self->video_codec_ctx, frame, &got_frame, pkt);
if (len < 0)
scm_misc_error("ffmpeg-decode-audio/video", "Error decoding frame: ~a", scm_list_1(get_error_text(len)));
consume_packet_data(pkt, pkt->size);
return got_frame ? list_timestamped_video(self, frame) : SCM_BOOL_F;
}
SCM make_ffmpeg_output(SCM scm_file_name,
SCM scm_format_name,
SCM scm_video_parameters,
SCM scm_have_video,
SCM scm_audio_parameters,
SCM scm_have_audio,
SCM scm_debug)
{
SCM retval;
struct ffmpeg_t *self;
scm_dynwind_begin(0);
const char *file_name = scm_to_locale_string(scm_file_name);
scm_dynwind_free(file_name);
self = (struct ffmpeg_t *)scm_gc_calloc(sizeof(struct ffmpeg_t), "ffmpeg");
self->video_stream_idx = -1;
self->audio_stream_idx = -1;
SCM_NEWSMOB(retval, ffmpeg_tag, self);
int err;
const char *format_name = NULL;
if (!scm_is_false(scm_format_name)) {
format_name = scm_to_locale_string(scm_symbol_to_string(scm_format_name));
scm_dynwind_free(format_name);
};
#ifdef HAVE_AVFORMAT_ALLOC_OUTPUT_CONTEXT2
err = avformat_alloc_output_context2(&self->fmt_ctx, NULL, format_name, file_name);
if (!self->fmt_ctx) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Error initializing output format for file '~a': ~a",
scm_list_2(scm_file_name, get_error_text(err)));
};
#else
AVOutputFormat *format;
if (format_name)
format = av_guess_format(format_name, NULL, NULL);
else
format = av_guess_format(NULL, file_name, NULL);
if (!format) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Unable to determine file format for file '~a'",
scm_list_1(scm_file_name));
};
self->fmt_ctx = avformat_alloc_context();
if (!self->fmt_ctx) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Error initializing output format for file '~a'",
scm_list_1(scm_file_name));
};
self->fmt_ctx->oformat = format;
strncpy(self->fmt_ctx->filename, file_name, sizeof(self->fmt_ctx->filename));
#endif
char have_video = scm_is_true(scm_have_video);
if (have_video) {
// Open codec and video stream
enum AVCodecID video_codec_id = self->fmt_ctx->oformat->video_codec;
AVCodec *video_encoder = find_encoder(retval, video_codec_id, "video");
AVStream *video_stream = open_output_stream(retval, video_encoder, &self->video_stream_idx, "video", scm_file_name);
// Get video parameters
SCM scm_shape = scm_car(scm_video_parameters);
SCM scm_frame_rate = scm_cadr(scm_video_parameters);
SCM scm_video_bit_rate = scm_caddr(scm_video_parameters);
SCM scm_aspect_ratio = scm_cadddr(scm_video_parameters);
// Configure the output video codec
self->video_codec_ctx =
configure_output_video_codec(video_stream, video_codec_id, scm_video_bit_rate, scm_shape, scm_frame_rate, scm_aspect_ratio);
// Some formats want stream headers to be separate.
if (self->fmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
self->video_codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
// Open output video codec
open_codec(retval, self->video_codec_ctx, video_encoder, "video", scm_file_name);
// Allocate frame
self->video_target_frame = allocate_output_video_frame(retval, self->video_codec_ctx);
};
char have_audio = scm_is_true(scm_have_audio);
if (have_audio) {
// Open audio codec and stream
enum AVCodecID audio_codec_id = self->fmt_ctx->oformat->audio_codec;
AVCodec *audio_encoder = find_encoder(retval, audio_codec_id, "audio");
AVStream *audio_stream = open_output_stream(retval, audio_encoder, &self->audio_stream_idx, "audio", scm_file_name);
// Get audio parameters
SCM scm_select_rate = scm_car(scm_audio_parameters);
SCM scm_channels = scm_cadr(scm_audio_parameters);
SCM scm_audio_bit_rate = scm_caddr(scm_audio_parameters);
SCM scm_select_format = scm_cadddr(scm_audio_parameters);
// Configure the output audio codec
self->audio_codec_ctx =
configure_output_audio_codec(retval, audio_stream, audio_codec_id,
scm_select_rate, scm_channels, scm_audio_bit_rate, scm_select_format);
// Some formats want stream headers to be separate.
if (self->fmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
self->audio_codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
// Open output audio codec
open_codec(retval, self->audio_codec_ctx, audio_encoder, "audio", scm_file_name);
// Allocate audio frame
self->audio_target_frame =
allocate_output_audio_frame(retval, self->audio_codec_ctx, self->audio_codec_ctx->sample_fmt);
self->audio_packed_frame =
allocate_output_audio_frame(retval, self->audio_codec_ctx, av_get_packed_sample_fmt(self->audio_codec_ctx->sample_fmt));
// Initialise audio buffer
ringbuffer_init(&self->audio_buffer, 1024);
};
if (scm_is_true(scm_debug)) av_dump_format(self->fmt_ctx, 0, file_name, 1);
// Open the output file if needed
if (!(self->fmt_ctx->oformat->flags & AVFMT_NOFILE)) {
int err = avio_open(&self->fmt_ctx->pb, file_name, AVIO_FLAG_WRITE);
if (err < 0) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Could not open '~a': ~a",
scm_list_2(scm_file_name, get_error_text(err)));
}
self->output_file = 1;
}
// Write video file header
err = avformat_write_header(self->fmt_ctx, NULL);
if (err < 0) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Error writing header of video '~a': ~a",
scm_list_2(scm_file_name, get_error_text(err)));
};
self->header_written = 1;
scm_dynwind_end();
return retval;
}
SCM make_ffmpeg_input(SCM scm_file_name, SCM scm_debug)
{
SCM retval;
struct ffmpeg_t *self;
scm_dynwind_begin(0);
const char *file_name = scm_to_locale_string(scm_file_name);
scm_dynwind_free(file_name);
self = (struct ffmpeg_t *)scm_gc_calloc(sizeof(struct ffmpeg_t), "ffmpeg");
self->video_stream_idx = -1;
self->audio_stream_idx = -1;
SCM_NEWSMOB(retval, ffmpeg_tag, self);
int err;
err = avformat_open_input(&self->fmt_ctx, file_name, NULL, NULL);
if (err < 0) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-input", "Error opening file '~a': ~a", scm_list_2(scm_file_name, get_error_text(err)));
};
err = avformat_find_stream_info(self->fmt_ctx, NULL);
if (err < 0) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-input", "No stream information in file '~a': ~a", scm_list_2(scm_file_name, get_error_text(err)));
};
// TODO: only open desired streams
// Open video stream
self->video_stream_idx = av_find_best_stream(self->fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
if (self->video_stream_idx >= 0)
self->video_codec_ctx = open_decoder(retval, scm_file_name, video_stream(self), "video");
// Open audio stream
self->audio_stream_idx = av_find_best_stream(self->fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
if (self->audio_stream_idx >= 0)
self->audio_codec_ctx = open_decoder(retval, scm_file_name, audio_stream(self), "audio");
// Print debug information
if (scm_is_true(scm_debug)) av_dump_format(self->fmt_ctx, 0, file_name, 0);
// Allocate input frames
self->video_target_frame = allocate_frame(retval);
self->audio_target_frame = allocate_frame(retval);
// Initialise data packet
av_init_packet(&self->pkt);
self->pkt.data = NULL;
self->pkt.size = 0;
scm_dynwind_end();
return retval;
}
