2015-03-17 15:52:01 +00:00
|
|
|
/*
|
|
|
|
* FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
|
|
|
|
* Copyright (C) 2005-2015, Anthony Minessale II <anthm@freeswitch.org>
|
|
|
|
*
|
|
|
|
* Version: MPL 1.1
|
|
|
|
*
|
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
|
|
|
*
|
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Seven Du <dujinfang@gmail.com>
|
|
|
|
* Portions created by the Initial Developer are Copyright (C)
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Seven Du <dujinfang@gmail.com>
|
|
|
|
*
|
|
|
|
* mod_avformat -- FS Video File Format using libav.org
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <switch.h>
|
|
|
|
#include <libavcodec/avcodec.h>
|
|
|
|
#include <libavformat/avformat.h>
|
|
|
|
#include <libavutil/opt.h>
|
|
|
|
#include <libavutil/imgutils.h>
|
|
|
|
#include <libavutil/avstring.h>
|
|
|
|
#include <libavutil/channel_layout.h>
|
|
|
|
// #include <libavutil/timestamp.h>
|
|
|
|
#include <libavresample/avresample.h>
|
2015-04-09 23:18:45 +00:00
|
|
|
#define DFT_RECORD_OFFSET 350
|
2015-03-17 15:52:01 +00:00
|
|
|
|
|
|
|
SWITCH_MODULE_LOAD_FUNCTION(mod_avformat_load);
|
|
|
|
SWITCH_MODULE_DEFINITION(mod_avformat, mod_avformat_load, NULL, NULL);
|
|
|
|
|
|
|
|
static char *const get_error_text(const int error)
|
|
|
|
{
|
|
|
|
static char error_buffer[255];
|
|
|
|
av_strerror(error, error_buffer, sizeof(error_buffer));
|
|
|
|
return error_buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __attribute__((unused)) fill_avframe(AVFrame *pict, switch_image_t *img)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint8_t *y = img->planes[0];
|
|
|
|
uint8_t *u = img->planes[1];
|
|
|
|
uint8_t *v = img->planes[2];
|
|
|
|
|
|
|
|
/* Y */
|
|
|
|
for (i = 0; i < pict->height; i++) {
|
|
|
|
memcpy(&pict->data[0][i * pict->linesize[0]], y + i * img->stride[0], pict->width);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* U/V */
|
|
|
|
for(i = 0; i < pict->height / 2; i++) {
|
|
|
|
memcpy(&pict->data[1][i * pict->linesize[1]], u + i * img->stride[1], pict->width / 2);
|
|
|
|
memcpy(&pict->data[2][i * pict->linesize[2]], v + i * img->stride[2], pict->width / 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* App interface */
|
|
|
|
|
|
|
|
// a wrapper around a single output AVStream
|
|
|
|
typedef struct OutputStream {
|
|
|
|
AVStream *st;
|
|
|
|
AVFrame *frame;
|
|
|
|
AVFrame *tmp_frame;
|
|
|
|
int64_t next_pts;
|
|
|
|
struct AVAudioResampleContext *resample_ctx;
|
|
|
|
// audio
|
|
|
|
int channels;
|
|
|
|
int sample_rate;
|
|
|
|
//video
|
|
|
|
int width;
|
|
|
|
int height;
|
|
|
|
} OutputStream;
|
|
|
|
|
|
|
|
typedef struct record_helper_s {
|
|
|
|
switch_mutex_t *mutex;
|
|
|
|
AVFormatContext *oc;
|
|
|
|
OutputStream *video_st;
|
|
|
|
switch_timer_t *timer;
|
|
|
|
int in_callback;
|
|
|
|
switch_queue_t *video_queue;
|
|
|
|
switch_thread_t *video_thread;
|
|
|
|
} record_helper_t;
|
|
|
|
|
|
|
|
static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt)
|
|
|
|
{
|
|
|
|
// AVRational *time_base = &fmt_ctx->streams[pkt->stream_index]->time_base;
|
|
|
|
|
|
|
|
// printf("pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n",
|
|
|
|
// av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, time_base),
|
|
|
|
// av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, time_base),
|
|
|
|
// av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, time_base),
|
|
|
|
// pkt->stream_index);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
|
|
|
|
const char *format, const char *filename)
|
|
|
|
{
|
|
|
|
AVFormatContext *s = avformat_alloc_context();
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
*avctx = NULL;
|
|
|
|
if (!s)
|
|
|
|
goto nomem;
|
|
|
|
|
|
|
|
if (!oformat) {
|
|
|
|
if (format) {
|
|
|
|
oformat = av_guess_format(format, NULL, NULL);
|
|
|
|
if (!oformat) {
|
|
|
|
av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
|
|
|
|
ret = AVERROR(EINVAL);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
oformat = av_guess_format(NULL, filename, NULL);
|
|
|
|
if (!oformat) {
|
|
|
|
ret = AVERROR(EINVAL);
|
|
|
|
av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
|
|
|
|
filename);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
s->oformat = oformat;
|
|
|
|
if (s->oformat->priv_data_size > 0) {
|
|
|
|
s->priv_data = av_mallocz(s->oformat->priv_data_size);
|
|
|
|
if (!s->priv_data)
|
|
|
|
goto nomem;
|
|
|
|
if (s->oformat->priv_class) {
|
|
|
|
*(const AVClass**)s->priv_data= s->oformat->priv_class;
|
|
|
|
av_opt_set_defaults(s->priv_data);
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
s->priv_data = NULL;
|
|
|
|
|
|
|
|
if (filename)
|
|
|
|
av_strlcpy(s->filename, filename, sizeof(s->filename));
|
|
|
|
*avctx = s;
|
|
|
|
return 0;
|
|
|
|
nomem:
|
|
|
|
av_log(s, AV_LOG_ERROR, "Out of memory\n");
|
|
|
|
ret = AVERROR(ENOMEM);
|
|
|
|
error:
|
|
|
|
avformat_free_context(s);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int write_frame(AVFormatContext *fmt_ctx, const AVRational *time_base, AVStream *st, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
/* rescale output packet timestamp values from codec to stream timebase */
|
|
|
|
av_packet_rescale_ts(pkt, *time_base, st->time_base);
|
|
|
|
pkt->stream_index = st->index;
|
|
|
|
|
|
|
|
/* Write the compressed frame to the media file. */
|
|
|
|
if (0) log_packet(fmt_ctx, pkt);
|
|
|
|
return av_interleaved_write_frame(fmt_ctx, pkt);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add an output stream. */
|
2015-03-18 22:58:23 +00:00
|
|
|
static switch_status_t add_stream(OutputStream *ost, AVFormatContext *oc, AVCodec **codec, enum AVCodecID codec_id, switch_mm_t *mm)
|
2015-03-17 15:52:01 +00:00
|
|
|
{
|
|
|
|
AVCodecContext *c;
|
|
|
|
switch_status_t status = SWITCH_STATUS_FALSE;
|
|
|
|
int threads = switch_core_cpu_count();
|
2015-04-15 17:56:07 +00:00
|
|
|
int buffer_bytes = 2097152; /* 2 mb */
|
|
|
|
|
2015-03-17 15:52:01 +00:00
|
|
|
/* find the encoder */
|
|
|
|
*codec = avcodec_find_encoder(codec_id);
|
|
|
|
if (!(*codec)) {
|
|
|
|
// switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not find encoder for '%s'\n", avcodec_get_name(codec_id));
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
ost->st = avformat_new_stream(oc, *codec);
|
|
|
|
if (!ost->st) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate stream\n");
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
ost->st->id = oc->nb_streams - 1;
|
|
|
|
c = ost->st->codec;
|
|
|
|
// switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "id:%d den:%d num:%d\n", ost->st->id, ost->st->time_base.den, ost->st->time_base.num);
|
|
|
|
|
|
|
|
if (threads > 4) {
|
|
|
|
threads = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch ((*codec)->type) {
|
|
|
|
case AVMEDIA_TYPE_AUDIO:
|
|
|
|
c->sample_fmt = (*codec)->sample_fmts ? (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
|
|
|
|
c->bit_rate = 128000;
|
|
|
|
c->sample_rate = ost->sample_rate = 44100;
|
|
|
|
c->channels = ost->channels;
|
|
|
|
c->channel_layout = av_get_default_channel_layout(c->channels);
|
2015-03-18 22:58:23 +00:00
|
|
|
|
|
|
|
if (mm) {
|
|
|
|
if (mm->ab) {
|
|
|
|
c->bit_rate = mm->ab * 1024;
|
|
|
|
}
|
|
|
|
if (mm->samplerate) {
|
|
|
|
c->sample_rate = ost->sample_rate = mm->samplerate;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-17 15:52:01 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case AVMEDIA_TYPE_VIDEO:
|
2015-04-15 17:56:07 +00:00
|
|
|
|
|
|
|
if (mm) {
|
|
|
|
if (mm->vbuf) {
|
|
|
|
buffer_bytes = mm->vbuf;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-17 15:52:01 +00:00
|
|
|
c->codec_id = codec_id;
|
2015-03-18 22:58:23 +00:00
|
|
|
c->bit_rate = 1000000;
|
2015-03-17 15:52:01 +00:00
|
|
|
/* Resolution must be a multiple of two. */
|
|
|
|
c->width = ost->width;
|
|
|
|
c->height = ost->height;
|
|
|
|
c->time_base.den = 1000;
|
|
|
|
c->time_base.num = 1;
|
|
|
|
c->gop_size = 25; /* emit one intra frame every x frames at most */
|
|
|
|
c->pix_fmt = AV_PIX_FMT_YUV420P;
|
|
|
|
c->thread_count = threads;
|
2015-04-15 17:56:07 +00:00
|
|
|
c->rc_initial_buffer_occupancy = buffer_bytes * 8;
|
|
|
|
|
2015-03-17 15:52:01 +00:00
|
|
|
if (codec_id == AV_CODEC_ID_VP8) {
|
|
|
|
av_set_options_string(c, "quality=realtime", "=", ":");
|
|
|
|
}
|
2015-03-18 22:58:23 +00:00
|
|
|
|
|
|
|
if (mm) {
|
|
|
|
if (mm->vb) {
|
|
|
|
c->bit_rate = mm->vb * 1000;
|
|
|
|
}
|
|
|
|
if (mm->keyint) {
|
|
|
|
c->gop_size = mm->keyint;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-17 15:52:01 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Some formats want stream headers to be separate. */
|
|
|
|
if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
|
|
|
|
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
|
|
|
|
}
|
|
|
|
|
|
|
|
return SWITCH_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)
|
|
|
|
{
|
|
|
|
AVFrame *picture;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
picture = av_frame_alloc();
|
|
|
|
if (!picture) return NULL;
|
|
|
|
|
|
|
|
picture->format = pix_fmt;
|
|
|
|
picture->width = width;
|
|
|
|
picture->height = height;
|
|
|
|
|
|
|
|
/* allocate the buffers for the frame data */
|
|
|
|
ret = av_frame_get_buffer(picture, 32);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate frame data.\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return picture;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t open_video(AVFormatContext *oc, AVCodec *codec, OutputStream *ost)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
AVCodecContext *c = ost->st->codec;
|
|
|
|
switch_status_t status = SWITCH_STATUS_FALSE;
|
|
|
|
|
|
|
|
/* open the codec */
|
|
|
|
ret = avcodec_open2(c, codec, NULL);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not open video codec: %s\n", get_error_text(ret));
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allocate and init a re-usable frame */
|
|
|
|
ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);
|
|
|
|
switch_assert(ost->frame);
|
|
|
|
|
|
|
|
// switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "pix_fmt: %d\n", c->pix_fmt);
|
|
|
|
switch_assert(c->pix_fmt == AV_PIX_FMT_YUV420P); // always I420 for NOW
|
|
|
|
|
|
|
|
return SWITCH_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t open_audio(AVFormatContext *oc, AVCodec *codec, OutputStream *ost)
|
|
|
|
{
|
|
|
|
AVCodecContext *c;
|
|
|
|
int ret;
|
|
|
|
switch_status_t status = SWITCH_STATUS_FALSE;
|
|
|
|
|
|
|
|
c = ost->st->codec;
|
|
|
|
|
|
|
|
ret = avcodec_open2(c, codec, NULL);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not open audio codec: %s\n", get_error_text(ret));
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
ost->frame = av_frame_alloc();
|
|
|
|
switch_assert(ost->frame);
|
|
|
|
|
|
|
|
ost->frame->sample_rate = c->sample_rate;
|
|
|
|
ost->frame->format = AV_SAMPLE_FMT_S16;
|
|
|
|
ost->frame->channel_layout = c->channel_layout;
|
|
|
|
|
|
|
|
if (c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE) {
|
|
|
|
ost->frame->nb_samples = 10000;
|
|
|
|
} else {
|
|
|
|
ost->frame->nb_samples = c->frame_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "sample_rate: %d nb_samples: %d\n", ost->frame->sample_rate, ost->frame->nb_samples);
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
|
|
|
|
if (c->sample_fmt != AV_SAMPLE_FMT_S16) {
|
2015-03-17 15:52:01 +00:00
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "sample_fmt %d != AV_SAMPLE_FMT_S16, start resampler\n", c->sample_fmt);
|
|
|
|
|
|
|
|
ost->resample_ctx = avresample_alloc_context();
|
|
|
|
|
|
|
|
if (!ost->resample_ctx) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate resampler context\n");
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set options */
|
|
|
|
av_opt_set_int(ost->resample_ctx, "in_channel_count", c->channels, 0);
|
|
|
|
av_opt_set_int(ost->resample_ctx, "in_sample_rate", c->sample_rate, 0);
|
|
|
|
av_opt_set_int(ost->resample_ctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);
|
|
|
|
av_opt_set_int(ost->resample_ctx, "in_channel_layout", c->channel_layout, 0);
|
|
|
|
av_opt_set_int(ost->resample_ctx, "out_channel_count", c->channels, 0);
|
|
|
|
av_opt_set_int(ost->resample_ctx, "out_sample_rate", c->sample_rate, 0);
|
|
|
|
av_opt_set_int(ost->resample_ctx, "out_sample_fmt", c->sample_fmt, 0);
|
|
|
|
av_opt_set_int(ost->resample_ctx, "out_channel_layout", c->channel_layout, 0);
|
|
|
|
|
|
|
|
if ((ret = avresample_open(ost->resample_ctx)) < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to initialize the resampling context\n");
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = av_frame_get_buffer(ost->frame, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate audio frame.\n");
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ost->resample_ctx) {
|
|
|
|
ost->tmp_frame = av_frame_alloc();
|
|
|
|
switch_assert(ost->tmp_frame);
|
|
|
|
|
|
|
|
ost->tmp_frame->sample_rate = c->sample_rate;
|
|
|
|
ost->tmp_frame->format = c->sample_fmt;
|
|
|
|
ost->tmp_frame->channel_layout = c->channel_layout;
|
|
|
|
ost->tmp_frame->nb_samples = ost->frame->nb_samples;
|
|
|
|
|
|
|
|
ret = av_frame_get_buffer(ost->tmp_frame, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate audio frame.\n");
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return SWITCH_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void *SWITCH_THREAD_FUNC video_thread_run(switch_thread_t *thread, void *obj)
|
|
|
|
{
|
|
|
|
record_helper_t *eh = (record_helper_t *) obj;
|
|
|
|
void *pop;
|
|
|
|
switch_image_t *img, *last_img = NULL, *tmp_img = NULL;
|
|
|
|
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "video thread start\n");
|
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
AVPacket pkt = { 0 };
|
|
|
|
int got_packet;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
img = NULL;
|
|
|
|
|
|
|
|
if (switch_queue_pop_timeout(eh->video_queue, &pop, 66000) == SWITCH_STATUS_SUCCESS) {
|
|
|
|
if (!pop) break;
|
|
|
|
img = (switch_image_t *) pop;
|
|
|
|
|
|
|
|
if (last_img && (last_img->d_w != img->d_w || last_img->d_h != img->d_h)) {
|
|
|
|
/* scale to match established stream */
|
|
|
|
switch_img_scale(img, &tmp_img, last_img->d_w, last_img->d_h);
|
|
|
|
switch_img_free(&img);
|
|
|
|
img = tmp_img;
|
|
|
|
tmp_img = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_img_free(&last_img);
|
|
|
|
last_img = img;
|
|
|
|
} else {
|
|
|
|
if (last_img) {
|
|
|
|
img = last_img;
|
|
|
|
} else {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!img) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
//switch_mutex_lock(eh->mutex);
|
2015-03-17 15:52:01 +00:00
|
|
|
|
|
|
|
eh->in_callback = 1;
|
|
|
|
|
|
|
|
av_init_packet(&pkt);
|
|
|
|
|
|
|
|
if (eh->video_st->frame) {
|
|
|
|
ret = av_frame_make_writable(eh->video_st->frame);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0) continue;
|
|
|
|
|
|
|
|
fill_avframe(eh->video_st->frame, img);
|
|
|
|
switch_core_timer_sync(eh->timer);
|
|
|
|
|
|
|
|
if (eh->video_st->frame->pts == eh->timer->samplecount) {
|
|
|
|
// never use the same pts, or the encoder coughs
|
|
|
|
eh->video_st->frame->pts++;
|
|
|
|
} else {
|
|
|
|
eh->video_st->frame->pts = eh->timer->samplecount;
|
|
|
|
}
|
|
|
|
// eh->video_st->frame->pts = switch_time_now() / 1000 - eh->video_st->next_pts;
|
|
|
|
// switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "pts: %lld\n", eh->video_st->frame->pts);
|
|
|
|
|
|
|
|
/* encode the image */
|
|
|
|
ret = avcodec_encode_video2(eh->video_st->st->codec, &pkt, eh->video_st->frame, &got_packet);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Encoding Error %d\n", ret);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (got_packet) {
|
2015-03-18 22:58:23 +00:00
|
|
|
switch_mutex_lock(eh->mutex);
|
2015-03-17 15:52:01 +00:00
|
|
|
ret = write_frame(eh->oc, &eh->video_st->st->codec->time_base, eh->video_st->st, &pkt);
|
2015-03-18 22:58:23 +00:00
|
|
|
switch_mutex_unlock(eh->mutex);
|
2015-03-17 15:52:01 +00:00
|
|
|
av_free_packet(&pkt);
|
|
|
|
}
|
|
|
|
|
|
|
|
eh->in_callback = 0;
|
2015-03-18 22:58:23 +00:00
|
|
|
//switch_mutex_unlock(eh->mutex);
|
2015-03-17 15:52:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch_img_free(&last_img);
|
|
|
|
|
|
|
|
while(switch_queue_trypop(eh->video_queue, &pop) == SWITCH_STATUS_SUCCESS) {
|
|
|
|
if (!pop) break;
|
|
|
|
img = (switch_image_t *) pop;
|
|
|
|
switch_img_free(&img);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "video thread done\n");
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static switch_status_t video_read_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data)
|
|
|
|
{
|
|
|
|
record_helper_t *eh = user_data;
|
|
|
|
switch_image_t *img = NULL;
|
|
|
|
|
|
|
|
if (frame->img) {
|
|
|
|
switch_img_copy(frame->img, &img);
|
|
|
|
switch_queue_push(eh->video_queue, img);
|
|
|
|
}
|
|
|
|
|
|
|
|
return SWITCH_STATUS_SUCCESS;;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void close_stream(AVFormatContext *oc, OutputStream *ost)
|
|
|
|
{
|
|
|
|
avcodec_close(ost->st->codec);
|
|
|
|
av_frame_free(&ost->frame);
|
|
|
|
if (ost->tmp_frame) av_frame_free(&ost->tmp_frame);
|
|
|
|
}
|
|
|
|
|
|
|
|
SWITCH_STANDARD_APP(record_av_function)
|
|
|
|
{
|
|
|
|
switch_status_t status;
|
|
|
|
switch_frame_t *read_frame;
|
|
|
|
switch_channel_t *channel = switch_core_session_get_channel(session);
|
|
|
|
record_helper_t eh = { 0 };
|
|
|
|
switch_timer_t timer = { 0 };
|
|
|
|
switch_mutex_t *mutex = NULL;
|
|
|
|
switch_codec_t codec;//, *vid_codec;
|
|
|
|
switch_codec_implementation_t read_impl = { 0 };
|
|
|
|
switch_dtmf_t dtmf = { 0 };
|
|
|
|
switch_buffer_t *buffer = NULL;
|
|
|
|
int inuse = 0, bytes = 0;
|
|
|
|
switch_vid_params_t vid_params = { 0 };
|
|
|
|
int force_sample_rate;
|
|
|
|
|
|
|
|
OutputStream video_st = { 0 }, audio_st = { 0 };
|
|
|
|
AVOutputFormat *fmt = NULL;
|
|
|
|
const char *format = NULL;
|
|
|
|
AVFormatContext *oc = NULL;
|
|
|
|
AVCodec *audio_codec, *video_codec;
|
|
|
|
int has_audio = 0, has_video = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
switch_channel_answer(channel);
|
|
|
|
switch_core_session_get_read_impl(session, &read_impl);
|
|
|
|
switch_core_session_request_video_refresh(session);
|
|
|
|
|
|
|
|
switch_channel_set_variable(channel, SWITCH_PLAYBACK_TERMINATOR_USED, "");
|
|
|
|
|
|
|
|
if (!switch_channel_ready(channel)) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "%s not ready.\n", switch_channel_get_name(channel));
|
|
|
|
switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE, "Channel not ready");
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_channel_set_flag(channel, CF_VIDEO_DECODED_READ);
|
|
|
|
switch_core_media_get_vid_params(session, &vid_params);
|
|
|
|
switch_channel_set_flag(channel, CF_VIDEO_ECHO);
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "video size: %dx%d\n", vid_params.width, vid_params.height);
|
|
|
|
|
|
|
|
force_sample_rate = read_impl.samples_per_second;
|
|
|
|
|
|
|
|
if (!strncmp(data, "rtmp://", 7)) {
|
|
|
|
format = "flv";
|
|
|
|
force_sample_rate = 44100;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (switch_core_codec_init(&codec,
|
|
|
|
"L16",
|
|
|
|
NULL,
|
2015-03-19 19:26:47 +00:00
|
|
|
NULL,
|
2015-03-17 15:52:01 +00:00
|
|
|
force_sample_rate,
|
|
|
|
read_impl.microseconds_per_packet / 1000,
|
|
|
|
read_impl.number_of_channels, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
|
|
|
|
NULL, switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Audio Codec Activation Success\n");
|
|
|
|
} else {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Audio Codec Activation Fail\n");
|
|
|
|
switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE, "Audio codec activation failed");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_buffer_create_dynamic(&buffer, 8192, 65536, 0);
|
|
|
|
|
|
|
|
av_register_all();
|
|
|
|
avformat_alloc_output_context2(&oc, NULL, format, data);
|
|
|
|
|
|
|
|
if (!oc) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Could not deduce output format from file extension\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt = oc->oformat;
|
|
|
|
|
|
|
|
/* open the output file, if needed */
|
|
|
|
if (!(fmt->flags & AVFMT_NOFILE)) {
|
|
|
|
ret = avio_open(&oc->pb, data, AVIO_FLAG_WRITE);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not open '%s': %s\n", data, get_error_text(ret));
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
avformat_network_init();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fmt->video_codec != AV_CODEC_ID_NONE &&
|
|
|
|
switch_channel_test_flag(channel, CF_VIDEO) &&
|
|
|
|
vid_params.width > 0 && vid_params.height > 0) {
|
|
|
|
|
|
|
|
char codec_str[256];
|
|
|
|
const AVCodecDescriptor *desc;
|
|
|
|
|
|
|
|
if (!strncmp(data, "rtmp://", 7)) {
|
2015-04-20 20:35:58 +00:00
|
|
|
fmt->video_codec = AV_CODEC_ID_H264;
|
|
|
|
fmt->audio_codec = AV_CODEC_ID_AAC;
|
2015-03-17 15:52:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
desc = avcodec_descriptor_get(fmt->video_codec);
|
|
|
|
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "use video codec: [%d] %s (%s)\n", fmt->video_codec, desc->name, desc->long_name);
|
|
|
|
|
|
|
|
video_st.width = vid_params.width;
|
|
|
|
video_st.height = vid_params.height;
|
|
|
|
video_st.next_pts = switch_time_now() / 1000;
|
2015-03-18 22:58:23 +00:00
|
|
|
if (add_stream(&video_st, oc, &video_codec, fmt->video_codec, NULL) == SWITCH_STATUS_SUCCESS &&
|
2015-03-17 15:52:01 +00:00
|
|
|
open_video(oc, video_codec, &video_st) == SWITCH_STATUS_SUCCESS) {
|
|
|
|
avcodec_string(codec_str, sizeof(codec_str), video_st.st->codec, 1);
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "use video codec implementation %s\n", codec_str);
|
|
|
|
has_video = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fmt->audio_codec != AV_CODEC_ID_NONE) {
|
|
|
|
audio_st.channels = read_impl.number_of_channels;
|
|
|
|
audio_st.sample_rate = force_sample_rate;
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
add_stream(&audio_st, oc, &audio_codec, fmt->audio_codec, NULL);
|
2015-03-17 15:52:01 +00:00
|
|
|
if (open_audio(oc, audio_codec, &audio_st) != SWITCH_STATUS_SUCCESS) {
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
has_audio = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_dump_format(oc, 0, data, 1);
|
|
|
|
|
|
|
|
/* Write the stream header, if any. */
|
|
|
|
ret = avformat_write_header(oc, NULL);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error occurred when opening output file: %s\n", get_error_text(ret));
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (has_video) {
|
|
|
|
switch_threadattr_t *thd_attr = NULL;
|
|
|
|
|
|
|
|
switch_mutex_init(&mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
|
|
|
|
eh.mutex = mutex;
|
|
|
|
eh.video_st = &video_st;
|
|
|
|
eh.oc = oc;
|
|
|
|
if (switch_core_timer_init(&timer, "soft", 1, 1, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Timer Activation Fail\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
eh.timer = &timer;
|
|
|
|
switch_queue_create(&eh.video_queue, SWITCH_CORE_QUEUE_LEN, switch_core_session_get_pool(session));
|
|
|
|
switch_core_session_set_video_read_callback(session, video_read_callback, (void *)&eh);
|
|
|
|
|
|
|
|
switch_threadattr_create(&thd_attr, switch_core_session_get_pool(session));
|
|
|
|
//switch_threadattr_priority_set(thd_attr, SWITCH_PRI_REALTIME);
|
|
|
|
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
|
|
|
|
switch_thread_create(&eh.video_thread, thd_attr, video_thread_run, &eh, switch_core_session_get_pool(session));
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_core_session_set_read_codec(session, &codec);
|
|
|
|
|
|
|
|
{
|
|
|
|
char buf[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0};
|
|
|
|
switch_size_t datalen = codec.implementation->decoded_bytes_per_packet;
|
|
|
|
switch_size_t samples = datalen / 2 / codec.implementation->number_of_channels;
|
2015-04-09 23:18:45 +00:00
|
|
|
int offset = DFT_RECORD_OFFSET;
|
2015-03-17 15:52:01 +00:00
|
|
|
int fps = codec.implementation->actual_samples_per_second / samples;
|
|
|
|
int lead_frames = (offset * fps) / 1000;
|
|
|
|
|
|
|
|
for (int x = 0; x < lead_frames; x++) {
|
|
|
|
switch_buffer_write(buffer, buf, datalen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (switch_channel_ready(channel)) {
|
|
|
|
|
|
|
|
status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_SINGLE_READ, 0);
|
|
|
|
|
|
|
|
if (switch_channel_test_flag(channel, CF_BREAK)) {
|
|
|
|
switch_channel_clear_flag(channel, CF_BREAK);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_ivr_parse_all_events(session);
|
|
|
|
|
|
|
|
//check for dtmf interrupts
|
|
|
|
if (switch_channel_has_dtmf(channel)) {
|
|
|
|
const char * terminators = switch_channel_get_variable(channel, SWITCH_PLAYBACK_TERMINATORS_VARIABLE);
|
|
|
|
switch_channel_dequeue_dtmf(channel, &dtmf);
|
|
|
|
|
|
|
|
if (terminators && !strcasecmp(terminators, "none"))
|
|
|
|
{
|
|
|
|
terminators = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (terminators && strchr(terminators, dtmf.digit)) {
|
|
|
|
|
|
|
|
char sbuf[2] = {dtmf.digit, '\0'};
|
|
|
|
switch_channel_set_variable(channel, SWITCH_PLAYBACK_TERMINATOR_USED, sbuf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!SWITCH_READ_ACCEPTABLE(status)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (switch_test_flag(read_frame, SFF_CNG)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mutex) switch_mutex_lock(mutex);
|
|
|
|
|
|
|
|
switch_buffer_write(buffer, read_frame->data, read_frame->datalen);
|
|
|
|
bytes = audio_st.frame->nb_samples * 2 * audio_st.st->codec->channels;
|
|
|
|
inuse = switch_buffer_inuse(buffer);
|
|
|
|
|
|
|
|
while (inuse >= bytes) {
|
|
|
|
AVPacket pkt = { 0 };
|
|
|
|
int got_packet = 0;
|
|
|
|
|
|
|
|
av_init_packet(&pkt);
|
|
|
|
|
|
|
|
// switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "inuse: %d samples: %d bytes: %d\n", inuse, audio_st.frame->nb_samples, bytes);
|
|
|
|
|
|
|
|
if (audio_st.resample_ctx) { // need resample
|
|
|
|
int out_samples = avresample_get_out_samples(audio_st.resample_ctx, audio_st.frame->nb_samples);
|
|
|
|
|
|
|
|
av_frame_make_writable(audio_st.frame);
|
|
|
|
av_frame_make_writable(audio_st.tmp_frame);
|
|
|
|
switch_buffer_read(buffer, audio_st.frame->data[0], bytes);
|
|
|
|
/* convert to destination format */
|
|
|
|
ret = avresample_convert(audio_st.resample_ctx,
|
|
|
|
(uint8_t **)audio_st.frame->data, 0, out_samples,
|
|
|
|
audio_st.tmp_frame->data, 0, audio_st.frame->nb_samples);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error while converting %d samples, error text: %s\n",
|
|
|
|
audio_st.frame->nb_samples, get_error_text(ret));
|
|
|
|
inuse = switch_buffer_inuse(buffer);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
audio_st.tmp_frame->pts = audio_st.next_pts;
|
|
|
|
audio_st.next_pts += audio_st.frame->nb_samples;
|
|
|
|
|
|
|
|
ret = avcodec_encode_audio2(audio_st.st->codec, &pkt, audio_st.tmp_frame, &got_packet);
|
|
|
|
} else {
|
|
|
|
av_frame_make_writable(audio_st.frame);
|
|
|
|
switch_buffer_read(buffer, audio_st.frame->data[0], bytes);
|
|
|
|
audio_st.frame->pts = audio_st.next_pts;
|
|
|
|
audio_st.next_pts += audio_st.frame->nb_samples;
|
|
|
|
|
|
|
|
ret = avcodec_encode_audio2(audio_st.st->codec, &pkt, audio_st.frame, &got_packet);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Error encoding audio frame: %d\n", ret);
|
|
|
|
inuse = switch_buffer_inuse(buffer);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (got_packet) {
|
|
|
|
// switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "got pkt: %d\n", pkt.size);
|
|
|
|
ret = write_frame(oc, &audio_st.st->codec->time_base, audio_st.st, &pkt);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error while writing audio frame: %s\n", get_error_text(ret));
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inuse = switch_buffer_inuse(buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mutex) switch_mutex_unlock(mutex);
|
|
|
|
|
|
|
|
//switch_core_session_write_frame(session, read_frame, SWITCH_IO_FLAG_NONE, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_core_session_set_video_read_callback(session, NULL, NULL);
|
|
|
|
|
|
|
|
if (has_video) {
|
|
|
|
AVPacket pkt = { 0 };
|
|
|
|
int got_packet = 0;
|
|
|
|
int ret = 0;
|
|
|
|
switch_status_t st;
|
|
|
|
|
|
|
|
switch_queue_push(eh.video_queue, NULL);
|
|
|
|
switch_thread_join(&st, eh.video_thread);
|
|
|
|
|
|
|
|
again:
|
|
|
|
av_init_packet(&pkt);
|
|
|
|
ret = avcodec_encode_video2(video_st.st->codec, &pkt, NULL, &got_packet);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Encoding Error %d\n", ret);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (got_packet) {
|
|
|
|
ret = write_frame(oc, &video_st.st->codec->time_base, video_st.st, &pkt);
|
|
|
|
av_free_packet(&pkt);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
av_write_trailer(oc);
|
|
|
|
switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE, "OK");
|
|
|
|
|
|
|
|
end:
|
|
|
|
|
|
|
|
if (oc) {
|
|
|
|
if (has_video) close_stream(oc, &video_st);
|
|
|
|
if (has_audio) close_stream(oc, &audio_st);
|
|
|
|
|
|
|
|
if (fmt) {
|
|
|
|
if (!(fmt->flags & AVFMT_NOFILE)) {
|
|
|
|
avio_close(oc->pb);
|
|
|
|
} else {
|
|
|
|
avformat_network_deinit();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* free the stream */
|
|
|
|
avformat_free_context(oc);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (timer.interval) {
|
|
|
|
switch_core_timer_destroy(&timer);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_core_media_end_video_function(session);
|
|
|
|
switch_core_session_set_read_codec(session, NULL);
|
|
|
|
switch_core_codec_destroy(&codec);
|
|
|
|
|
|
|
|
done:
|
|
|
|
switch_core_session_video_reset(session);
|
|
|
|
}
|
|
|
|
/* end of App interface */
|
|
|
|
|
|
|
|
|
|
|
|
/* API interface */
|
|
|
|
|
|
|
|
static char get_media_type_char(enum AVMediaType type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case AVMEDIA_TYPE_VIDEO: return 'V';
|
|
|
|
case AVMEDIA_TYPE_AUDIO: return 'A';
|
|
|
|
case AVMEDIA_TYPE_DATA: return 'D';
|
|
|
|
case AVMEDIA_TYPE_SUBTITLE: return 'S';
|
|
|
|
case AVMEDIA_TYPE_ATTACHMENT:return 'T';
|
|
|
|
default: return '?';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const AVCodec *next_codec_for_id(enum AVCodecID id, const AVCodec *prev,
|
|
|
|
int encoder)
|
|
|
|
{
|
|
|
|
while ((prev = av_codec_next(prev))) {
|
|
|
|
if (prev->id == id &&
|
|
|
|
(encoder ? av_codec_is_encoder(prev) : av_codec_is_decoder(prev)))
|
|
|
|
return prev;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compare_codec_desc(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
const AVCodecDescriptor * const *da = a;
|
|
|
|
const AVCodecDescriptor * const *db = b;
|
|
|
|
|
|
|
|
return (*da)->type != (*db)->type ? (*da)->type - (*db)->type :
|
|
|
|
strcmp((*da)->name, (*db)->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
|
|
|
|
{
|
|
|
|
const AVCodecDescriptor *desc = NULL;
|
|
|
|
const AVCodecDescriptor **codecs;
|
|
|
|
unsigned nb_codecs = 0, i = 0;
|
|
|
|
|
|
|
|
while ((desc = avcodec_descriptor_next(desc)))
|
|
|
|
nb_codecs++;
|
|
|
|
if (!(codecs = av_malloc(nb_codecs * sizeof(*codecs)))) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MEM Error!\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
desc = NULL;
|
|
|
|
while ((desc = avcodec_descriptor_next(desc)))
|
|
|
|
codecs[i++] = desc;
|
|
|
|
switch_assert(i == nb_codecs);
|
|
|
|
qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
|
|
|
|
*rcodecs = codecs;
|
|
|
|
return nb_codecs;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_codecs_for_id(switch_stream_handle_t *stream, enum AVCodecID id, int encoder)
|
|
|
|
{
|
|
|
|
const AVCodec *codec = NULL;
|
|
|
|
|
|
|
|
stream->write_function(stream, " (%s: ", encoder ? "encoders" : "decoders");
|
|
|
|
|
|
|
|
while ((codec = next_codec_for_id(id, codec, encoder)))
|
|
|
|
stream->write_function(stream, "%s ", codec->name);
|
|
|
|
|
|
|
|
stream->write_function(stream, ")");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int is_device(const AVClass *avclass)
|
|
|
|
{
|
|
|
|
#if 0
|
|
|
|
if (!avclass) return 0;
|
|
|
|
|
|
|
|
|
|
|
|
return avclass->category == AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT ||
|
|
|
|
avclass->category == AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT ||
|
|
|
|
avclass->category == AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT ||
|
|
|
|
avclass->category == AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT ||
|
|
|
|
avclass->category == AV_CLASS_CATEGORY_DEVICE_OUTPUT ||
|
|
|
|
avclass->category == AV_CLASS_CATEGORY_DEVICE_INPUT;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void show_formats(switch_stream_handle_t *stream) {
|
|
|
|
AVInputFormat *ifmt = NULL;
|
|
|
|
AVOutputFormat *ofmt = NULL;
|
|
|
|
const char *last_name;
|
|
|
|
// int is_dev;
|
|
|
|
|
|
|
|
stream->write_function(stream, "============= File Formats ==============================:\n"
|
|
|
|
" D. = Demuxing supported\n"
|
|
|
|
" .M = Muxing supported\n"
|
|
|
|
"----------------------\n");
|
|
|
|
|
|
|
|
last_name = "000";
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int decode = 0;
|
|
|
|
int encode = 0;
|
|
|
|
int is_dev = 0;
|
|
|
|
const char *name = NULL;
|
|
|
|
const char *long_name = NULL;
|
|
|
|
|
|
|
|
while ((ofmt = av_oformat_next(ofmt))) {
|
|
|
|
is_dev = is_device(ofmt->priv_class);
|
|
|
|
|
|
|
|
if ((name == NULL || strcmp(ofmt->name, name) < 0) &&
|
|
|
|
strcmp(ofmt->name, last_name) > 0) {
|
|
|
|
name = ofmt->name;
|
|
|
|
long_name = ofmt->long_name;
|
|
|
|
encode = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((ifmt = av_iformat_next(ifmt))) {
|
|
|
|
is_dev = is_device(ifmt->priv_class);
|
|
|
|
|
|
|
|
if ((name == NULL || strcmp(ifmt->name, name) < 0) &&
|
|
|
|
strcmp(ifmt->name, last_name) > 0) {
|
|
|
|
name = ifmt->name;
|
|
|
|
long_name = ifmt->long_name;
|
|
|
|
encode = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (name && strcmp(ifmt->name, name) == 0) decode = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (name == NULL) break;
|
|
|
|
|
|
|
|
last_name = name;
|
|
|
|
|
|
|
|
stream->write_function(stream, "%s%s%s %-15s %s\n",
|
|
|
|
is_dev ? "*" : " ",
|
|
|
|
decode ? "D" : " ",
|
|
|
|
encode ? "M" : " ",
|
|
|
|
name, long_name ? long_name:" ");
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void show_codecs(switch_stream_handle_t *stream)
|
|
|
|
{
|
|
|
|
const AVCodecDescriptor **codecs = NULL;
|
|
|
|
unsigned i, nb_codecs = get_codecs_sorted(&codecs);
|
|
|
|
|
|
|
|
stream->write_function(stream, "================ Codecs ===============================:\n"
|
|
|
|
" V..... = Video\n"
|
|
|
|
" A..... = Audio\n"
|
|
|
|
" S..... = Subtitle\n"
|
|
|
|
" .F.... = Frame-level multithreading\n"
|
|
|
|
" ..S... = Slice-level multithreading\n"
|
|
|
|
" ...X.. = Codec is experimental\n"
|
|
|
|
" ....B. = Supports draw_horiz_band\n"
|
|
|
|
" .....D = Supports direct rendering method 1\n"
|
|
|
|
" ----------------------------------------------\n\n");
|
|
|
|
|
|
|
|
for (i = 0; i < nb_codecs; i++) {
|
|
|
|
const AVCodecDescriptor *desc = codecs[i];
|
|
|
|
const AVCodec *codec = NULL;
|
|
|
|
|
|
|
|
stream->write_function(stream, " ");
|
|
|
|
stream->write_function(stream, avcodec_find_decoder(desc->id) ? "D" : ".");
|
|
|
|
stream->write_function(stream, avcodec_find_encoder(desc->id) ? "E" : ".");
|
|
|
|
|
|
|
|
stream->write_function(stream, "%c", get_media_type_char(desc->type));
|
|
|
|
stream->write_function(stream, (desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
|
|
|
|
stream->write_function(stream, (desc->props & AV_CODEC_PROP_LOSSY) ? "L" : ".");
|
|
|
|
stream->write_function(stream, (desc->props & AV_CODEC_PROP_LOSSLESS) ? "S" : ".");
|
|
|
|
|
|
|
|
stream->write_function(stream, " %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
|
|
|
|
|
|
|
|
/* print decoders/encoders when there's more than one or their
|
|
|
|
* names are different from codec name */
|
|
|
|
while ((codec = next_codec_for_id(desc->id, codec, 0))) {
|
|
|
|
if (strcmp(codec->name, desc->name)) {
|
|
|
|
print_codecs_for_id(stream ,desc->id, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
codec = NULL;
|
|
|
|
while ((codec = next_codec_for_id(desc->id, codec, 1))) {
|
|
|
|
if (strcmp(codec->name, desc->name)) {
|
|
|
|
print_codecs_for_id(stream, desc->id, 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
stream->write_function(stream, "\n");
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
av_free(codecs);
|
|
|
|
}
|
|
|
|
|
|
|
|
SWITCH_STANDARD_API(av_format_api_function)
|
|
|
|
{
|
|
|
|
if (zstr(cmd)) {
|
|
|
|
show_codecs(stream);
|
|
|
|
stream->write_function(stream, "\n");
|
|
|
|
show_formats(stream);
|
|
|
|
} else {
|
|
|
|
if (!strcmp(cmd, "show formats")) {
|
|
|
|
show_formats(stream);
|
|
|
|
} else if (!strcmp(cmd, "show codecs")) {
|
|
|
|
show_codecs(stream);
|
|
|
|
} else {
|
|
|
|
stream->write_function(stream, "Usage: ffmpeg show <formats|codecs>");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return SWITCH_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
|
|
|
|
{
|
|
|
|
switch_log_level_t switch_level = SWITCH_LOG_DEBUG;
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
/* naggy messages */
|
|
|
|
if (level == AV_LOG_DEBUG || level == AV_LOG_WARNING) return;
|
2015-03-17 15:52:01 +00:00
|
|
|
|
|
|
|
switch(level) {
|
|
|
|
case AV_LOG_QUIET: switch_level = SWITCH_LOG_CONSOLE; break;
|
|
|
|
case AV_LOG_PANIC: switch_level = SWITCH_LOG_ERROR; break;
|
|
|
|
case AV_LOG_FATAL: switch_level = SWITCH_LOG_ERROR; break;
|
|
|
|
case AV_LOG_ERROR: switch_level = SWITCH_LOG_ERROR; break;
|
|
|
|
case AV_LOG_WARNING: switch_level = SWITCH_LOG_WARNING; break;
|
|
|
|
case AV_LOG_INFO: switch_level = SWITCH_LOG_INFO; break;
|
|
|
|
case AV_LOG_VERBOSE: switch_level = SWITCH_LOG_INFO; break;
|
|
|
|
case AV_LOG_DEBUG: switch_level = SWITCH_LOG_DEBUG; break;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// switch_level = SWITCH_LOG_ERROR; // hardcoded for debug
|
|
|
|
switch_log_vprintf(SWITCH_CHANNEL_LOG_CLEAN, switch_level, fmt, vl);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* file interface */
|
|
|
|
|
|
|
|
struct av_file_context {
|
|
|
|
switch_memory_pool_t *pool;
|
|
|
|
switch_mutex_t *mutex;
|
|
|
|
switch_buffer_t *buf;
|
|
|
|
switch_buffer_t *audio_buffer;
|
|
|
|
switch_timer_t timer;
|
|
|
|
int offset;
|
|
|
|
int audio_start;
|
|
|
|
int vid_ready;
|
|
|
|
int audio_ready;
|
|
|
|
|
|
|
|
OutputStream video_st;
|
|
|
|
OutputStream audio_st;
|
|
|
|
AVFormatContext *oc;
|
|
|
|
AVCodec *audio_codec;
|
|
|
|
AVCodec *video_codec;
|
|
|
|
|
|
|
|
int has_audio;
|
|
|
|
int has_video;
|
|
|
|
|
|
|
|
record_helper_t eh;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct av_file_context av_file_context_t;
|
|
|
|
|
|
|
|
static switch_status_t av_file_open(switch_file_handle_t *handle, const char *path)
|
|
|
|
{
|
|
|
|
av_file_context_t *context;
|
|
|
|
char *ext;
|
|
|
|
unsigned int flags = 0;
|
|
|
|
const char *tmp = NULL;
|
|
|
|
AVOutputFormat *fmt;
|
|
|
|
const char *format = NULL;
|
|
|
|
int ret;
|
|
|
|
char file[1024];
|
|
|
|
|
|
|
|
switch_set_string(file, path);
|
2015-04-02 00:36:18 +00:00
|
|
|
|
|
|
|
if (switch_test_flag(handle, SWITCH_FILE_FLAG_READ)) {
|
|
|
|
return SWITCH_STATUS_FALSE;
|
|
|
|
}
|
|
|
|
|
2015-03-17 15:52:01 +00:00
|
|
|
if ((ext = strrchr((char *)path, '.')) == 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Format\n");
|
|
|
|
return SWITCH_STATUS_GENERR;
|
|
|
|
} else if (handle->stream_name && (!strcasecmp(handle->stream_name, "rtmp") || !strcasecmp(handle->stream_name, "youtube"))) {
|
|
|
|
format = "flv";
|
|
|
|
switch_snprintf(file, sizeof(file), "rtmp://%s", path);
|
|
|
|
}
|
|
|
|
|
|
|
|
ext++;
|
|
|
|
|
|
|
|
if ((context = (av_file_context_t *)switch_core_alloc(handle->memory_pool, sizeof(av_file_context_t))) == 0) {
|
|
|
|
return SWITCH_STATUS_MEMERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(context, 0, sizeof(av_file_context_t));
|
|
|
|
|
2015-04-09 23:18:45 +00:00
|
|
|
context->offset = DFT_RECORD_OFFSET;
|
2015-03-17 15:52:01 +00:00
|
|
|
if (handle->params && (tmp = switch_event_get_header(handle->params, "av_video_offset"))) {
|
|
|
|
context->offset = atoi(tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_mutex_init(&context->mutex, SWITCH_MUTEX_NESTED, handle->memory_pool);
|
|
|
|
switch_core_timer_init(&context->timer, "soft", 1, 1000, context->pool);
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "init timer\n");
|
|
|
|
|
|
|
|
if (switch_test_flag(handle, SWITCH_FILE_FLAG_WRITE)) {
|
|
|
|
flags |= SWITCH_FOPEN_WRITE | SWITCH_FOPEN_CREATE;
|
|
|
|
if (switch_test_flag(handle, SWITCH_FILE_WRITE_APPEND) || switch_test_flag(handle, SWITCH_FILE_WRITE_OVER)) {
|
|
|
|
flags |= SWITCH_FOPEN_READ;
|
|
|
|
} else {
|
|
|
|
flags |= SWITCH_FOPEN_TRUNCATE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (switch_test_flag(handle, SWITCH_FILE_FLAG_READ)) {
|
|
|
|
flags |= SWITCH_FOPEN_READ;
|
|
|
|
}
|
|
|
|
|
2015-04-02 00:36:18 +00:00
|
|
|
switch_buffer_create_dynamic(&context->audio_buffer, 512, 512, 0);
|
2015-03-17 15:52:01 +00:00
|
|
|
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "sample rate: %d, channels: %d\n", handle->samplerate, handle->channels);
|
|
|
|
|
|
|
|
av_register_all();
|
|
|
|
avformat_alloc_output_context2(&context->oc, NULL, format, (char *)file);
|
|
|
|
|
|
|
|
if (!context->oc) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Could not deduce output format from file extension\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt = context->oc->oformat;
|
|
|
|
|
|
|
|
/* open the output file, if needed */
|
|
|
|
if (!(fmt->flags & AVFMT_NOFILE)) {
|
|
|
|
ret = avio_open(&context->oc->pb, file, AVIO_FLAG_WRITE);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not open '%s': %s\n", file, get_error_text(ret));
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
avformat_network_init();
|
|
|
|
}
|
|
|
|
|
2015-04-02 00:36:18 +00:00
|
|
|
if (handle->mm.samplerate) {
|
|
|
|
handle->mm.samplerate = handle->samplerate;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!handle->mm.ab) {
|
|
|
|
handle->mm.ab = 128;
|
|
|
|
}
|
|
|
|
|
2015-03-17 15:52:01 +00:00
|
|
|
if (fmt->video_codec != AV_CODEC_ID_NONE) {
|
|
|
|
const AVCodecDescriptor *desc;
|
|
|
|
|
|
|
|
if (handle->stream_name && (!strcasecmp(handle->stream_name, "rtmp") || !strcasecmp(handle->stream_name, "youtube"))) {
|
|
|
|
if (fmt->video_codec != AV_CODEC_ID_H264 ) {
|
|
|
|
fmt->video_codec = AV_CODEC_ID_H264; // force H264
|
|
|
|
}
|
2015-04-20 20:35:58 +00:00
|
|
|
|
|
|
|
fmt->audio_codec = AV_CODEC_ID_AAC;
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
handle->mm.samplerate = 44100;
|
|
|
|
handle->mm.ab = 128;
|
|
|
|
|
2015-04-20 20:35:58 +00:00
|
|
|
if (!handle->mm.vb && handle->mm.vw && handle->mm.vh) {
|
2015-03-18 22:58:23 +00:00
|
|
|
switch(handle->mm.vh) {
|
|
|
|
case 240:
|
|
|
|
handle->mm.vb = 400;
|
|
|
|
break;
|
|
|
|
case 360:
|
|
|
|
handle->mm.vb = 750;
|
|
|
|
break;
|
|
|
|
case 480:
|
|
|
|
handle->mm.vb = 1000;
|
|
|
|
break;
|
|
|
|
case 720:
|
|
|
|
handle->mm.vb = 2500;
|
|
|
|
break;
|
|
|
|
case 1080:
|
|
|
|
handle->mm.vb = 4500;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
handle->mm.vb = (handle->mm.vw * handle->mm.vh) / 175;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (handle->mm.fps > 0.0f) {
|
|
|
|
handle->mm.keyint = (int) 2.0f * handle->mm.fps;
|
|
|
|
}
|
2015-03-17 15:52:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
desc = avcodec_descriptor_get(fmt->video_codec);
|
|
|
|
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "use video codec: [%d] %s (%s)\n", fmt->video_codec, desc->name, desc->long_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fmt->audio_codec != AV_CODEC_ID_NONE) {
|
|
|
|
context->audio_st.channels = handle->channels;
|
|
|
|
context->audio_st.sample_rate = handle->samplerate;
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
add_stream(&context->audio_st, context->oc, &context->audio_codec, fmt->audio_codec, &handle->mm);
|
2015-03-17 15:52:01 +00:00
|
|
|
if (open_audio(context->oc, context->audio_codec, &context->audio_st) != SWITCH_STATUS_SUCCESS) {
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
context->has_audio = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_dump_format(context->oc, 0, file, 1);
|
|
|
|
|
|
|
|
handle->format = 0;
|
|
|
|
handle->sections = 0;
|
|
|
|
handle->seekable = 0;
|
|
|
|
handle->speed = 0;
|
|
|
|
handle->pos = 0;
|
|
|
|
handle->private_info = context;
|
|
|
|
context->pool = handle->memory_pool;
|
|
|
|
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Opening File [%s] %dhz %s\n",
|
|
|
|
file, handle->samplerate, switch_test_flag(handle, SWITCH_FILE_FLAG_VIDEO) ? " with VIDEO" : "");
|
|
|
|
|
|
|
|
return SWITCH_STATUS_SUCCESS;
|
|
|
|
|
|
|
|
end:
|
|
|
|
|
|
|
|
return SWITCH_STATUS_GENERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t av_file_truncate(switch_file_handle_t *handle, int64_t offset)
|
|
|
|
{
|
|
|
|
return SWITCH_STATUS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t av_file_close(switch_file_handle_t *handle)
|
|
|
|
{
|
|
|
|
av_file_context_t *context = (av_file_context_t *)handle->private_info;
|
|
|
|
switch_status_t status;
|
|
|
|
|
|
|
|
if (context->eh.video_queue) {
|
|
|
|
switch_queue_push(context->eh.video_queue, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (context->eh.video_thread) {
|
|
|
|
switch_thread_join(&status, context->eh.video_thread);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (context->oc) {
|
|
|
|
av_write_trailer(context->oc);
|
|
|
|
|
|
|
|
if (context->has_video) close_stream(context->oc, &context->video_st);
|
|
|
|
if (context->has_audio) close_stream(context->oc, &context->audio_st);
|
|
|
|
|
|
|
|
if (!(context->oc->oformat->flags & AVFMT_NOFILE)) {
|
|
|
|
avio_close(context->oc->pb);
|
|
|
|
} else {
|
|
|
|
avformat_network_deinit();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* free the stream */
|
|
|
|
avformat_free_context(context->oc);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (context->timer.interval) {
|
|
|
|
switch_core_timer_destroy(&context->timer);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch_buffer_destroy(&context->audio_buffer);
|
|
|
|
|
|
|
|
return SWITCH_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t av_file_seek(switch_file_handle_t *handle, unsigned int *cur_sample, int64_t samples, int whence)
|
|
|
|
{
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "seek not implemented\n");
|
|
|
|
return SWITCH_STATUS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t av_file_read(switch_file_handle_t *handle, void *data, size_t *len)
|
|
|
|
{
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "read not implemented\n");
|
|
|
|
return SWITCH_STATUS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t av_file_write(switch_file_handle_t *handle, void *data, size_t *len)
|
|
|
|
{
|
|
|
|
|
|
|
|
uint32_t datalen = *len * 2 * handle->channels;
|
|
|
|
switch_status_t status = SWITCH_STATUS_SUCCESS;
|
|
|
|
// uint8_t buf[SWITCH_RECOMMENDED_BUFFER_SIZE] = { 0 }, *bp = buf;
|
|
|
|
// uint32_t encoded_rate;
|
|
|
|
av_file_context_t *context = (av_file_context_t *)handle->private_info;
|
|
|
|
// uint32_t size = 0;
|
|
|
|
uint32_t bytes;
|
|
|
|
int inuse;
|
|
|
|
|
|
|
|
if (!context->vid_ready) {
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (context->offset) {
|
|
|
|
char buf[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0};
|
|
|
|
switch_size_t samples = *len;
|
|
|
|
int fps = handle->samplerate / samples;
|
|
|
|
int lead_frames = (context->offset * fps) / 1000;
|
|
|
|
|
|
|
|
for (int x = 0; x < lead_frames; x++) {
|
|
|
|
switch_buffer_write(context->audio_buffer, buf, datalen);
|
|
|
|
}
|
|
|
|
context->offset = 0;
|
|
|
|
}
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
|
2015-03-17 15:52:01 +00:00
|
|
|
|
|
|
|
switch_buffer_write(context->audio_buffer, data, datalen);
|
|
|
|
bytes = context->audio_st.frame->nb_samples * 2 * context->audio_st.st->codec->channels;
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
//inuse = switch_buffer_inuse(context->audio_buffer);
|
|
|
|
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "inuse: %d samples: %d bytes: %d\n", inuse, context->audio_st.frame->nb_samples, bytes);
|
|
|
|
|
2015-04-02 00:36:18 +00:00
|
|
|
while ((inuse = switch_buffer_inuse(context->audio_buffer)) >= bytes * 5) {
|
2015-03-17 15:52:01 +00:00
|
|
|
AVPacket pkt = { 0 };
|
|
|
|
int got_packet = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
av_init_packet(&pkt);
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
if (context->audio_st.resample_ctx) { // need resample
|
2015-03-17 15:52:01 +00:00
|
|
|
int out_samples = avresample_get_out_samples(context->audio_st.resample_ctx, context->audio_st.frame->nb_samples);
|
|
|
|
|
|
|
|
av_frame_make_writable(context->audio_st.frame);
|
|
|
|
av_frame_make_writable(context->audio_st.tmp_frame);
|
|
|
|
switch_buffer_read(context->audio_buffer, context->audio_st.frame->data[0], bytes);
|
|
|
|
/* convert to destination format */
|
|
|
|
ret = avresample_convert(context->audio_st.resample_ctx,
|
|
|
|
(uint8_t **)context->audio_st.frame->data, 0, out_samples,
|
|
|
|
context->audio_st.tmp_frame->data, 0, context->audio_st.frame->nb_samples);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error while converting %d samples, error text: %s\n",
|
|
|
|
context->audio_st.frame->nb_samples, get_error_text(ret));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
context->audio_st.tmp_frame->pts = context->audio_st.next_pts;
|
|
|
|
context->audio_st.next_pts += context->audio_st.frame->nb_samples;
|
|
|
|
|
|
|
|
ret = avcodec_encode_audio2(context->audio_st.st->codec, &pkt, context->audio_st.tmp_frame, &got_packet);
|
|
|
|
} else {
|
|
|
|
av_frame_make_writable(context->audio_st.frame);
|
|
|
|
switch_buffer_read(context->audio_buffer, context->audio_st.frame->data[0], bytes);
|
|
|
|
context->audio_st.frame->pts = context->audio_st.next_pts;
|
|
|
|
context->audio_st.next_pts += context->audio_st.frame->nb_samples;
|
|
|
|
|
|
|
|
ret = avcodec_encode_audio2(context->audio_st.st->codec, &pkt, context->audio_st.frame, &got_packet);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Error encoding audio frame: %d\n", ret);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (got_packet) {
|
2015-03-18 22:58:23 +00:00
|
|
|
if (context->mutex) switch_mutex_lock(context->mutex);
|
2015-03-17 15:52:01 +00:00
|
|
|
ret = write_frame(context->oc, &context->audio_st.st->codec->time_base, context->audio_st.st, &pkt);
|
2015-03-18 22:58:23 +00:00
|
|
|
if (context->mutex) switch_mutex_unlock(context->mutex);
|
2015-03-17 15:52:01 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error while writing audio frame: %s\n", get_error_text(ret));
|
|
|
|
switch_goto_status(SWITCH_STATUS_FALSE, end);
|
|
|
|
}
|
|
|
|
}
|
2015-04-02 00:36:18 +00:00
|
|
|
|
|
|
|
break;
|
2015-03-17 15:52:01 +00:00
|
|
|
}
|
|
|
|
|
2015-03-18 22:58:23 +00:00
|
|
|
|
2015-03-17 15:52:01 +00:00
|
|
|
|
|
|
|
end:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t av_file_read_video(switch_file_handle_t *handle, switch_frame_t *frame, switch_video_read_flag_t flags)
|
|
|
|
{
|
|
|
|
return SWITCH_STATUS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t av_file_write_video(switch_file_handle_t *handle, switch_frame_t *frame)
|
|
|
|
{
|
|
|
|
switch_status_t status = SWITCH_STATUS_SUCCESS;
|
|
|
|
av_file_context_t *context = (av_file_context_t *)handle->private_info;
|
|
|
|
|
|
|
|
if (!frame->img) {
|
|
|
|
switch_goto_status(SWITCH_STATUS_FALSE, end);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!context->has_video) {
|
|
|
|
context->video_st.width = frame->img->d_w;
|
|
|
|
context->video_st.height = frame->img->d_h;
|
|
|
|
context->video_st.next_pts = switch_time_now() / 1000;
|
2015-03-18 22:58:23 +00:00
|
|
|
if (add_stream(&context->video_st, context->oc, &context->video_codec, context->oc->oformat->video_codec, &handle->mm) == SWITCH_STATUS_SUCCESS &&
|
2015-03-17 15:52:01 +00:00
|
|
|
open_video(context->oc, context->video_codec, &context->video_st) == SWITCH_STATUS_SUCCESS) {
|
|
|
|
|
|
|
|
char codec_str[256];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
avcodec_string(codec_str, sizeof(codec_str), context->video_st.st->codec, 1);
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "use video codec implementation %s\n", codec_str);
|
|
|
|
context->has_video = 1;
|
|
|
|
|
|
|
|
// av_dump_format(context->oc, 0, "/tmp/av.mp4", 1);
|
|
|
|
|
|
|
|
ret = avformat_write_header(context->oc, NULL);
|
|
|
|
if (ret < 0) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error occurred when opening output file: %s\n", get_error_text(ret));
|
|
|
|
switch_goto_status(SWITCH_STATUS_FALSE, end);
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error adding video stream\n");
|
|
|
|
switch_goto_status(SWITCH_STATUS_FALSE, end);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!context->vid_ready) {
|
|
|
|
switch_threadattr_t *thd_attr = NULL;
|
|
|
|
|
|
|
|
switch_mutex_init(&context->mutex, SWITCH_MUTEX_NESTED, handle->memory_pool);
|
|
|
|
context->eh.mutex = context->mutex;
|
|
|
|
context->eh.video_st = &context->video_st;
|
|
|
|
context->eh.oc = context->oc;
|
|
|
|
if (switch_core_timer_init(&context->timer, "soft", 1, 1, handle->memory_pool) != SWITCH_STATUS_SUCCESS) {
|
|
|
|
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timer Activation Fail\n");
|
|
|
|
switch_goto_status(SWITCH_STATUS_FALSE, end);
|
|
|
|
}
|
|
|
|
context->eh.timer = &context->timer;
|
|
|
|
switch_queue_create(&context->eh.video_queue, SWITCH_CORE_QUEUE_LEN, handle->memory_pool);
|
|
|
|
|
|
|
|
switch_threadattr_create(&thd_attr, handle->memory_pool);
|
|
|
|
//switch_threadattr_priority_set(thd_attr, SWITCH_PRI_REALTIME);
|
|
|
|
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
|
|
|
|
switch_thread_create(&context->eh.video_thread, thd_attr, video_thread_run, &context->eh, handle->memory_pool);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (context->has_video) {
|
|
|
|
switch_image_t *img = NULL;
|
|
|
|
|
|
|
|
switch_img_copy(frame->img, &img);
|
|
|
|
switch_queue_push(context->eh.video_queue, img);
|
|
|
|
}
|
|
|
|
|
|
|
|
context->vid_ready = 1;
|
|
|
|
|
|
|
|
end:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t av_file_set_string(switch_file_handle_t *handle, switch_audio_col_t col, const char *string)
|
|
|
|
{
|
|
|
|
return SWITCH_STATUS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static switch_status_t av_file_get_string(switch_file_handle_t *handle, switch_audio_col_t col, const char **string)
|
|
|
|
{
|
|
|
|
return SWITCH_STATUS_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *supported_formats[SWITCH_MAX_CODECS] = { 0 };
|
|
|
|
|
|
|
|
SWITCH_MODULE_LOAD_FUNCTION(mod_avformat_load)
|
|
|
|
{
|
|
|
|
switch_api_interface_t *api_interface;
|
|
|
|
switch_application_interface_t *app_interface;
|
|
|
|
switch_file_interface_t *file_interface;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
supported_formats[i++] = "av";
|
|
|
|
supported_formats[i++] = "rtmp";
|
|
|
|
supported_formats[i++] = "mp4";
|
|
|
|
|
|
|
|
/* connect my internal structure to the blank pointer passed to me */
|
|
|
|
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
|
|
|
|
|
|
|
|
file_interface = (switch_file_interface_t *)switch_loadable_module_create_interface(*module_interface, SWITCH_FILE_INTERFACE);
|
|
|
|
file_interface->interface_name = modname;
|
|
|
|
file_interface->extens = supported_formats;
|
|
|
|
file_interface->file_open = av_file_open;
|
|
|
|
file_interface->file_close = av_file_close;
|
|
|
|
file_interface->file_truncate = av_file_truncate;
|
|
|
|
file_interface->file_read = av_file_read;
|
|
|
|
file_interface->file_write = av_file_write;
|
|
|
|
file_interface->file_read_video = av_file_read_video;
|
|
|
|
file_interface->file_write_video = av_file_write_video;
|
|
|
|
file_interface->file_seek = av_file_seek;
|
|
|
|
file_interface->file_set_string = av_file_set_string;
|
|
|
|
file_interface->file_get_string = av_file_get_string;
|
|
|
|
|
|
|
|
SWITCH_ADD_API(api_interface, "av_format", "av information", av_format_api_function, "");
|
|
|
|
|
|
|
|
SWITCH_ADD_APP(app_interface, "record_av", "record video using libavformat", "record video using libavformat", record_av_function, "<file>", SAF_NONE);
|
|
|
|
|
|
|
|
av_log_set_callback(log_callback);
|
|
|
|
av_log_set_level(AV_LOG_INFO);
|
|
|
|
avformat_network_init();
|
|
|
|
av_register_all();
|
|
|
|
|
|
|
|
av_log(NULL, AV_LOG_INFO, "%s %d\n", "av_log callback installed, level=", av_log_get_level());
|
|
|
|
|
|
|
|
/* indicate that the module should continue to be loaded */
|
|
|
|
return SWITCH_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For Emacs:
|
|
|
|
* Local Variables:
|
|
|
|
* mode:c
|
|
|
|
* indent-tabs-mode:t
|
|
|
|
* tab-width:4
|
|
|
|
* c-basic-offset:4
|
|
|
|
* End:
|
|
|
|
* For VIM:
|
|
|
|
* vim:set softtabstop=4 shiftwidth=4 tabstop=4:
|
|
|
|
*/
|