AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,
URLContext *handle, int packet_size)
{
AVFormatContext *rtpctx;
int ret;
AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
if (!rtp_format)
return NULL;
/* Allocate an AVFormatContext for each output stream */
rtpctx = avformat_alloc_context();
if (!rtpctx)
return NULL;
rtpctx->oformat = rtp_format;
if (!av_new_stream(rtpctx, 0)) {
av_free(rtpctx);
return NULL;
}
/* Copy the max delay setting; the rtp muxer reads this. */
rtpctx->max_delay = s->max_delay;
/* Copy other stream parameters. */
rtpctx->streams[0]->sample_aspect_ratio = st->sample_aspect_ratio;
rtpctx->flags |= s->flags & AVFMT_FLAG_MP4A_LATM;
av_set_parameters(rtpctx, NULL);
/* Copy the rtpflags values straight through */
if (s->oformat->priv_class &&
av_find_opt(s->priv_data, "rtpflags", NULL, 0, 0))
av_set_int(rtpctx->priv_data, "rtpflags",
av_get_int(s->priv_data, "rtpflags", NULL));
/* Set the synchronized start time. */
rtpctx->start_time_realtime = s->start_time_realtime;
avcodec_copy_context(rtpctx->streams[0]->codec, st->codec);
if (handle) {
ffio_fdopen(&rtpctx->pb, handle);
} else
ffio_open_dyn_packet_buf(&rtpctx->pb, packet_size);
ret = avformat_write_header(rtpctx, NULL);
if (ret) {
if (handle) {
avio_close(rtpctx->pb);
} else {
uint8_t *ptr;
avio_close_dyn_buf(rtpctx->pb, &ptr);
av_free(ptr);
}
avformat_free_context(rtpctx);
return NULL;
}
return rtpctx;
}
void VideoStream::SetParameters()
{
/* set the output parameters (must be done even if no
parameters). */
if ( av_set_parameters(ofc, NULL) < 0 )
{
Panic( "Invalid output format parameters" );
}
//dump_format(ofc, 0, filename, 1);
}
status_t
AVFormatWriter::CommitHeader()
{
TRACE("AVFormatWriter::CommitHeader\n");
if (fContext == NULL)
return B_NO_INIT;
if (fHeaderWritten)
return B_NOT_ALLOWED;
// According to output_example.c, the output parameters must be set even
// if none are specified. In the example, this call is used after the
// streams have been created.
if (av_set_parameters(fContext, NULL) < 0)
return B_ERROR;
#if OPEN_CODEC_CONTEXT
for (unsigned i = 0; i < fContext->nb_streams; i++) {
AVStream* stream = fContext->streams[i];
// NOTE: Experimental, this should not be needed. Especially, since
// we have no idea (in the future) what CodecID some encoder uses,
// it may be an encoder from a different plugin.
AVCodecContext* codecContext = stream->codec;
AVCodec* codec = avcodec_find_encoder(codecContext->codec_id);
if (codec == NULL || avcodec_open(codecContext, codec) < 0) {
TRACE(" stream[%u] - failed to open AVCodecContext\n", i);
}
TRACE(" stream[%u] time_base: (%d/%d), codec->time_base: (%d/%d)\n",
i, stream->time_base.num, stream->time_base.den,
stream->codec->time_base.num, stream->codec->time_base.den);
}
#endif
int result = av_write_header(fContext);
if (result < 0)
TRACE(" av_write_header(): %d\n", result);
// We need to close the codecs we opened, even in case of failure.
fHeaderWritten = true;
#ifdef TRACE_AVFORMAT_WRITER
TRACE(" wrote header\n");
for (unsigned i = 0; i < fContext->nb_streams; i++) {
AVStream* stream = fContext->streams[i];
TRACE(" stream[%u] time_base: (%d/%d), codec->time_base: (%d/%d)\n",
i, stream->time_base.num, stream->time_base.den,
stream->codec->time_base.num, stream->codec->time_base.den);
}
#endif // TRACE_AVFORMAT_WRITER
return result == 0 ? B_OK : B_ERROR;
}
int FFMpegEncoder::init(FFMpegEncodeProfile *myProfile)
{
av_register_all();
profile = *myProfile;
videoEncodeBufSize = 1024000;
videoEncodeBuf = (unsigned char*)malloc(videoEncodeBufSize);
if (videoEncodeBuf == NULL)
return ERR_ALLOC_VIDEO_BUF;
audioEncodeBufSize = 4*128*1024;
audioEncodeBuf = (unsigned char*)malloc(audioEncodeBufSize);
if (audioEncodeBuf == NULL)
return ERR_ALLOC_AUDIO_BUF;
pFormatCtx = avformat_alloc_context();
int ret = -1;
ret = configOutput();
if (ret)
{
printf("error configuring output!\n");
return ret;
}
videoStream = NULL;
ret = configVideoStream();
if (ret)
{
printf("error configuring video!\n");
return ret;
}
audioStream = NULL;
ret = configAudioStream();
if (ret)
{
printf("error configuring audio!\n");
return ret;
}
av_set_parameters(pFormatCtx, NULL);
dump_format(pFormatCtx, 0, (char*)profile.outputFilename, 1);
av_write_header(pFormatCtx);
audioClock = 0;
videoClock = 0;
return 0;
//
}
void VideoStream::SetParameters()
{
/* set the output parameters (must be done even if no
parameters). */
#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(53, 4, 0)
if ( av_set_parameters(ofc, NULL) < 0 )
#else
if ( avformat_write_header(ofc, NULL) < 0 )
#endif
{
Panic( "Invalid output format parameters" );
}
//dump_format(ofc, 0, filename, 1);
}
bool CFFMPEGLoader::CreateMovie(const char *filename, const AVOutputFormat *format, const AVCodecContext *VideoCon, const AVCodecContext *AudioCon) {
if(!filename)
return false;
AVOutputFormat *fmt;
//*fmt=*format;
fmt = guess_format(NULL, filename, NULL);
pFormatCon = av_alloc_format_context();
if(!pFormatCon) {
cout<<"Error while allocating format context\n";
return false;
}
bOutput=true;
strcpy(pFormatCon->filename,filename);
pFormatCon->oformat=fmt;
pAudioStream=pVideoStream=NULL;
if (fmt->video_codec != CODEC_ID_NONE) {
pVideoStream = add_video_stream(pFormatCon, fmt->video_codec,VideoCon);
}
if (fmt->audio_codec != CODEC_ID_NONE) {
pAudioStream = add_audio_stream(pFormatCon, fmt->audio_codec,AudioCon);
}
if (av_set_parameters(pFormatCon, NULL) < 0) {
cout<<"Invalid output format parameters\n";
return false;
}
if (pVideoStream)
open_stream(pFormatCon, pVideoStream);
if (pAudioStream)
open_stream(pFormatCon, pAudioStream);
dump_format(pFormatCon, 0, filename, 1);
if (!(fmt->flags & AVFMT_NOFILE)) {
if (url_fopen(&pFormatCon->pb, filename, URL_WRONLY) < 0) {
cout<<"Could not open '%s'"<<filename<<endl;
return false;
}
}
/* write the stream header, if any */
av_write_header(pFormatCon);
return true;
}
bool OStreamVideoEncoder::encoder_initialize ()
{
char *encoding_str;
// register all codecs
av_register_all();
switch ( _encoding_type ) {
case OSTREAM_ENCODING_MJPEG:
encoding_str = "mjpeg";
_out_fmt = guess_format ( encoding_str, NULL, NULL);
if( !_out_fmt ) {
// DEBUG_PRINT( "Could not find suitable output format.\n");
return false;
}
break;
case OSTREAM_ENCODING_H263P:
encoding_str ="h263";
_out_fmt = guess_format ( encoding_str, NULL, NULL);
if( !_out_fmt ) {
// DEBUG_PRINT( "Could not find suitable output format.\n");
return false;
}
// specify the sub-codec we want to use. Without this we won't be able
// to stream H263P not use 640x480 videos
_out_fmt->video_codec = CODEC_ID_H263P;
break;
default:
// DEBUG_PRINT ("could not find known OSTREAM_ENCODING type.\n" );
break;
}
_out_fmt_context = av_alloc_format_context ();
if( !_out_fmt_context ) {
// DEBUG_PRINT( "Memory error.\n" );
return false;
}
// set output format of AVFormatContext
_out_fmt_context->oformat = _out_fmt;
// check if we had a correct video_codec
if ( _out_fmt->video_codec == CODEC_ID_NONE ) {
// DEBUG_PRINT( "CODEC_ID_NONE\n" );
return false;
}
// add the stream
if(!( _video_stream = create_video_stream( _out_fmt_context, _out_fmt->video_codec ) )) {
// DEBUG_PRINT( "error in adding stream\n" );
return false;
}
// set the output parameters (must be done even if no parameters)
if ( av_set_parameters( _out_fmt_context, NULL ) < 0 ) {
// DEBUG_PRINT( "Invalid output format parameters\n" );
return false;
}
// open codec associated with current video_stream
if ( !open_codec( _video_stream ) ) {
// DEBUG_PRINT( "could not open codec\n" );
return false;
}
// we should now create the frame on which we can store the converted bytes
// ready to be encoded
_ready_to_encode_frame = create_avframe( _video_stream->codec->pix_fmt,this->_video_width,this->_video_height );
if ( !_ready_to_encode_frame ) {
// DEBUG_PRINT( "Could not allocate encoded_frame\n" );
return false;
}
// we'll receive IplImage(s). This _opencv_frame will be converted to a stream-compatible
// AVFrame [see up _ready_to_encode_frame]
_opencv_frame = NULL;
return true;
}
/* This function opens an mpeg file using the new libavformat method. Both mpeg1
* and mpeg4 are supported. However, if the current ffmpeg version doesn't allow
* mpeg1 with non-standard framerate, the open will fail. Timelapse is a special
* case and is tested separately.
*/
struct ffmpeg *ffmpeg_open(char *ffmpeg_video_codec, char *filename,
unsigned char *y, unsigned char *u, unsigned char *v,
int width, int height, int rate, int bps, int vbr)
{
AVCodecContext *c;
AVCodec *codec;
struct ffmpeg *ffmpeg;
int is_mpeg1;
/* Allocate space for our ffmpeg structure. This structure contains all the
* codec and image information we need to generate movies.
* FIXME when motion exits we should close the movie to ensure that
* ffmpeg is freed.
*/
ffmpeg = mymalloc(sizeof(struct ffmpeg));
memset(ffmpeg, 0, sizeof(struct ffmpeg));
ffmpeg->vbr = vbr;
/* store codec name in ffmpeg->codec, with buffer overflow check */
snprintf(ffmpeg->codec, sizeof(ffmpeg->codec), "%s", ffmpeg_video_codec);
/* allocation the output media context */
ffmpeg->oc = av_mallocz(sizeof(AVFormatContext));
if (!ffmpeg->oc) {
motion_log(LOG_ERR, 1, "Memory error while allocating output media context");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* Setup output format */
ffmpeg->oc->oformat = get_oformat(ffmpeg_video_codec, filename);
if (!ffmpeg->oc->oformat) {
ffmpeg_cleanups(ffmpeg);
return NULL;
}
snprintf(ffmpeg->oc->filename, sizeof(ffmpeg->oc->filename), "%s", filename);
/* Create a new video stream and initialize the codecs */
ffmpeg->video_st = NULL;
if (ffmpeg->oc->oformat->video_codec != CODEC_ID_NONE) {
ffmpeg->video_st = av_new_stream(ffmpeg->oc, 0);
if (!ffmpeg->video_st) {
motion_log(LOG_ERR, 1, "av_new_stream - could not alloc stream");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
} else {
/* We did not get a proper video codec. */
motion_log(LOG_ERR, 0, "Failed to obtain a proper video codec");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
ffmpeg->c = c = AVSTREAM_CODEC_PTR(ffmpeg->video_st);
c->codec_id = ffmpeg->oc->oformat->video_codec;
c->codec_type = CODEC_TYPE_VIDEO;
is_mpeg1 = c->codec_id == CODEC_ID_MPEG1VIDEO;
if (strcmp(ffmpeg_video_codec, "ffv1") == 0)
c->strict_std_compliance = -2;
/* Uncomment to allow non-standard framerates. */
//c->strict_std_compliance = -1;
/* Set default parameters */
c->bit_rate = bps;
c->width = width;
c->height = height;
#if LIBAVCODEC_BUILD >= 4754
/* frame rate = 1/time_base, so we set 1/rate, not rate/1 */
c->time_base.num = 1;
c->time_base.den = rate;
#else
c->frame_rate = rate;
c->frame_rate_base = 1;
#endif /* LIBAVCODEC_BUILD >= 4754 */
if (debug_level >= CAMERA_DEBUG)
motion_log(LOG_DEBUG, 0, "%s FPS %d",__FUNCTION__,rate);
if (vbr)
c->flags |= CODEC_FLAG_QSCALE;
/* Set codec specific parameters. */
/* set intra frame distance in frames depending on codec */
c->gop_size = is_mpeg1 ? 10 : 12;
/* some formats want stream headers to be separate */
if (!strcmp(ffmpeg->oc->oformat->name, "mp4") ||
!strcmp(ffmpeg->oc->oformat->name, "mov") ||
!strcmp(ffmpeg->oc->oformat->name, "3gp")) {
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
/* set the output parameters (must be done even if no parameters). */
if (av_set_parameters(ffmpeg->oc, NULL) < 0) {
motion_log(LOG_ERR, 0, "ffmpeg av_set_parameters error: Invalid output format parameters");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* Dump the format settings. This shows how the various streams relate to each other */
//dump_format(ffmpeg->oc, 0, filename, 1);
/* Now that all the parameters are set, we can open the video
codec and allocate the necessary encode buffers */
codec = avcodec_find_encoder(c->codec_id);
if (!codec) {
motion_log(LOG_ERR, 1, "Codec not found");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* Set the picture format - need in ffmpeg starting round April-May 2005 */
c->pix_fmt = PIX_FMT_YUV420P;
/* Get a mutex lock. */
pthread_mutex_lock(&global_lock);
/* open the codec */
if (avcodec_open(c, codec) < 0) {
/* Release the lock. */
pthread_mutex_unlock(&global_lock);
motion_log(LOG_ERR, 1, "avcodec_open - could not open codec");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* Release the lock. */
pthread_mutex_unlock(&global_lock);
ffmpeg->video_outbuf = NULL;
if (!(ffmpeg->oc->oformat->flags & AVFMT_RAWPICTURE)) {
/* allocate output buffer */
/* XXX: API change will be done */
/* ffmpeg->video_outbuf_size = 20000; */
ffmpeg->video_outbuf_size = ffmpeg->c->width * 256;
ffmpeg->video_outbuf = mymalloc(ffmpeg->video_outbuf_size);
}
/* allocate the encoded raw picture */
ffmpeg->picture = avcodec_alloc_frame();
if (!ffmpeg->picture) {
motion_log(LOG_ERR, 1, "avcodec_alloc_frame - could not alloc frame");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* set variable bitrate if requested */
if (ffmpeg->vbr)
ffmpeg->picture->quality = ffmpeg->vbr;
/* set the frame data */
ffmpeg->picture->data[0] = y;
ffmpeg->picture->data[1] = u;
ffmpeg->picture->data[2] = v;
ffmpeg->picture->linesize[0] = ffmpeg->c->width;
ffmpeg->picture->linesize[1] = ffmpeg->c->width / 2;
ffmpeg->picture->linesize[2] = ffmpeg->c->width / 2;
/* open the output file, if needed */
if (!(ffmpeg->oc->oformat->flags & AVFMT_NOFILE)) {
char file_proto[256];
/* Use append file protocol for mpeg1, to get the append behavior from
* url_fopen, but no protocol (=> default) for other codecs.
*/
if (is_mpeg1)
snprintf(file_proto, sizeof(file_proto), APPEND_PROTO ":%s", filename);
else
snprintf(file_proto, sizeof(file_proto), "%s", filename);
if (url_fopen(&ffmpeg->oc->pb, file_proto, URL_WRONLY) < 0) {
/* path did not exist? */
if (errno == ENOENT) {
/* create path for file (don't use file_proto)... */
if (create_path(filename) == -1) {
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* and retry opening the file (use file_proto) */
if (url_fopen(&ffmpeg->oc->pb, file_proto, URL_WRONLY) < 0) {
motion_log(LOG_ERR, 1, "url_fopen - error opening file %s",filename);
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* Permission denied */
} else if (errno == EACCES) {
motion_log(LOG_ERR, 1,
"url_fopen - error opening file %s"
" ... check access rights to target directory", filename);
ffmpeg_cleanups(ffmpeg);
return NULL;
} else {
motion_log(LOG_ERR, 1, "Error opening file %s", filename);
ffmpeg_cleanups(ffmpeg);
return NULL;
}
}
}
/* write the stream header, if any */
av_write_header(ffmpeg->oc);
return ffmpeg;
}
MediaRet MediaRecorder::finish_setup(const char *fname)
{
if(av_set_parameters(oc, NULL) < 0) {
avformat_free_context(oc);
oc = NULL;
return MRET_ERR_NOCODEC;
}
if(audio_buf)
free(audio_buf);
if(audio_buf2)
free(audio_buf2);
audio_buf2 = NULL;
in_audio_buf2 = 0;
if(aud_st) {
frame_len = aud_st->codec->frame_size * 4;
sample_len = soundGetSampleRate() * 4 / 60;
switch(aud_st->codec->codec_id) {
case CODEC_ID_PCM_S16LE:
case CODEC_ID_PCM_S16BE:
case CODEC_ID_PCM_U16LE:
case CODEC_ID_PCM_U16BE:
frame_len = sample_len;
}
audio_buf = (u8 *)malloc(AUDIO_BUF_LEN);
if(!audio_buf) {
avformat_free_context(oc);
oc = NULL;
return MRET_ERR_NOMEM;
}
if(frame_len != sample_len && (frame_len > sample_len || sample_len % frame_len)) {
audio_buf2 = (u16 *)malloc(frame_len);
if(!audio_buf2) {
avformat_free_context(oc);
oc = NULL;
return MRET_ERR_NOMEM;
}
}
} else
audio_buf = NULL;
if(video_buf)
free(video_buf);
if(vid_st) {
video_buf = (u8 *)malloc(VIDEO_BUF_LEN);
if(!video_buf) {
avformat_free_context(oc);
oc = NULL;
return MRET_ERR_NOMEM;
}
} else {
video_buf = NULL;
}
if(!(oc->oformat->flags & AVFMT_NOFILE)) {
if(avio_open(&oc->pb, fname, URL_WRONLY) < 0) {
avformat_free_context(oc);
oc = NULL;
return MRET_ERR_FERR;
}
}
av_write_header(oc);
return MRET_OK;
}
bool AVFormatWriter::Init(void)
{
if (m_videoOutBuf)
delete [] m_videoOutBuf;
if (m_width && m_height)
m_videoOutBuf = new unsigned char[m_width * m_height * 2 + 10];
AVOutputFormat *fmt = av_guess_format(m_container.toAscii().constData(),
NULL, NULL);
if (!fmt)
{
LOG(VB_RECORD, LOG_ERR, LOC +
QString("Init(): Unable to guess AVOutputFormat from container %1")
.arg(m_container));
return false;
}
m_fmt = *fmt;
if (m_width && m_height)
{
m_avVideoCodec = avcodec_find_encoder_by_name(
m_videoCodec.toAscii().constData());
if (!m_avVideoCodec)
{
LOG(VB_RECORD, LOG_ERR, LOC +
QString("Init(): Unable to find video codec %1").arg(m_videoCodec));
return false;
}
m_fmt.video_codec = m_avVideoCodec->id;
}
else
m_fmt.video_codec = CODEC_ID_NONE;
m_avAudioCodec = avcodec_find_encoder_by_name(
m_audioCodec.toAscii().constData());
if (!m_avAudioCodec)
{
LOG(VB_RECORD, LOG_ERR, LOC +
QString("Init(): Unable to find audio codec %1").arg(m_audioCodec));
return false;
}
m_fmt.audio_codec = m_avAudioCodec->id;
m_ctx = avformat_alloc_context();
if (!m_ctx)
{
LOG(VB_RECORD, LOG_ERR,
LOC + "Init(): Unable to allocate AVFormatContext");
return false;
}
m_ctx->oformat = &m_fmt;
if (m_container == "mpegts")
m_ctx->packet_size = 2324;
snprintf(m_ctx->filename, sizeof(m_ctx->filename), "%s",
m_filename.toAscii().constData());
if (m_fmt.video_codec != CODEC_ID_NONE)
m_videoStream = AddVideoStream();
if (m_fmt.audio_codec != CODEC_ID_NONE)
m_audioStream = AddAudioStream();
m_pkt = new AVPacket;
if (!m_pkt)
{
LOG(VB_RECORD, LOG_ERR, LOC + "Init(): error allocating AVPacket");
return false;
}
if (av_set_parameters(m_ctx, NULL) < 0)
{
LOG(VB_RECORD, LOG_ERR, "Init(): Invalid output format parameters");
return false;
}
if ((m_videoStream) && (!OpenVideo()))
{
LOG(VB_RECORD, LOG_ERR, LOC + "Init(): OpenVideo() failed");
return false;
}
if ((m_audioStream) && (!OpenAudio()))
{
LOG(VB_RECORD, LOG_ERR, LOC + "Init(): OpenAudio() failed");
return false;
}
return true;
}
void create_video_file(const char*filename,int width,int height)
{
/* auto detect the output format from the name. default is
mpeg. */
//fmt = av_guess_format(NULL, filename, NULL);
#if (LIBAVFORMAT_VERSION_INT>=AV_VERSION_INT(52,81,0))
#define libavformat_guess_format av_guess_format
#else
#define libavformat_guess_format guess_format
#endif
fmt = libavformat_guess_format(NULL, filename, NULL);
if (!fmt) {
printf("Could not deduce output format from file extension: using MPEG.\n");
//fmt = av_guess_format("mpeg", NULL, NULL);
fmt = libavformat_guess_format("mpeg", NULL, NULL);
}
if (!fmt) {
fprintf(stderr, "Could not find suitable output format\n");
exit(1);
}
/* allocate the output media context */
oc = avformat_alloc_context();
if (!oc) {
fprintf(stderr, "Memory error\n");
exit(1);
}
oc->oformat = fmt;
snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
/* add the audio and video streams using the default format codecs
and initialize the codecs */
video_st = NULL;
if (fmt->video_codec != CODEC_ID_NONE) {
video_st = add_video_stream(oc, fmt->video_codec,width,height);
}
/* set the output parameters (must be done even if no
parameters). */
if (av_set_parameters(oc, NULL) < 0) {
fprintf(stderr, "Invalid output format parameters\n");
exit(1);
}
dump_format(oc, 0, filename, 1);
/* now that all the parameters are set, we can open the audio and
video codecs and allocate the necessary encode buffers */
if (video_st)
open_video(oc, video_st);
/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE)) {
if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
fprintf(stderr, "Could not open '%s'\n", filename);
exit(1);
}
}
/* write the stream header, if any */
av_write_header(oc);
}
SPDIFEncoder::SPDIFEncoder(QString muxer, AVCodecContext *ctx)
: m_complete(false), m_oc(NULL), m_stream(NULL), m_size(0)
{
QByteArray dev_ba = muxer.toAscii();
AVOutputFormat *fmt =
av_guess_format(dev_ba.constData(), NULL, NULL);
if (!(av_guess_format && avformat_alloc_context &&
av_new_stream && av_write_header && av_write_frame &&
av_write_trailer && av_set_parameters))
{
VERBOSE(VB_IMPORTANT, LOC_ERR + "Couldn't find libavformat");
return;
}
if (!avcodec_close)
{
VERBOSE(VB_IMPORTANT, LOC_ERR + "Couldn't find libavcodec");
return;
}
if (!(av_freep && av_alloc_put_byte))
{
VERBOSE(VB_IMPORTANT, LOC_ERR + "Couldn't find libavutil");
return;
}
if (!fmt)
{
VERBOSE(VB_AUDIO, LOC_ERR + "av_guess_format");
return;
}
m_oc = avformat_alloc_context();
if (!m_oc)
{
VERBOSE(VB_AUDIO, LOC_ERR + "avformat_alloc_context");
return;
}
m_oc->oformat = fmt;
if (av_set_parameters(m_oc, NULL) < 0)
{
VERBOSE(VB_AUDIO, LOC_ERR + "av_set_parameters");
Destroy();
return;
}
m_oc->pb = av_alloc_put_byte(m_buffer, sizeof(m_buffer), URL_RDONLY,
this, NULL, funcIO, NULL);
if (!m_oc->pb)
{
VERBOSE(VB_AUDIO, LOC_ERR + "av_alloc_put_byte");
Destroy();
return;
}
m_oc->pb->is_streamed = true;
m_oc->flags |= AVFMT_NOFILE | AVFMT_FLAG_IGNIDX;
if (av_set_parameters(m_oc, NULL) != 0)
{
VERBOSE(VB_AUDIO, LOC_ERR + "av_set_parameters");
Destroy();
return;
}
m_stream = av_new_stream(m_oc, 1);
if (!m_stream)
{
VERBOSE(VB_AUDIO, LOC_ERR + "av_new_stream");
Destroy();
return;
}
// copy without decoding or reencoding
m_stream->stream_copy = true;
AVCodecContext *codec = m_stream->codec;
codec->codec_type = ctx->codec_type;
codec->codec_id = ctx->codec_id;
codec->sample_rate = ctx->sample_rate;
codec->sample_fmt = ctx->sample_fmt;
codec->channels = ctx->channels;
codec->bit_rate = ctx->bit_rate;
codec->extradata = new uint8_t[ctx->extradata_size];
codec->extradata_size = ctx->extradata_size;
memcpy(codec->extradata, ctx->extradata, ctx->extradata_size);
av_write_header(m_oc);
VERBOSE(VB_AUDIO, LOC + QString("Creating %1 encoder (%2, %3Hz)")
.arg(muxer).arg(ff_codec_id_string((CodecID)codec->codec_type))
.arg(codec->sample_rate));
m_complete = true;
}
UINT CFlvUtils::InitStreams()
{
HRESULT hr = S_OK;
if (!m_szFlvFile)
hr = E_FAIL;
// Add the audio and video streams using the default format codecs
// and initialize the codecs
if (SUCCEEDED(hr))
{
if (m_pAVOutputFormat->video_codec != CODEC_ID_NONE)
{
//_tprintf(_T("### codec supports video.\n"));
m_pAVStreamVideo = AddVideoStream(m_pAVOutputFormat->video_codec);
if (m_pAVStreamVideo == NULL)
{
hr = E_FAIL;
_ftprintf(stderr, _T("Error in CFlvUtils::Init():\n Could not allocate video stream!\n"));
// TODO: error handling?
}
}
}
if (SUCCEEDED(hr))
{
if (m_pAVOutputFormat->audio_codec != CODEC_ID_NONE)
{
//_tprintf(_T("### codec supports audio.\n"));
m_pAVStreamAudio = AddAudioStream(m_pAVOutputFormat->audio_codec);
if (m_pAVStreamAudio == NULL)
{
hr = E_FAIL;
_ftprintf(stderr, _T("Error in CFlvUtils::Init():\n Could not allocate audio stream!\n"));
// TODO: error handling?
}
}
}
if (SUCCEEDED(hr))
{
// Set the output parameters (must be done even if no parameters).
if (av_set_parameters(m_pAVFormatContext, NULL) < 0)
{
_ftprintf(stderr, _T("Error in CFlvUtils::Init():\n Invalid output format parameters!\n"));
hr = E_FAIL;
// TODO: error handling?
}
}
if (SUCCEEDED(hr))
{
// Dump codec format info to the shell
dump_format(m_pAVFormatContext, 0, m_szFlvFile, 1);
}
// Now that all the parameters are set, we can open the audio and
// video codecs and allocate the necessary encode buffers
if (SUCCEEDED(hr))
{
if (m_pAVStreamVideo)
hr = OpenVideoStream();
}
if (SUCCEEDED(hr))
{
if (m_pAVStreamAudio)
hr = OpenAudioStream();
}
return hr;
}
/// close video output stream and free associated memory
void CvVideoWriter_FFMPEG::close()
{
unsigned i;
// nothing to do if already released
if ( !picture )
return;
/* no more frame to compress. The codec has a latency of a few
frames if using B frames, so we get the last frames by
passing the same picture again */
// TODO -- do we need to account for latency here?
/* write the trailer, if any */
av_write_trailer(oc);
// free pictures
#if LIBAVFORMAT_BUILD > 4628
if( video_st->codec->pix_fmt != input_pix_fmt){
#else
if( video_st->codec.pix_fmt != input_pix_fmt){
#endif
cvFree(&(picture->data[0]));
}
av_free(picture);
if (input_picture) {
av_free(input_picture);
}
/* close codec */
#if LIBAVFORMAT_BUILD > 4628
avcodec_close(video_st->codec);
#else
avcodec_close(&(video_st->codec));
#endif
av_free(outbuf);
/* free the streams */
for(i = 0; i < oc->nb_streams; i++) {
av_freep(&oc->streams[i]->codec);
av_freep(&oc->streams[i]);
}
if (!(fmt->flags & AVFMT_NOFILE)) {
/* close the output file */
#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(49<<8)+0)
url_fclose(oc->pb);
#else
url_fclose(&oc->pb);
#endif
}
/* free the stream */
av_free(oc);
cvReleaseImage( &temp_image );
init();
}
/// Create a video writer object that uses FFMPEG
bool CvVideoWriter_FFMPEG::open( const char * filename, int fourcc,
double fps, CvSize frameSize, bool is_color )
{
CV_FUNCNAME("CvVideoWriter_FFMPEG::open");
CodecID codec_id = CODEC_ID_NONE;
int err, codec_pix_fmt, bitrate_scale=64;
__BEGIN__;
close();
// check arguments
assert (filename);
assert (fps > 0);
assert (frameSize.width > 0 && frameSize.height > 0);
// tell FFMPEG to register codecs
av_register_all ();
/* auto detect the output format from the name and fourcc code. */
fmt = guess_format(NULL, filename, NULL);
if (!fmt) {
CV_ERROR( CV_StsUnsupportedFormat, "FFMPEG does not recognize the given file extension");
}
/* determine optimal pixel format */
if (is_color) {
input_pix_fmt = PIX_FMT_BGR24;
}
else {
input_pix_fmt = PIX_FMT_GRAY8;
}
// alloc memory for context
oc = av_alloc_format_context();
assert (oc);
/* set file name */
oc->oformat = fmt;
snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
/* set some options */
oc->max_delay = (int)(0.7*AV_TIME_BASE); /* This reduces buffer underrun warnings with MPEG */
/* Lookup codec_id for given fourcc */
#if LIBAVCODEC_VERSION_INT<((51<<16)+(49<<8)+0)
if( (codec_id = codec_get_bmp_id( fourcc )) == CODEC_ID_NONE ){
CV_ERROR( CV_StsUnsupportedFormat,
"FFMPEG could not find a codec matching the given FOURCC code. Use fourcc=CV_FOURCC_DEFAULT for auto selection." );
}
#else
{
const struct AVCodecTag * tags[] = { codec_bmp_tags, NULL};
if( (codec_id = av_codec_get_id(tags, fourcc)) == CODEC_ID_NONE ){
CV_ERROR( CV_StsUnsupportedFormat,
"FFMPEG could not find a codec matching the given FOURCC code. Use fourcc=CV_FOURCC_DEFAULT for auto selection." );
}
}
#endif
// set a few optimal pixel formats for lossless codecs of interest..
switch (codec_id) {
#if LIBAVCODEC_VERSION_INT>((50<<16)+(1<<8)+0)
case CODEC_ID_JPEGLS:
// BGR24 or GRAY8 depending on is_color...
codec_pix_fmt = input_pix_fmt;
break;
#endif
case CODEC_ID_HUFFYUV:
codec_pix_fmt = PIX_FMT_YUV422P;
break;
case CODEC_ID_MJPEG:
case CODEC_ID_LJPEG:
codec_pix_fmt = PIX_FMT_YUVJ420P;
bitrate_scale = 128;
break;
case CODEC_ID_RAWVIDEO:
default:
// good for lossy formats, MPEG, etc.
codec_pix_fmt = PIX_FMT_YUV420P;
break;
}
// TODO -- safe to ignore output audio stream?
video_st = icv_add_video_stream_FFMPEG(oc, codec_id,
frameSize.width, frameSize.height, frameSize.width*frameSize.height*bitrate_scale,
fps, codec_pix_fmt);
/* set the output parameters (must be done even if no
parameters). */
if (av_set_parameters(oc, NULL) < 0) {
CV_ERROR(CV_StsBadArg, "Invalid output format parameters");
}
dump_format(oc, 0, filename, 1);
/* now that all the parameters are set, we can open the audio and
video codecs and allocate the necessary encode buffers */
if (!video_st){
CV_ERROR(CV_StsBadArg, "Couldn't open video stream");
}
AVCodec *codec;
AVCodecContext *c;
#if LIBAVFORMAT_BUILD > 4628
c = (video_st->codec);
#else
c = &(video_st->codec);
#endif
c->codec_tag = fourcc;
/* find the video encoder */
codec = avcodec_find_encoder(c->codec_id);
if (!codec) {
CV_ERROR(CV_StsBadArg, "codec not found");
}
/* open the codec */
if ( (err=avcodec_open(c, codec)) < 0) {
char errtext[256];
sprintf(errtext, "Could not open codec '%s': %s", codec->name, icvFFMPEGErrStr(err));
CV_ERROR(CV_StsBadArg, errtext);
}
outbuf = NULL;
if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
/* allocate output buffer */
/* assume we will never get codec output with more than 4 bytes per pixel... */
outbuf_size = frameSize.width*frameSize.height*4;
outbuf = (uint8_t *) av_malloc(outbuf_size);
}
bool need_color_convert;
need_color_convert = (c->pix_fmt != input_pix_fmt);
/* allocate the encoded raw picture */
picture = icv_alloc_picture_FFMPEG(c->pix_fmt, c->width, c->height, need_color_convert);
if (!picture) {
CV_ERROR(CV_StsNoMem, "Could not allocate picture");
}
/* if the output format is not our input format, then a temporary
picture of the input format is needed too. It is then converted
to the required output format */
input_picture = NULL;
if ( need_color_convert ) {
input_picture = icv_alloc_picture_FFMPEG(input_pix_fmt, c->width, c->height, false);
if (!input_picture) {
CV_ERROR(CV_StsNoMem, "Could not allocate picture");
}
}
/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE)) {
if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
CV_ERROR(CV_StsBadArg, "Couldn't open output file for writing");
}
}
/* write the stream header, if any */
av_write_header( oc );
__END__;
return true;
}
/**
* ffmpeg_open
* Opens an mpeg file using the new libavformat method. Both mpeg1
* and mpeg4 are supported. However, if the current ffmpeg version doesn't allow
* mpeg1 with non-standard framerate, the open will fail. Timelapse is a special
* case and is tested separately.
*
* Returns
* A new allocated ffmpeg struct or NULL if any error happens.
*/
struct ffmpeg *ffmpeg_open(char *ffmpeg_video_codec, char *filename,
unsigned char *y, unsigned char *u, unsigned char *v,
int width, int height, int rate, int bps, int vbr)
{
AVCodecContext *c;
AVCodec *codec;
struct ffmpeg *ffmpeg;
int is_mpeg1;
int ret;
/*
* Allocate space for our ffmpeg structure. This structure contains all the
* codec and image information we need to generate movies.
* FIXME when motion exits we should close the movie to ensure that
* ffmpeg is freed.
*/
ffmpeg = mymalloc(sizeof(struct ffmpeg));
memset(ffmpeg, 0, sizeof(struct ffmpeg));
ffmpeg->vbr = vbr;
/* Store codec name in ffmpeg->codec, with buffer overflow check. */
snprintf(ffmpeg->codec, sizeof(ffmpeg->codec), "%s", ffmpeg_video_codec);
/* Allocation the output media context. */
#ifdef have_avformat_alloc_context
ffmpeg->oc = avformat_alloc_context();
#elif defined have_av_avformat_alloc_context
ffmpeg->oc = av_alloc_format_context();
#else
ffmpeg->oc = av_mallocz(sizeof(AVFormatContext));
#endif
if (!ffmpeg->oc) {
MOTION_LOG(ERR, TYPE_ENCODER, SHOW_ERRNO, "%s: Memory error while allocating"
" output media context");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* Setup output format */
ffmpeg->oc->oformat = get_oformat(ffmpeg_video_codec, filename);
if (!ffmpeg->oc->oformat) {
ffmpeg_cleanups(ffmpeg);
return NULL;
}
snprintf(ffmpeg->oc->filename, sizeof(ffmpeg->oc->filename), "%s", filename);
/* Create a new video stream and initialize the codecs. */
ffmpeg->video_st = NULL;
if (ffmpeg->oc->oformat->video_codec != CODEC_ID_NONE) {
#if defined FF_API_NEW_AVIO
ffmpeg->video_st = avformat_new_stream(ffmpeg->oc, NULL /* Codec */);
#else
ffmpeg->video_st = av_new_stream(ffmpeg->oc, 0);
#endif
if (!ffmpeg->video_st) {
MOTION_LOG(ERR, TYPE_ENCODER, SHOW_ERRNO, "%s: av_new_stream - could"
" not alloc stream");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
} else {
/* We did not get a proper video codec. */
MOTION_LOG(ERR, TYPE_ENCODER, NO_ERRNO, "%s: Failed to obtain a proper"
" video codec");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
ffmpeg->c = c = AVSTREAM_CODEC_PTR(ffmpeg->video_st);
c->codec_id = ffmpeg->oc->oformat->video_codec;
#if LIBAVCODEC_VERSION_MAJOR < 53
c->codec_type = CODEC_TYPE_VIDEO;
#else
c->codec_type = AVMEDIA_TYPE_VIDEO;
#endif
is_mpeg1 = c->codec_id == CODEC_ID_MPEG1VIDEO;
if (strcmp(ffmpeg_video_codec, "ffv1") == 0)
c->strict_std_compliance = -2;
/* Uncomment to allow non-standard framerates. */
//c->strict_std_compliance = -1;
/* Set default parameters */
c->bit_rate = bps;
c->width = width;
c->height = height;
#if LIBAVCODEC_BUILD >= 4754
/* Frame rate = 1/time_base, so we set 1/rate, not rate/1 */
c->time_base.num = 1;
c->time_base.den = rate;
#else
c->frame_rate = rate;
c->frame_rate_base = 1;
#endif /* LIBAVCODEC_BUILD >= 4754 */
MOTION_LOG(INF, TYPE_ENCODER, NO_ERRNO, "%s FPS %d",
rate);
if (vbr)
c->flags |= CODEC_FLAG_QSCALE;
/*
* Set codec specific parameters.
* Set intra frame distance in frames depending on codec.
*/
c->gop_size = is_mpeg1 ? 10 : 12;
/* Some formats want stream headers to be separate. */
if (!strcmp(ffmpeg->oc->oformat->name, "mp4") ||
!strcmp(ffmpeg->oc->oformat->name, "mov") ||
!strcmp(ffmpeg->oc->oformat->name, "3gp")) {
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
#if defined FF_API_NEW_AVIO
// pass the options to avformat_write_header directly
#else
/* Set the output parameters (must be done even if no parameters). */
if (av_set_parameters(ffmpeg->oc, NULL) < 0) {
MOTION_LOG(ERR, TYPE_ENCODER, NO_ERRNO, "%s: av_set_parameters error:"
" Invalid output format parameters");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
#endif
/* Dump the format settings. This shows how the various streams relate to each other. */
//dump_format(ffmpeg->oc, 0, filename, 1);
/*
* Now that all the parameters are set, we can open the video
* codec and allocate the necessary encode buffers.
*/
codec = avcodec_find_encoder(c->codec_id);
if (!codec) {
MOTION_LOG(ERR, TYPE_ENCODER, NO_ERRNO, "%s: Codec %s not found",
ffmpeg_video_codec);
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* Set the picture format - need in ffmpeg starting round April-May 2005 */
c->pix_fmt = PIX_FMT_YUV420P;
/* Get a mutex lock. */
pthread_mutex_lock(&global_lock);
/* Open the codec */
#if defined FF_API_NEW_AVIO
ret = avcodec_open2(c, codec, NULL /* options */ );
#else
ret = avcodec_open(c, codec);
#endif
if (ret < 0) {
/* Release the lock. */
pthread_mutex_unlock(&global_lock);
MOTION_LOG(ERR, TYPE_ENCODER, NO_ERRNO, "%s: avcodec_open - could not open codec %s",
ffmpeg_video_codec);
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* Release the lock. */
pthread_mutex_unlock(&global_lock);
ffmpeg->video_outbuf = NULL;
if (!(ffmpeg->oc->oformat->flags & AVFMT_RAWPICTURE)) {
/*
* Allocate output buffer
* XXX: API change will be done
* ffmpeg->video_outbuf_size = 200000
*/
ffmpeg->video_outbuf_size = ffmpeg->c->width * 512;
ffmpeg->video_outbuf = mymalloc(ffmpeg->video_outbuf_size);
}
/* Allocate the encoded raw picture. */
ffmpeg->picture = avcodec_alloc_frame();
if (!ffmpeg->picture) {
MOTION_LOG(ERR, TYPE_ENCODER, NO_ERRNO, "%s: avcodec_alloc_frame -"
" could not alloc frame");
ffmpeg_cleanups(ffmpeg);
return NULL;
}
/* Set variable bitrate if requested. */
if (ffmpeg->vbr)
ffmpeg->picture->quality = ffmpeg->vbr;
/* Set the frame data. */
ffmpeg->picture->data[0] = y;
ffmpeg->picture->data[1] = u;
ffmpeg->picture->data[2] = v;
ffmpeg->picture->linesize[0] = ffmpeg->c->width;
ffmpeg->picture->linesize[1] = ffmpeg->c->width / 2;
ffmpeg->picture->linesize[2] = ffmpeg->c->width / 2;
/* Open the output file, if needed. */
if (!(ffmpeg->oc->oformat->flags & AVFMT_NOFILE)) {
char file_proto[256];
/*
* Use append file protocol for mpeg1, to get the append behavior from
* url_fopen, but no protocol (=> default) for other codecs.
*/
if (is_mpeg1)
#if defined FF_API_NEW_AVIO
snprintf(file_proto, sizeof(file_proto), "%s", filename);
#else
snprintf(file_proto, sizeof(file_proto), APPEND_PROTO ":%s", filename);
#endif
else
static GstFlowReturn
gst_ffmpegmux_collected (GstCollectPads * pads, gpointer user_data)
{
GstFFMpegMux *ffmpegmux = (GstFFMpegMux *) user_data;
GSList *collected;
GstFFMpegMuxPad *best_pad;
GstClockTime best_time;
const GstTagList *tags;
/* open "file" (gstreamer protocol to next element) */
if (!ffmpegmux->opened) {
int open_flags = URL_WRONLY;
/* we do need all streams to have started capsnego,
* or things will go horribly wrong */
for (collected = ffmpegmux->collect->data; collected;
collected = g_slist_next (collected)) {
GstFFMpegMuxPad *collect_pad = (GstFFMpegMuxPad *) collected->data;
AVStream *st = ffmpegmux->context->streams[collect_pad->padnum];
/* check whether the pad has successfully completed capsnego */
if (st->codec->codec_id == CODEC_ID_NONE) {
GST_ELEMENT_ERROR (ffmpegmux, CORE, NEGOTIATION, (NULL),
("no caps set on stream %d (%s)", collect_pad->padnum,
(st->codec->codec_type == CODEC_TYPE_VIDEO) ?
"video" : "audio"));
return GST_FLOW_ERROR;
}
/* set framerate for audio */
if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
switch (st->codec->codec_id) {
case CODEC_ID_PCM_S16LE:
case CODEC_ID_PCM_S16BE:
case CODEC_ID_PCM_U16LE:
case CODEC_ID_PCM_U16BE:
case CODEC_ID_PCM_S8:
case CODEC_ID_PCM_U8:
st->codec->frame_size = 1;
break;
default:
{
GstBuffer *buffer;
/* FIXME : This doesn't work for RAW AUDIO...
* in fact I'm wondering if it even works for any kind of audio... */
buffer = gst_collect_pads_peek (ffmpegmux->collect,
(GstCollectData *) collect_pad);
if (buffer) {
st->codec->frame_size =
st->codec->sample_rate *
GST_BUFFER_DURATION (buffer) / GST_SECOND;
gst_buffer_unref (buffer);
}
}
}
}
}
/* tags */
tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (ffmpegmux));
if (tags) {
gint i;
gchar *s;
/* get the interesting ones */
if (gst_tag_list_get_string (tags, GST_TAG_TITLE, &s)) {
strncpy (ffmpegmux->context->title, s,
sizeof (ffmpegmux->context->title));
}
if (gst_tag_list_get_string (tags, GST_TAG_ARTIST, &s)) {
strncpy (ffmpegmux->context->author, s,
sizeof (ffmpegmux->context->author));
}
if (gst_tag_list_get_string (tags, GST_TAG_COPYRIGHT, &s)) {
strncpy (ffmpegmux->context->copyright, s,
sizeof (ffmpegmux->context->copyright));
}
if (gst_tag_list_get_string (tags, GST_TAG_COMMENT, &s)) {
strncpy (ffmpegmux->context->comment, s,
sizeof (ffmpegmux->context->comment));
}
if (gst_tag_list_get_string (tags, GST_TAG_ALBUM, &s)) {
strncpy (ffmpegmux->context->album, s,
sizeof (ffmpegmux->context->album));
}
if (gst_tag_list_get_string (tags, GST_TAG_GENRE, &s)) {
strncpy (ffmpegmux->context->genre, s,
sizeof (ffmpegmux->context->genre));
}
if (gst_tag_list_get_int (tags, GST_TAG_TRACK_NUMBER, &i)) {
ffmpegmux->context->track = i;
}
}
/* set the streamheader flag for gstffmpegprotocol if codec supports it */
if (!strcmp (ffmpegmux->context->oformat->name, "flv")) {
open_flags |= GST_FFMPEG_URL_STREAMHEADER;
}
if (url_fopen (&ffmpegmux->context->pb,
ffmpegmux->context->filename, open_flags) < 0) {
GST_ELEMENT_ERROR (ffmpegmux, LIBRARY, TOO_LAZY, (NULL),
("Failed to open stream context in ffmux"));
return GST_FLOW_ERROR;
}
if (av_set_parameters (ffmpegmux->context, NULL) < 0) {
GST_ELEMENT_ERROR (ffmpegmux, LIBRARY, INIT, (NULL),
("Failed to initialize muxer"));
return GST_FLOW_ERROR;
}
/* now open the mux format */
if (av_write_header (ffmpegmux->context) < 0) {
GST_ELEMENT_ERROR (ffmpegmux, LIBRARY, SETTINGS, (NULL),
("Failed to write file header - check codec settings"));
return GST_FLOW_ERROR;
}
/* we're now opened */
ffmpegmux->opened = TRUE;
/* flush the header so it will be used as streamheader */
put_flush_packet (ffmpegmux->context->pb);
}
/* take the one with earliest timestamp,
* and push it forward */
best_pad = NULL;
best_time = GST_CLOCK_TIME_NONE;
for (collected = ffmpegmux->collect->data; collected;
collected = g_slist_next (collected)) {
GstFFMpegMuxPad *collect_pad = (GstFFMpegMuxPad *) collected->data;
GstBuffer *buffer = gst_collect_pads_peek (ffmpegmux->collect,
(GstCollectData *) collect_pad);
/* if there's no buffer, just continue */
if (buffer == NULL) {
continue;
}
/* if we have no buffer yet, just use the first one */
if (best_pad == NULL) {
best_pad = collect_pad;
best_time = GST_BUFFER_TIMESTAMP (buffer);
goto next_pad;
}
/* if we do have one, only use this one if it's older */
if (GST_BUFFER_TIMESTAMP (buffer) < best_time) {
best_time = GST_BUFFER_TIMESTAMP (buffer);
best_pad = collect_pad;
}
next_pad:
gst_buffer_unref (buffer);
/* Mux buffers with invalid timestamp first */
if (!GST_CLOCK_TIME_IS_VALID (best_time))
break;
}
/* now handle the buffer, or signal EOS if we have
* no buffers left */
if (best_pad != NULL) {
GstBuffer *buf;
AVPacket pkt;
gboolean need_free = FALSE;
/* push out current buffer */
buf = gst_collect_pads_pop (ffmpegmux->collect,
(GstCollectData *) best_pad);
ffmpegmux->context->streams[best_pad->padnum]->codec->frame_number++;
/* set time */
pkt.pts = gst_ffmpeg_time_gst_to_ff (GST_BUFFER_TIMESTAMP (buf),
ffmpegmux->context->streams[best_pad->padnum]->time_base);
pkt.dts = pkt.pts;
if (strcmp (ffmpegmux->context->oformat->name, "gif") == 0) {
AVStream *st = ffmpegmux->context->streams[best_pad->padnum];
AVPicture src, dst;
need_free = TRUE;
pkt.size = st->codec->width * st->codec->height * 3;
pkt.data = g_malloc (pkt.size);
dst.data[0] = pkt.data;
dst.data[1] = NULL;
dst.data[2] = NULL;
dst.linesize[0] = st->codec->width * 3;
gst_ffmpeg_avpicture_fill (&src, GST_BUFFER_DATA (buf),
PIX_FMT_RGB24, st->codec->width, st->codec->height);
av_picture_copy (&dst, &src, PIX_FMT_RGB24,
st->codec->width, st->codec->height);
} else {
pkt.data = GST_BUFFER_DATA (buf);
pkt.size = GST_BUFFER_SIZE (buf);
}
pkt.stream_index = best_pad->padnum;
pkt.flags = 0;
if (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT))
pkt.flags |= PKT_FLAG_KEY;
if (GST_BUFFER_DURATION_IS_VALID (buf))
pkt.duration =
gst_ffmpeg_time_gst_to_ff (GST_BUFFER_DURATION (buf),
ffmpegmux->context->streams[best_pad->padnum]->time_base);
else
pkt.duration = 0;
av_write_frame (ffmpegmux->context, &pkt);
gst_buffer_unref (buf);
if (need_free)
g_free (pkt.data);
} else {
/* close down */
av_write_trailer (ffmpegmux->context);
ffmpegmux->opened = FALSE;
put_flush_packet (ffmpegmux->context->pb);
url_fclose (ffmpegmux->context->pb);
gst_pad_push_event (ffmpegmux->srcpad, gst_event_new_eos ());
return GST_FLOW_UNEXPECTED;
}
return GST_FLOW_OK;
}
int VideoFFmpegWriter::execute( boost::uint8_t* in_buffer, int in_width, int in_height, PixelFormat in_pixelFormat )
{
_error = IGNORE_FINISH;
AVOutputFormat* fmt = 0;
fmt = guess_format( _format.c_str(), NULL, NULL );
if( !fmt )
{
fmt = guess_format( NULL, filename().c_str(), NULL );
if( !fmt )
{
std::cerr << "ffmpegWriter: could not deduce output format from file extension." << std::endl;
return false;
}
}
if( !_avformatOptions )
_avformatOptions = avformat_alloc_context();
_avformatOptions->oformat = fmt;
snprintf( _avformatOptions->filename, sizeof( _avformatOptions->filename ), "%s", filename().c_str() );
if( !_stream )
{
_stream = av_new_stream( _avformatOptions, 0 );
if( !_stream )
{
std::cout << "ffmpegWriter: out of memory." << std::endl;
return false;
}
CodecID codecId = fmt->video_codec;
AVCodec* userCodec = avcodec_find_encoder_by_name( _codec.c_str() );
if( userCodec )
codecId = userCodec->id;
_stream->codec->codec_id = codecId;
_stream->codec->codec_type = CODEC_TYPE_VIDEO;
_stream->codec->bit_rate = _bitRate;
_stream->codec->bit_rate_tolerance = _bitRateTolerance;
_stream->codec->width = width();
_stream->codec->height = height();
_stream->codec->time_base = av_d2q( 1.0 / _fps, 100 );
_stream->codec->gop_size = _gopSize;
if( _bFrames )
{
_stream->codec->max_b_frames = _bFrames;
_stream->codec->b_frame_strategy = 0;
_stream->codec->b_quant_factor = 2.0;
}
_stream->codec->mb_decision = _mbDecision;
_stream->codec->pix_fmt = _out_pixelFormat;
if( !strcmp( _avformatOptions->oformat->name, "mp4" ) || !strcmp( _avformatOptions->oformat->name, "mov" ) || !strcmp( _avformatOptions->oformat->name, "3gp" ) || !strcmp( _avformatOptions->oformat->name, "flv" ) )
_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
if( av_set_parameters( _avformatOptions, NULL ) < 0 )
{
std::cout << "ffmpegWriter: unable to set parameters." << std::endl;
freeFormat();
return false;
}
dump_format( _avformatOptions, 0, filename().c_str(), 1 );
AVCodec* videoCodec = avcodec_find_encoder( codecId );
if( !videoCodec )
{
std::cout << "ffmpegWriter: unable to find codec." << std::endl;
freeFormat();
return false;
}
if( avcodec_open( _stream->codec, videoCodec ) < 0 )
{
std::cout << "ffmpegWriter: unable to open codec." << std::endl;
freeFormat();
return false;
}
if( !( fmt->flags & AVFMT_NOFILE ) )
{
if( url_fopen( &_avformatOptions->pb, filename().c_str(), URL_WRONLY ) < 0 )
{
std::cout << "ffmpegWriter: unable to open file." << std::endl;
return false;
}
}
av_write_header( _avformatOptions );
}
_error = CLEANUP;
AVFrame* in_frame = avcodec_alloc_frame();
avcodec_get_frame_defaults( in_frame );
avpicture_fill( (AVPicture*)in_frame, in_buffer, in_pixelFormat, in_width, in_height );
AVFrame* out_frame = avcodec_alloc_frame();
avcodec_get_frame_defaults( out_frame );
int out_picSize = avpicture_get_size( _out_pixelFormat, width(), height() );
boost::uint8_t* out_buffer = (boost::uint8_t*) av_malloc( out_picSize );
avpicture_fill( (AVPicture*) out_frame, out_buffer, _out_pixelFormat, width(), height() );
_sws_context = sws_getCachedContext( _sws_context, in_width, in_height, in_pixelFormat, width(), height(), _out_pixelFormat, SWS_BICUBIC, NULL, NULL, NULL );
std::cout << "ffmpegWriter: input format: " << pixelFormat_toString( in_pixelFormat ) << std::endl;
std::cout << "ffmpegWriter: output format: " << pixelFormat_toString( _out_pixelFormat ) << std::endl;
if( !_sws_context )
{
std::cout << "ffmpeg-conversion failed (" << in_pixelFormat << "->" << _out_pixelFormat << ")." << std::endl;
return false;
}
int error = sws_scale( _sws_context, in_frame->data, in_frame->linesize, 0, height(), out_frame->data, out_frame->linesize );
if( error < 0 )
{
std::cout << "ffmpeg-conversion failed (" << in_pixelFormat << "->" << _out_pixelFormat << ")." << std::endl;
return false;
}
int ret = 0;
if( ( _avformatOptions->oformat->flags & AVFMT_RAWPICTURE ) != 0 )
{
AVPacket pkt;
av_init_packet( &pkt );
pkt.flags |= PKT_FLAG_KEY;
pkt.stream_index = _stream->index;
pkt.data = (boost::uint8_t*) out_frame;
pkt.size = sizeof( AVPicture );
ret = av_interleaved_write_frame( _avformatOptions, &pkt );
}
else
{
boost::uint8_t* out_buffer = (boost::uint8_t*) av_malloc( out_picSize );
ret = avcodec_encode_video( _stream->codec, out_buffer, out_picSize, out_frame );
if( ret > 0 )
{
AVPacket pkt;
av_init_packet( &pkt );
if( _stream->codec->coded_frame && _stream->codec->coded_frame->pts != static_cast<boost::int64_t>( AV_NOPTS_VALUE ) ) // static_cast<unsigned long> (
pkt.pts = av_rescale_q( _stream->codec->coded_frame->pts, _stream->codec->time_base, _stream->time_base );
if( _stream->codec->coded_frame && _stream->codec->coded_frame->key_frame )
pkt.flags |= PKT_FLAG_KEY;
pkt.stream_index = _stream->index;
pkt.data = out_buffer;
pkt.size = ret;
ret = av_interleaved_write_frame( _avformatOptions, &pkt );
}
av_free( out_buffer );
}
av_free( out_buffer );
av_free( out_frame );
av_free( in_frame );
// in_buffer not free (function parameter)
if( ret )
{
std::cout << "ffmpegWriter: error writing frame to file." << std::endl;
return false;
}
_error = SUCCESS;
return true;
}
static int start_ffmpeg_impl(struct RenderData *rd, int rectx, int recty, ReportList *reports)
{
/* Handle to the output file */
AVFormatContext* of;
AVOutputFormat* fmt;
char name[256];
const char ** exts;
ffmpeg_type = rd->ffcodecdata.type;
ffmpeg_codec = rd->ffcodecdata.codec;
ffmpeg_audio_codec = rd->ffcodecdata.audio_codec;
ffmpeg_video_bitrate = rd->ffcodecdata.video_bitrate;
ffmpeg_audio_bitrate = rd->ffcodecdata.audio_bitrate;
ffmpeg_gop_size = rd->ffcodecdata.gop_size;
ffmpeg_autosplit = rd->ffcodecdata.flags
& FFMPEG_AUTOSPLIT_OUTPUT;
do_init_ffmpeg();
/* Determine the correct filename */
filepath_ffmpeg(name, rd);
fprintf(stderr, "Starting output to %s(ffmpeg)...\n"
" Using type=%d, codec=%d, audio_codec=%d,\n"
" video_bitrate=%d, audio_bitrate=%d,\n"
" gop_size=%d, autosplit=%d\n"
" render width=%d, render height=%d\n",
name, ffmpeg_type, ffmpeg_codec, ffmpeg_audio_codec,
ffmpeg_video_bitrate, ffmpeg_audio_bitrate,
ffmpeg_gop_size, ffmpeg_autosplit, rectx, recty);
exts = get_file_extensions(ffmpeg_type);
if (!exts) {
BKE_report(reports, RPT_ERROR, "No valid formats found.");
return 0;
}
fmt = av_guess_format(NULL, exts[0], NULL);
if (!fmt) {
BKE_report(reports, RPT_ERROR, "No valid formats found.");
return 0;
}
of = avformat_alloc_context();
if (!of) {
BKE_report(reports, RPT_ERROR, "Error opening output file");
return 0;
}
of->oformat = fmt;
of->packet_size= rd->ffcodecdata.mux_packet_size;
if (ffmpeg_audio_codec != CODEC_ID_NONE) {
of->mux_rate = rd->ffcodecdata.mux_rate;
} else {
of->mux_rate = 0;
}
of->preload = (int)(0.5*AV_TIME_BASE);
of->max_delay = (int)(0.7*AV_TIME_BASE);
fmt->audio_codec = ffmpeg_audio_codec;
BLI_snprintf(of->filename, sizeof(of->filename), "%s", name);
/* set the codec to the user's selection */
switch(ffmpeg_type) {
case FFMPEG_AVI:
case FFMPEG_MOV:
case FFMPEG_MKV:
fmt->video_codec = ffmpeg_codec;
break;
case FFMPEG_OGG:
fmt->video_codec = CODEC_ID_THEORA;
break;
case FFMPEG_DV:
fmt->video_codec = CODEC_ID_DVVIDEO;
break;
case FFMPEG_MPEG1:
fmt->video_codec = CODEC_ID_MPEG1VIDEO;
break;
case FFMPEG_MPEG2:
fmt->video_codec = CODEC_ID_MPEG2VIDEO;
break;
case FFMPEG_H264:
fmt->video_codec = CODEC_ID_H264;
break;
case FFMPEG_XVID:
fmt->video_codec = CODEC_ID_MPEG4;
break;
case FFMPEG_FLV:
fmt->video_codec = CODEC_ID_FLV1;
break;
case FFMPEG_MP3:
fmt->audio_codec = CODEC_ID_MP3;
case FFMPEG_WAV:
fmt->video_codec = CODEC_ID_NONE;
break;
case FFMPEG_MPEG4:
default:
fmt->video_codec = CODEC_ID_MPEG4;
break;
}
if (fmt->video_codec == CODEC_ID_DVVIDEO) {
if (rectx != 720) {
BKE_report(reports, RPT_ERROR, "Render width has to be 720 pixels for DV!");
return 0;
}
if (rd->frs_sec != 25 && recty != 480) {
BKE_report(reports, RPT_ERROR, "Render height has to be 480 pixels for DV-NTSC!");
return 0;
}
if (rd->frs_sec == 25 && recty != 576) {
BKE_report(reports, RPT_ERROR, "Render height has to be 576 pixels for DV-PAL!");
return 0;
}
}
if (ffmpeg_type == FFMPEG_DV) {
fmt->audio_codec = CODEC_ID_PCM_S16LE;
if (ffmpeg_audio_codec != CODEC_ID_NONE && rd->ffcodecdata.audio_mixrate != 48000 && rd->ffcodecdata.audio_channels != 2) {
BKE_report(reports, RPT_ERROR, "FFMPEG only supports 48khz / stereo audio for DV!");
return 0;
}
}
if (fmt->video_codec != CODEC_ID_NONE) {
video_stream = alloc_video_stream(rd, fmt->video_codec, of, rectx, recty);
printf("alloc video stream %p\n", video_stream);
if (!video_stream) {
BKE_report(reports, RPT_ERROR, "Error initializing video stream.");
return 0;
}
}
if (ffmpeg_audio_codec != CODEC_ID_NONE) {
audio_stream = alloc_audio_stream(rd, fmt->audio_codec, of);
if (!audio_stream) {
BKE_report(reports, RPT_ERROR, "Error initializing audio stream.");
return 0;
}
}
if (av_set_parameters(of, NULL) < 0) {
BKE_report(reports, RPT_ERROR, "Error setting output parameters.");
return 0;
}
if (!(fmt->flags & AVFMT_NOFILE)) {
if (avio_open(&of->pb, name, AVIO_FLAG_WRITE) < 0) {
BKE_report(reports, RPT_ERROR, "Could not open file for writing.");
return 0;
}
}
if (av_write_header(of) < 0) {
BKE_report(reports, RPT_ERROR, "Could not initialize streams. Probably unsupported codec combination.");
return 0;
}
outfile = of;
av_dump_format(of, 0, name, 1);
return 1;
}
/// Create a video writer object that uses FFMPEG
inline bool CvVideoWriter_FFMPEG::open( const char * filename, int fourcc,
double fps, int width, int height, bool is_color )
{
icvInitFFMPEG_internal();
CodecID codec_id = CODEC_ID_NONE;
int err, codec_pix_fmt;
double bitrate_scale = 1;
close();
// check arguments
if( !filename )
return false;
if(fps <= 0)
return false;
// we allow frames of odd width or height, but in this case we truncate
// the rightmost column/the bottom row. Probably, this should be handled more elegantly,
// but some internal functions inside FFMPEG swscale require even width/height.
width &= -2;
height &= -2;
if( width <= 0 || height <= 0 )
return false;
/* auto detect the output format from the name and fourcc code. */
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 2, 0)
fmt = av_guess_format(NULL, filename, NULL);
#else
fmt = guess_format(NULL, filename, NULL);
#endif
if (!fmt)
return false;
/* determine optimal pixel format */
if (is_color) {
input_pix_fmt = PIX_FMT_BGR24;
}
else {
input_pix_fmt = PIX_FMT_GRAY8;
}
/* Lookup codec_id for given fourcc */
#if LIBAVCODEC_VERSION_INT<((51<<16)+(49<<8)+0)
if( (codec_id = codec_get_bmp_id( fourcc )) == CODEC_ID_NONE )
return false;
#else
const struct AVCodecTag * tags[] = { codec_bmp_tags, NULL};
if( (codec_id = av_codec_get_id(tags, fourcc)) == CODEC_ID_NONE )
return false;
#endif
// alloc memory for context
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 2, 0)
oc = avformat_alloc_context();
#else
oc = av_alloc_format_context();
#endif
assert (oc);
/* set file name */
oc->oformat = fmt;
_snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
/* set some options */
oc->max_delay = (int)(0.7*AV_TIME_BASE); /* This reduces buffer underrun warnings with MPEG */
// set a few optimal pixel formats for lossless codecs of interest..
switch (codec_id) {
#if LIBAVCODEC_VERSION_INT>((50<<16)+(1<<8)+0)
case CODEC_ID_JPEGLS:
// BGR24 or GRAY8 depending on is_color...
codec_pix_fmt = input_pix_fmt;
break;
#endif
case CODEC_ID_HUFFYUV:
codec_pix_fmt = PIX_FMT_YUV422P;
break;
case CODEC_ID_MJPEG:
case CODEC_ID_LJPEG:
codec_pix_fmt = PIX_FMT_YUVJ420P;
bitrate_scale = 3;
break;
case CODEC_ID_RAWVIDEO:
codec_pix_fmt = input_pix_fmt == PIX_FMT_GRAY8 ||
input_pix_fmt == PIX_FMT_GRAY16LE ||
input_pix_fmt == PIX_FMT_GRAY16BE ? input_pix_fmt : PIX_FMT_YUV420P;
break;
default:
// good for lossy formats, MPEG, etc.
codec_pix_fmt = PIX_FMT_YUV420P;
break;
}
double bitrate = MIN(bitrate_scale*fps*width*height, (double)INT_MAX/2);
// TODO -- safe to ignore output audio stream?
video_st = icv_add_video_stream_FFMPEG(oc, codec_id,
width, height, (int)(bitrate + 0.5),
fps, codec_pix_fmt);
/* set the output parameters (must be done even if no
parameters). */
#if LIBAVFORMAT_BUILD < CALC_FFMPEG_VERSION(53, 2, 0)
if (av_set_parameters(oc, NULL) < 0) {
return false;
}
#endif
#if 0
#if FF_API_DUMP_FORMAT
dump_format(oc, 0, filename, 1);
#else
av_dump_format(oc, 0, filename, 1);
#endif
#endif
/* now that all the parameters are set, we can open the audio and
video codecs and allocate the necessary encode buffers */
if (!video_st){
return false;
}
AVCodec *codec;
AVCodecContext *c;
#if LIBAVFORMAT_BUILD > 4628
c = (video_st->codec);
#else
c = &(video_st->codec);
#endif
c->codec_tag = fourcc;
/* find the video encoder */
codec = avcodec_find_encoder(c->codec_id);
if (!codec) {
fprintf(stderr, "Could not find encoder for codec id %d: %s", c->codec_id, icvFFMPEGErrStr(
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 2, 0)
AVERROR_ENCODER_NOT_FOUND
#else
-1
#endif
));
return false;
}
s64 lbit_rate = (s64)c->bit_rate;
lbit_rate += (bitrate / 2);
lbit_rate = std::min(lbit_rate, (s64)INT_MAX);
c->bit_rate_tolerance = (int)lbit_rate;
c->bit_rate = (int)lbit_rate;
/* open the codec */
if ((err=
#if LIBAVCODEC_VERSION_INT >= ((53<<16)+(8<<8)+0)
avcodec_open2(c, codec, NULL)
#else
avcodec_open(c, codec)
#endif
) < 0) {
fprintf(stderr, "Could not open codec '%s': %s", codec->name, icvFFMPEGErrStr(err));
return false;
}
outbuf = NULL;
if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
/* allocate output buffer */
/* assume we will never get codec output with more than 4 bytes per pixel... */
outbuf_size = width*height*4;
outbuf = (uint8_t *) av_malloc(outbuf_size);
}
bool need_color_convert;
need_color_convert = (c->pix_fmt != input_pix_fmt);
/* allocate the encoded raw picture */
picture = icv_alloc_picture_FFMPEG(c->pix_fmt, c->width, c->height, need_color_convert);
if (!picture) {
return false;
}
/* if the output format is not our input format, then a temporary
picture of the input format is needed too. It is then converted
to the required output format */
input_picture = NULL;
if ( need_color_convert ) {
input_picture = icv_alloc_picture_FFMPEG(input_pix_fmt, c->width, c->height, false);
if (!input_picture) {
return false;
}
}
/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE)) {
#if LIBAVFORMAT_BUILD < CALC_FFMPEG_VERSION(53, 2, 0)
if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0)
#else
if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0)
#endif
{
return false;
}
}
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(52, 111, 0)
/* write the stream header, if any */
err=avformat_write_header(oc, NULL);
#else
err=av_write_header( oc );
#endif
if(err < 0)
{
close();
remove(filename);
return false;
}
frame_width = width;
frame_height = height;
ok = true;
return true;
}
jint Java_org_devtcg_rojocam_ffmpeg_RtpOutputContext_nativeCreate(JNIEnv *env,
jclass clazz, jint streamConfigNativeInt, jlong nowNanoTime,
jstring hostAddress, jint rtpPort) {
FFStreamConfig *config = (FFStreamConfig *)streamConfigNativeInt;
RtpOutputContext *rtpContext = NULL;
AVFormatContext *avContext = NULL;
AVStream *st = NULL;
uint8_t *dummy_buf;
int max_packet_size;
rtpContext = av_mallocz(sizeof(RtpOutputContext));
if (rtpContext == NULL) {
jniThrowOOM(env);
goto cleanup;
}
rtpContext->lastFrameTime = nowNanoTime;
rtpContext->config = config;
avContext = avformat_alloc_context();
if (avContext == NULL) {
jniThrowOOM(env);
goto cleanup;
}
avContext->oformat = av_guess_format("rtp", NULL, NULL);
if (avContext->oformat == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"rtp avformat is not available");
goto cleanup;
}
rtpContext->avContext = avContext;
st = av_mallocz(sizeof(AVStream));
if (st == NULL) {
jniThrowOOM(env);
goto cleanup;
}
avContext->nb_streams = 1;
avContext->streams = av_malloc(avContext->nb_streams * sizeof(*avContext->streams));
avContext->streams[0] = st;
/* XXX: What would we be doing if we supported audio as well? */
memcpy(st, config->streams[0], sizeof(AVStream));
st->priv_data = NULL;
const jbyte *hostAddress_str = (*env)->GetStringUTFChars(env,
hostAddress, NULL);
snprintf(avContext->filename, sizeof(avContext->filename),
"rtp://%s:%d?localrtpport=5000&localrtcpport=5001",
hostAddress_str, rtpPort);
(*env)->ReleaseStringUTFChars(env, hostAddress, hostAddress_str);
if (url_open(&rtpContext->urlContext,
avContext->filename, URL_WRONLY) < 0) {
LOGE("Cannot open url context for filename=%s", avContext->filename);
jniThrowException(env, "java/io/IOException", "Unable to open URL");
goto cleanup;
}
max_packet_size = url_get_max_packet_size(rtpContext->urlContext);
/* XXX: No idea what purpose this serves... */
url_open_dyn_packet_buf(&avContext->pb, max_packet_size);
av_set_parameters(avContext, NULL);
if (av_write_header(avContext) < 0) {
jniThrowException(env, "java/io/IOException", "Unexpected error writing dummy RTP header");
goto cleanup;
}
url_close_dyn_buf(avContext->pb, &dummy_buf);
av_free(dummy_buf);
return (jint)rtpContext;
cleanup:
rtp_output_context_free(rtpContext);
assert((*env)->ExceptionOccurred(env));
return 0;
}
int main(int argc, char **argv)
{
if (argc != 5) {
fprintf(stderr,
"Usage: %s <segment length> <output location> <filename prefix> <encoding profile>\n",
argv[0]);
return 1;
}
struct config_info config;
memset(&config, 0, sizeof(struct config_info));
config.segment_length = atoi(argv[1]);
config.temp_directory = argv[2];
config.filename_prefix = argv[3];
config.encoding_profile = argv[4];
config.input_filename = "pipe://1";
char *output_filename =
malloc(sizeof(char) *
(strlen(config.temp_directory) + 1 +
strlen(config.filename_prefix) + 10));
if (!output_filename) {
fprintf(stderr,
"Segmenter error: Could not allocate space for output filenames\n");
exit(1);
}
// ------------------ Done parsing input --------------
av_register_all();
AVInputFormat *input_format = av_find_input_format("mpegts");
if (!input_format) {
fprintf(stderr,
"Segmenter error: Could not find MPEG-TS demuxer\n");
exit(1);
}
AVFormatContext *input_context = NULL;
int ret = avformat_open_input(&input_context, config.input_filename,
input_format, NULL);
if (ret != 0) {
fprintf(stderr,
"Segmenter error: Could not open input file, make sure it is an mpegts file: %d\n",
ret);
exit(1);
}
if (avformat_find_stream_info(input_context, NULL) < 0) {
fprintf(stderr,
"Segmenter error: Could not read stream information\n");
exit(1);
}
AVOutputFormat *output_format = av_guess_format("mpegts", NULL, NULL);
if (!output_format) {
fprintf(stderr,
"Segmenter error: Could not find MPEG-TS muxer\n");
exit(1);
}
AVFormatContext *output_context = avformat_alloc_context();
if (!output_context) {
fprintf(stderr,
"Segmenter error: Could not allocated output context");
exit(1);
}
output_context->oformat = output_format;
// Don't print warnings when PTS and DTS are identical.
input_context->flags |= AVFMT_FLAG_IGNDTS;
int video_index = -1;
int audio_index = -1;
AVStream *video_stream;
AVStream *audio_stream;
int i;
for (i = 0;
i < input_context->nb_streams && (video_index < 0
|| audio_index < 0); i++) {
switch (input_context->streams[i]->codec->codec_type) {
case AVMEDIA_TYPE_VIDEO:
video_index = i;
input_context->streams[i]->discard = AVDISCARD_NONE;
video_stream =
add_output_stream(output_context,
input_context->streams[i]);
break;
case AVMEDIA_TYPE_AUDIO:
audio_index = i;
input_context->streams[i]->discard = AVDISCARD_NONE;
audio_stream =
add_output_stream(output_context,
input_context->streams[i]);
break;
default:
input_context->streams[i]->discard = AVDISCARD_ALL;
break;
}
}
#if LIBAVFORMAT_VERSION_MAJOR < 54
if (av_set_parameters(output_context, NULL) < 0) {
fprintf(stderr,
"Segmenter error: Invalid output format parameters\n");
exit(1);
}
#endif
av_dump_format(output_context, 0, config.filename_prefix, 1);
if (video_index >= 0) {
AVCodec *codec =
avcodec_find_decoder(video_stream->codec->codec_id);
if (!codec) {
fprintf(stderr,
"Segmenter error: Could not find video decoder, key frames will not be honored\n");
}
if (avcodec_open2(video_stream->codec, codec, NULL) < 0) {
fprintf(stderr,
"Segmenter error: Could not open video decoder, key frames will not be honored\n");
}
}
if (video_stream->codec->ticks_per_frame > 1) {
// h264 sets the ticks_per_frame and time_base.den but not time_base.num
// since we don't use ticks_per_frame, adjust time_base.num accordingly.
video_stream->codec->time_base.num *=
video_stream->codec->ticks_per_frame;
}
unsigned int output_index = 1;
snprintf(output_filename,
strlen(config.temp_directory) + 1 +
strlen(config.filename_prefix) + 10, "%s/%s-%05u.ts",
config.temp_directory, config.filename_prefix, output_index++);
if (avio_open(&output_context->pb, output_filename, AVIO_FLAG_WRITE) < 0) {
fprintf(stderr, "Segmenter error: Could not open '%s'\n",
output_filename);
exit(1);
}
if (avformat_write_header(output_context, NULL)) {
fprintf(stderr,
"Segmenter error: Could not write mpegts header to first output file\n");
exit(1);
}
// Track initial PTS values so we can subtract them out (removing aduio/video delay, since they seem incorrect).
int64_t initial_audio_pts = -1;
int64_t initial_video_pts = -1;
unsigned int first_segment = 1;
unsigned int last_segment = 0;
double prev_segment_time = 0;
int decode_done;
do {
double segment_time;
AVPacket packet;
decode_done = av_read_frame(input_context, &packet);
if (decode_done < 0) {
break;
}
if (av_dup_packet(&packet) < 0) {
fprintf(stderr,
"Segmenter error: Could not duplicate packet");
av_free_packet(&packet);
break;
}
if (packet.stream_index == video_index) {
if (initial_video_pts < 0)
initial_video_pts = packet.pts;
packet.pts -= initial_video_pts;
packet.dts = packet.pts;
if (packet.flags & AV_PKT_FLAG_KEY) {
segment_time =
(double)packet.pts *
video_stream->time_base.num /
video_stream->time_base.den;
} else {
segment_time = prev_segment_time;
}
} else if (packet.stream_index == audio_index) {
if (initial_audio_pts < 0)
initial_audio_pts = packet.pts;
packet.pts -= initial_audio_pts;
packet.dts = packet.pts;
segment_time = prev_segment_time;
} else {
segment_time = prev_segment_time;
}
// done writing the current file?
if (segment_time - prev_segment_time >= config.segment_length) {
avio_flush(output_context->pb);
avio_close(output_context->pb);
output_transfer_command(first_segment, ++last_segment,
0, config.encoding_profile);
snprintf(output_filename,
strlen(config.temp_directory) + 1 +
strlen(config.filename_prefix) + 10,
"%s/%s-%05u.ts", config.temp_directory,
config.filename_prefix, output_index++);
if (avio_open
(&output_context->pb, output_filename,
AVIO_FLAG_WRITE) < 0) {
fprintf(stderr,
"Segmenter error: Could not open '%s'\n",
output_filename);
break;
}
prev_segment_time = segment_time;
}
ret = av_write_frame(output_context, &packet);
if (ret < 0) {
fprintf(stderr,
"Segmenter error: Could not write frame of stream: %d\n",
ret);
} else if (ret > 0) {
fprintf(stderr,
"Segmenter info: End of stream requested\n");
av_free_packet(&packet);
break;
}
av_free_packet(&packet);
} while (!decode_done);
av_write_trailer(output_context);
if (video_index >= 0) {
avcodec_close(video_stream->codec);
}
for (i = 0; i < output_context->nb_streams; i++) {
av_freep(&output_context->streams[i]->codec);
av_freep(&output_context->streams[i]);
}
avio_close(output_context->pb);
av_free(output_context);
output_transfer_command(first_segment, ++last_segment, 1,
config.encoding_profile);
return 0;
}
int main(int argc, char *argv[])
{
IDeckLinkIterator *deckLinkIterator = CreateDeckLinkIteratorInstance();
DeckLinkCaptureDelegate *delegate;
BMDDisplayMode selectedDisplayMode = bmdModeNTSC;
int displayModeCount = 0;
int exitStatus = 1;
int connection = 0, camera = 0, i=0;
int ch;
HRESULT result;
pthread_mutex_init(&sleepMutex, NULL);
pthread_cond_init(&sleepCond, NULL);
av_register_all();
if (!deckLinkIterator)
{
fprintf(stderr, "This application requires the DeckLink drivers installed.\n");
goto bail;
}
// Parse command line options
while ((ch = getopt(argc, argv, "?hc:s:f:a:m:n:F:C:I:")) != -1)
{
switch (ch)
{
case 'm':
g_videoModeIndex = atoi(optarg);
break;
case 'c':
g_audioChannels = atoi(optarg);
if (g_audioChannels != 2 &&
g_audioChannels != 8 &&
g_audioChannels != 16)
{
fprintf(stderr, "Invalid argument: Audio Channels must be either 2, 8 or 16\n");
goto bail;
}
break;
case 's':
g_audioSampleDepth = atoi(optarg);
if (g_audioSampleDepth != 16 && g_audioSampleDepth != 32)
{
fprintf(stderr, "Invalid argument: Audio Sample Depth must be either 16 bits or 32 bits\n");
goto bail;
}
break;
case 'f':
g_videoOutputFile = optarg;
break;
case 'n':
g_maxFrames = atoi(optarg);
break;
case 'F':
fmt = av_guess_format(optarg, NULL, NULL);
break;
case 'I':
connection = atoi(optarg);
break;
case 'C':
camera = atoi(optarg);
break;
case '?':
case 'h':
usage(0);
}
}
/* Connect to the first DeckLink instance */
do {
result = deckLinkIterator->Next(&deckLink);
} while(i++<camera);
if (result != S_OK)
{
fprintf(stderr, "No DeckLink PCI cards found.\n");
goto bail;
}
if (deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput) != S_OK)
goto bail;
result = deckLink->QueryInterface(IID_IDeckLinkConfiguration, (void**)&deckLinkConfiguration);
if (result != S_OK)
{
fprintf(stderr, "Could not obtain the IDeckLinkConfiguration interface - result = %08x\n", result);
goto bail;
}
//XXX make it generic
if (connection == 1) { // video compuesto + audio analogico
deckLinkConfiguration->SetInt(bmdDeckLinkConfigVideoInputConnection,
bmdVideoConnectionComposite);
deckLinkConfiguration->SetInt(bmdDeckLinkConfigAudioInputConnection,
bmdAudioConnectionAnalog);
}else if (connection == 2) { // video componentes + audio analogico
deckLinkConfiguration->SetInt(bmdDeckLinkConfigVideoInputConnection,
bmdVideoConnectionComponent);
deckLinkConfiguration->SetInt(bmdDeckLinkConfigAudioInputConnection,
bmdAudioConnectionAnalog);
}else if (connection == 3) { // HDMI video + audio
deckLinkConfiguration->SetInt(bmdDeckLinkConfigVideoInputConnection,
bmdVideoConnectionHDMI);
deckLinkConfiguration->SetInt(bmdDeckLinkConfigAudioInputConnection,
bmdAudioConnectionEmbedded);
}else if (connection == 4) { // SDI video + audio
deckLinkConfiguration->SetInt(bmdDeckLinkConfigVideoInputConnection,
bmdVideoConnectionSDI);
deckLinkConfiguration->SetInt(bmdDeckLinkConfigAudioInputConnection,
bmdAudioConnectionEmbedded);
}
delegate = new DeckLinkCaptureDelegate();
deckLinkInput->SetCallback(delegate);
// Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on output
result = deckLinkInput->GetDisplayModeIterator(&displayModeIterator);
if (result != S_OK)
{
fprintf(stderr, "Could not obtain the video output display mode iterator - result = %08x\n", result);
goto bail;
}
if (!fmt)
fmt = av_guess_format(NULL, g_videoOutputFile, NULL);
if (g_videoModeIndex < 0)
{
fprintf(stderr, "No video mode specified\n");
usage(0);
}
selectedDisplayMode = -1;
while (displayModeIterator->Next(&displayMode) == S_OK)
{
if (g_videoModeIndex == displayModeCount)
{
selectedDisplayMode = displayMode->GetDisplayMode();
break;
}
displayModeCount++;
displayMode->Release();
}
oc = avformat_alloc_context();
oc->oformat = fmt;
snprintf(oc->filename, sizeof(oc->filename), "%s", g_videoOutputFile);
fmt->video_codec = CODEC_ID_RAWVIDEO;
fmt->audio_codec = CODEC_ID_PCM_S16LE;
video_st = add_video_stream(oc, fmt->video_codec);
audio_st = add_audio_stream(oc, fmt->audio_codec);
av_set_parameters(oc, NULL);
if (!(fmt->flags & AVFMT_NOFILE)) {
if (url_fopen(&oc->pb, oc->filename, URL_WRONLY) < 0) {
fprintf(stderr, "Could not open '%s'\n", oc->filename);
exit(1);
}
}
if (selectedDisplayMode < 0)
{
fprintf(stderr, "Invalid mode %d specified\n", g_videoModeIndex);
goto bail;
}
result = deckLinkInput->EnableVideoInput(selectedDisplayMode, bmdFormat8BitYUV, 0);
if(result != S_OK)
{
fprintf(stderr, "Failed to enable video input. Is another application using the card?\n");
goto bail;
}
result = deckLinkInput->EnableAudioInput(bmdAudioSampleRate48kHz, g_audioSampleDepth, g_audioChannels);
if(result != S_OK)
{
goto bail;
}
av_write_header(oc);
result = deckLinkInput->StartStreams();
if(result != S_OK)
{
goto bail;
}
// All Okay.
exitStatus = 0;
// Block main thread until signal occurs
pthread_mutex_lock(&sleepMutex);
pthread_cond_wait(&sleepCond, &sleepMutex);
pthread_mutex_unlock(&sleepMutex);
fprintf(stderr, "Stopping Capture\n");
bail:
if (displayModeIterator != NULL)
{
displayModeIterator->Release();
displayModeIterator = NULL;
}
if (deckLinkInput != NULL)
{
deckLinkInput->Release();
deckLinkInput = NULL;
}
if (deckLink != NULL)
{
deckLink->Release();
deckLink = NULL;
}
if (deckLinkIterator != NULL)
deckLinkIterator->Release();
if (oc != NULL)
{
av_write_trailer(oc);
if (!(fmt->flags & AVFMT_NOFILE)) {
/* close the output file */
url_fclose(oc->pb);
}
}
return exitStatus;
}
uint8_t lavMuxer::open(const char *filename,uint32_t inbitrate, ADM_MUXER_TYPE type, aviInfo *info,
uint32_t videoExtraDataSize, uint8_t *videoExtraData, WAVHeader *audioheader,
uint32_t audioextraSize,uint8_t *audioextraData)
{
AVCodecContext *c;
_type=type;
_fps1000=info->fps1000;
switch(_type)
{
case MUXER_TS:
fmt=guess_format("mpegts", NULL, NULL);
break;
case MUXER_DVD:
fmt = guess_format("dvd", NULL, NULL);
break;
case MUXER_VCD:
fmt = guess_format("vcd", NULL, NULL);
break;
case MUXER_SVCD:
fmt = guess_format("svcd", NULL, NULL);
break;
case MUXER_MP4:
fmt = guess_format("mp4", NULL, NULL);
break;
case MUXER_PSP:
fmt = guess_format("psp", NULL, NULL);
break;
case MUXER_FLV:
fmt = guess_format("flv", NULL, NULL);
break;
case MUXER_MATROSKA:
fmt = guess_format("matroska", NULL, NULL);
break;
default:
fmt=NULL;
}
if (!fmt)
{
printf("Lav:Cannot guess format\n");
ADM_assert(0);
return 0;
}
oc = av_alloc_format_context();
if (!oc)
{
printf("Lav:Cannot allocate context\n");
return 0;
}
oc->oformat = fmt;
snprintf(oc->filename,1000,"file://%s",filename);
// Video
//________
video_st = av_new_stream(oc, 0);
if (!video_st)
{
printf("Lav: new stream failed\n");
return 0;
}
c = video_st->codec;
switch(_type)
{
case MUXER_FLV:
c->codec=new AVCodec;
memset(c->codec,0,sizeof(AVCodec));
if(fourCC::check(info->fcc,(uint8_t *)"FLV1"))
{
c->codec_id=CODEC_ID_FLV1;
c->codec->name=ADM_strdup("FLV1");
}else
{
if(fourCC::check(info->fcc,(uint8_t *)"VP6F"))
{
c->codec_id=CODEC_ID_VP6F;
c->codec->name=ADM_strdup("VP6F");
}
else
ADM_assert(0);
}
break;
case MUXER_MATROSKA:
strcpy(oc->title,"Avidemux");
strcpy(oc->author,"Avidemux");
c->sample_aspect_ratio.num=1;
c->sample_aspect_ratio.den=1;
if(isMpeg4Compatible(info->fcc))
{
c->codec_id = CODEC_ID_MPEG4;
c->has_b_frames=1; // in doubt...
}else
{
if(isH264Compatible(info->fcc))
{
c->has_b_frames=1; // in doubt...
c->codec_id = CODEC_ID_H264;
c->codec=new AVCodec;
memset(c->codec,0,sizeof(AVCodec));
c->codec->name=ADM_strdup("H264");
}
else
{
if(!ADM_4cc_to_lavcodec((const char *)&(info->fcc),&(c->codec_id)))
{
printf("[lavFormat] Cannot map this\n");
return 0;
}
}
}
if(videoExtraDataSize)
{
c->extradata=videoExtraData;
c->extradata_size= videoExtraDataSize;
}
break;
case MUXER_MP4:
case MUXER_PSP:
{
// probably a memeleak here
char *foo=ADM_strdup(filename);
strcpy(oc->title,ADM_GetFileName(foo));
strcpy(oc->author,"Avidemux");
c->sample_aspect_ratio.num=1;
c->sample_aspect_ratio.den=1;
if(isMpeg4Compatible(info->fcc))
{
c->codec_id = CODEC_ID_MPEG4;
c->has_b_frames=1; // in doubt...
}else
{
if(isH264Compatible(info->fcc))
{
c->has_b_frames=1; // in doubt...
c->codec_id = CODEC_ID_H264;
c->codec=new AVCodec;
memset(c->codec,0,sizeof(AVCodec));
c->codec->name=ADM_strdup("H264");
}
else
{
if(isDVCompatible(info->fcc))
{
c->codec_id = CODEC_ID_DVVIDEO;
}else
{
if(fourCC::check(info->fcc,(uint8_t *)"H263"))
{
c->codec_id=CODEC_ID_H263;
}else{
c->codec_id = CODEC_ID_MPEG4; // Default value
printf("Ooops, cant mux that...\n");
printf("Ooops, cant mux that...\n");
printf("Ooops, cant mux that...\n");
}
}
}
}
if(videoExtraDataSize)
{
c->extradata=videoExtraData;
c->extradata_size= videoExtraDataSize;
}
if(MUXER_PSP==_type)
{
c->rc_buffer_size=0; //8*1024*224;
c->rc_max_rate=0; //768*1000;
c->rc_min_rate=0;
c->bit_rate=768*1000;
}
else
{
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
}
}
break;
case MUXER_TS:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_DVD:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_VCD:
c->codec_id = CODEC_ID_MPEG1VIDEO;
c->rc_buffer_size=8*1024*40;
c->rc_max_rate=1152*1000;
c->rc_min_rate=1152*1000;
c->bit_rate=1152*1000;
break;
case MUXER_SVCD:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*112;
c->rc_max_rate=2500*1000;
c->rc_min_rate=0*1000;
if(!inbitrate)
c->bit_rate=2040*1000;
else
c->bit_rate=inbitrate;
break;
default:
ADM_assert(0);
}
c->codec_type = CODEC_TYPE_VIDEO;
c->flags=CODEC_FLAG_QSCALE;
c->width = info->width;
c->height = info->height;
AVRational fps25=(AVRational){1001,25025};
AVRational fps24=(AVRational){1001,24000};
AVRational fps30= (AVRational){1001,30000};
AVRational fpsfree= (AVRational){1000,_fps1000};
switch(_fps1000)
{
case 25000:
{
c->time_base= fps25;
break;
}
case 23976:
if(_type==MUXER_MP4 || _type==MUXER_PSP || _type==MUXER_FLV || _type==MUXER_MATROSKA)
{
c->time_base= fps24; //(AVRational){1001,24000};
break;
}
case 29970:
c->time_base=fps30;
break;
default:
{
if(_type==MUXER_MP4 || _type==MUXER_PSP || _type==MUXER_FLV || _type==MUXER_MATROSKA)
{
c->time_base=fpsfree;// (AVRational){1000,_fps1000};
break;
}
else
{
GUI_Error_HIG(QT_TR_NOOP("Incompatible frame rate"), NULL);
return 0;
}
}
break;
}
c->gop_size=15;
c->max_b_frames=2;
c->has_b_frames=1;
// Audio
//________
if(audioheader)
{
audio_st = av_new_stream(oc, 1);
if (!audio_st)
{
printf("Lav: new stream failed\n");
return 0;
}
c = audio_st->codec;
c->frame_size=1024; //For AAC mainly, sample per frame
printf("[LavFormat] Bitrate %u\n",(audioheader->byterate*8)/1000);
_audioFq=c->sample_rate = audioheader->frequency;
#if 0
if(_type== MUXER_PSP && audioheader->encoding==WAV_AAC)
{
_audioFq=c->sample_rate = audioheader->frequency/2; //_audioFq*=2; // SBR
}
#endif
switch(audioheader->encoding)
{
case WAV_AC3: c->codec_id = CODEC_ID_AC3;break;
case WAV_MP2: c->codec_id = CODEC_ID_MP2;break;
case WAV_MP3:
#warning FIXME : Probe deeper
c->frame_size=1152;
c->codec_id = CODEC_ID_MP3;
break;
case WAV_PCM:
// One chunk is 10 ms (1/100 of fq)
c->frame_size=4;
c->codec_id = CODEC_ID_PCM_S16LE;break;
case WAV_AAC:
c->extradata=audioextraData;
c->extradata_size= audioextraSize;
c->codec_id = CODEC_ID_AAC;
break;
default:
if(_type==MUXER_MATROSKA)
{
if(ADM_WaveTag_to_lavcodec(audioheader->encoding, &(c->codec_id)))
{
if(audioextraData)
{
c->extradata=audioextraData;
c->extradata_size= audioextraSize;
}
// Put a dummy time increment
c->time_base= fps25;
break;
}
}
printf("Cant mux that ! audio\n");
printf("Cant mux that ! audio\n");
c->codec_id = CODEC_ID_MP2;
return 0;
break;
}
c->codec_type = CODEC_TYPE_AUDIO;
c->bit_rate = audioheader->byterate*8;
c->rc_buffer_size=(c->bit_rate/(2*8)); // 500 ms worth
c->channels = audioheader->channels;
_audioByterate=audioheader->byterate;
}
// /audio
//----------------------
switch(_type)
{
case MUXER_FLV:
case MUXER_PSP:
case MUXER_MP4:
case MUXER_MATROSKA:
oc->mux_rate=10080*1000; // Needed ?
break;
case MUXER_TS:
oc->mux_rate=10080*1000;
break;
case MUXER_DVD:
oc->packet_size=2048;
oc->mux_rate=10080*1000;
break;
case MUXER_VCD:
oc->packet_size=2324;
oc->mux_rate=2352 * 75 * 8;
break;
case MUXER_SVCD:
oc->packet_size=2324;
oc->mux_rate=2*2352 * 75 * 8; // ?
break;
default:
ADM_assert(0);
}
oc->preload=AV_TIME_BASE/10; // 100 ms preloading
oc->max_delay=200*1000; // 500 ms
if (av_set_parameters(oc, NULL) < 0)
{
printf("Lav: set param failed \n");
return 0;
}
if (url_fopen(&(oc->pb), filename, URL_WRONLY) < 0)
{
printf("Lav: Failed to open file :%s\n",filename);
return 0;
}
ADM_assert(av_write_header(oc)>=0);
dump_format(oc, 0, filename, 1);
printf("lavformat mpeg muxer initialized\n");
_running=1;
one=(1000*1000*1000)/_fps1000;
_curDTS=one;
return 1;
}
int muxer_init_muxer_lavf(muxer_t *muxer)
{
muxer_priv_t *priv;
AVOutputFormat *fmt = NULL;
char mp_filename[256] = "menc://stream.dummy";
av_register_all();
if (conf_format && strcmp(conf_format, "help") == 0) {
list_formats();
return 0;
}
mp_msg(MSGT_MUXER, MSGL_WARN, "** MUXER_LAVF *****************************************************************\n");
if (!conf_allow_lavf) {
mp_msg(MSGT_MUXER, MSGL_FATAL,
"If you wish to use libavformat muxing, you must ensure that your video stream\n"
"does not contain B frames (out of order decoding) and specify:\n"
" -lavfopts i_certify_that_my_video_stream_does_not_use_b_frames\n"
"on the command line.\n");
} else {
mp_msg(MSGT_MUXER, MSGL_WARN,
"You have certified that your video stream does not contain B frames.\n");
}
mp_msg(MSGT_MUXER, MSGL_WARN,
"REMEMBER: MEncoder's libavformat muxing is presently broken and will generate\n"
"INCORRECT files in the presence of B frames. Moreover, due to bugs MPlayer\n"
"will play these INCORRECT files as if nothing were wrong!\n"
"*******************************************************************************\n");
if (!conf_allow_lavf) return 0;
priv = (muxer_priv_t *) calloc(1, sizeof(muxer_priv_t));
if(priv == NULL)
return 0;
priv->oc = av_alloc_format_context();
if(!priv->oc)
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "Couldn't get format context\n");
goto fail;
}
if(conf_format)
fmt = guess_format(conf_format, NULL, NULL);
if(! fmt)
fmt = guess_format(NULL, out_filename, NULL);
if(! fmt)
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "CAN'T GET SPECIFIED FORMAT\n");
goto fail;
}
priv->oc->oformat = fmt;
if(av_set_parameters(priv->oc, NULL) < 0)
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "Invalid output format parameters\n");
goto fail;
}
priv->oc->packet_size= mux_packet_size;
priv->oc->mux_rate= mux_rate;
priv->oc->preload= (int)(mux_preload*AV_TIME_BASE);
priv->oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
if (info_name)
pstrcpy(priv->oc->title , sizeof(priv->oc->title ), info_name );
if (info_artist)
pstrcpy(priv->oc->author , sizeof(priv->oc->author ), info_artist );
if (info_genre)
pstrcpy(priv->oc->genre , sizeof(priv->oc->genre ), info_genre );
if (info_copyright)
pstrcpy(priv->oc->copyright, sizeof(priv->oc->copyright), info_copyright);
if (info_comment)
pstrcpy(priv->oc->comment , sizeof(priv->oc->comment ), info_comment );
register_protocol(&mp_protocol);
if(url_fopen(&priv->oc->pb, mp_filename, URL_WRONLY))
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "Coulnd't open outfile\n");
goto fail;
}
((URLContext*)(priv->oc->pb.opaque))->priv_data= muxer;
muxer->priv = (void *) priv;
muxer->cont_new_stream = &lavf_new_stream;
muxer->cont_write_chunk = &write_chunk;
muxer->cont_write_header = &write_header;
muxer->cont_write_index = &write_trailer;
muxer->fix_stream_parameters = &fix_parameters;
mp_msg(MSGT_MUXER, MSGL_INFO, "OK, exit\n");
return 1;
fail:
free(priv);
return 0;
}
GF_AbstractTSMuxer * ts_amux_new(GF_AVRedirect * avr, u32 videoBitrateInBitsPerSec, u32 width, u32 height, u32 audioBitRateInBitsPerSec) {
GF_AbstractTSMuxer * ts = gf_malloc( sizeof(GF_AbstractTSMuxer));
memset( ts, 0, sizeof( GF_AbstractTSMuxer));
ts->oc = avformat_alloc_context();
ts->destination = avr->destination;
av_register_all();
ts->oc->oformat = GUESS_FORMAT(NULL, avr->destination, NULL);
if (!ts->oc->oformat)
ts->oc->oformat = GUESS_FORMAT("mpegts", NULL, NULL);
assert( ts->oc->oformat);
#if REDIRECT_AV_AUDIO_ENABLED
ts->audio_st = av_new_stream(ts->oc, avr->audioCodec->id);
{
AVCodecContext * c = ts->audio_st->codec;
c->codec_id = avr->audioCodec->id;
c->codec_type = AVMEDIA_TYPE_AUDIO;
/* put sample parameters */
c->sample_fmt = SAMPLE_FMT_S16;
c->bit_rate = audioBitRateInBitsPerSec;
c->sample_rate = avr->audioSampleRate;
c->channels = 2;
c->time_base.num = 1;
c->time_base.den = 1000;
// some formats want stream headers to be separate
if (ts->oc->oformat->flags & AVFMT_GLOBALHEADER)
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
#endif
ts->video_st = av_new_stream(ts->oc, avr->videoCodec->id);
{
AVCodecContext * c = ts->video_st->codec;
c->codec_id = avr->videoCodec->id;
c->codec_type = AVMEDIA_TYPE_VIDEO;
/* put sample parameters */
c->bit_rate = videoBitrateInBitsPerSec;
/* resolution must be a multiple of two */
c->width = width;
c->height = height;
/* time base: this is the fundamental unit of time (in seconds) in terms
of which frame timestamps are represented. for fixed-fps content,
timebase should be 1/framerate and timestamp increments should be
identically 1. */
c->time_base.den = STREAM_FRAME_RATE;
c->time_base.num = 1;
c->gop_size = 12; /* emit one intra frame every twelve frames at most */
c->pix_fmt = STREAM_PIX_FMT;
if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
/* just for testing, we also add B frames */
c->max_b_frames = 2;
}
if (c->codec_id == CODEC_ID_MPEG1VIDEO) {
/* Needed to avoid using macroblocks in which some coeffs overflow.
This does not happen with normal video, it just happens here as
the motion of the chroma plane does not match the luma plane. */
c->mb_decision=2;
}
// some formats want stream headers to be separate
if (ts->oc->oformat->flags & AVFMT_GLOBALHEADER)
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
//av_set_pts_info(ts->audio_st, 33, 1, audioBitRateInBitsPerSec);
#ifndef AVIO_FLAG_WRITE
/* set the output parameters (must be done even if no
parameters). */
if (av_set_parameters(ts->oc, NULL) < 0) {
fprintf(stderr, "Invalid output format parameters\n");
return NULL;
}
#endif
dump_format(ts->oc, 0, avr->destination, 1);
GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("[AVRedirect] DUMPING to %s...\n", ts->destination));
#if (LIBAVCODEC_VERSION_MAJOR<55)
if (avcodec_open(ts->video_st->codec, avr->videoCodec) < 0) {
#else
if (avcodec_open2(ts->video_st->codec, avr->videoCodec, NULL) < 0) {
#endif
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[AVRedirect] failed to open video codec\n"));
return NULL;
}
#if REDIRECT_AV_AUDIO_ENABLED
#if (LIBAVCODEC_VERSION_MAJOR<55)
if (avcodec_open(ts->audio_st->codec, avr->audioCodec) < 0) {
#else
if (avcodec_open2(ts->audio_st->codec, avr->audioCodec, NULL) < 0) {
#endif
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[AVRedirect] failed to open audio codec\n"));
return NULL;
}
ts->audioMx = gf_mx_new("TS_AudioMx");
#endif
ts->videoMx = gf_mx_new("TS_VideoMx");
ts->tsEncodingThread = gf_th_new("ts_interleave_thread_run");
ts->encode = 1;
ts->audioPackets = NULL;
ts->videoPackets = NULL;
gf_th_run(ts->tsEncodingThread, ts_interleave_thread_run, ts);
return ts;
}
void ts_amux_del(GF_AbstractTSMuxer * muxerToDelete) {
if (!muxerToDelete)
return;
muxerToDelete->encode = 0;
gf_sleep(100);
gf_th_stop(muxerToDelete->tsEncodingThread);
muxerToDelete->tsEncodingThread = NULL;
#if REDIRECT_AV_AUDIO_ENABLED
gf_mx_del(muxerToDelete->audioMx);
muxerToDelete->audioMx = NULL;
#endif
gf_mx_del(muxerToDelete->videoMx);
muxerToDelete->videoMx = NULL;
if (muxerToDelete->video_st) {
avcodec_close(muxerToDelete->video_st->codec);
muxerToDelete->video_st = NULL;
}
#if REDIRECT_AV_AUDIO_ENABLED
if (muxerToDelete->audio_st) {
avcodec_close(muxerToDelete->audio_st->codec);
muxerToDelete->audio_st = NULL;
}
#endif
/* write the trailer, if any. the trailer must be written
* before you close the CodecContexts open when you wrote the
* header; otherwise write_trailer may try to use memory that
* was freed on av_codec_close() */
if (muxerToDelete->oc) {
u32 i;
/* free the streams */
for (i = 0; i < muxerToDelete->oc->nb_streams; i++) {
av_freep(&muxerToDelete->oc->streams[i]->codec);
av_freep(&muxerToDelete->oc->streams[i]);
}
/* free the stream */
av_free(muxerToDelete->oc);
muxerToDelete->oc = NULL;
}
}
Bool ts_encode_audio_frame(GF_AbstractTSMuxer * ts, uint8_t * data, int encoded, u64 pts) {
AVPacketList *pl;
AVPacket * pkt;
if (!ts->encode)
return 1;
pl = gf_malloc(sizeof(AVPacketList));
pl->next = NULL;
pkt = &(pl->pkt);
av_init_packet(pkt);
assert( ts->audio_st);
assert( ts->audio_st->codec);
pkt->flags = 0;
if (ts->audio_st->codec->coded_frame) {
if (ts->audio_st->codec->coded_frame->key_frame)
pkt->flags = AV_PKT_FLAG_KEY;
if (ts->audio_st->codec->coded_frame->pts != AV_NOPTS_VALUE) {
pkt->pts = av_rescale_q(ts->audio_st->codec->coded_frame->pts, ts->audio_st->codec->time_base, ts->audio_st->time_base);
} else {
if (pts == AV_NOPTS_VALUE)
pkt->pts = AV_NOPTS_VALUE;
else {
pkt->pts = av_rescale_q(pts, ts->audio_st->codec->time_base, ts->audio_st->time_base);
}
}
} else {
if (pts == AV_NOPTS_VALUE)
pkt->pts = AV_NOPTS_VALUE;
else
pkt->pts = av_rescale_q(pts, ts->audio_st->codec->time_base, ts->audio_st->time_base);
}
pkt->stream_index= ts->audio_st->index;
pkt->data = data;
pkt->size = encoded;
//fprintf(stderr, "AUDIO PTS="LLU" was: "LLU" (%p)\n", pkt->pts, pts, pl);
gf_mx_p(ts->audioMx);
if (!ts->audioPackets)
ts->audioPackets = pl;
else {
AVPacketList * px = ts->audioPackets;
while (px->next)
px = px->next;
px->next = pl;
}
gf_mx_v(ts->audioMx);
return 0;
}
Bool ts_encode_video_frame(GF_AbstractTSMuxer* ts, uint8_t* data, int encoded) {
AVPacketList *pl;
AVPacket * pkt;
if (!ts->encode)
return 1;
pl = gf_malloc(sizeof(AVPacketList));
pl->next = NULL;
pkt = &(pl->pkt);
av_init_packet(pkt);
if (ts->video_st->codec->coded_frame->pts != AV_NOPTS_VALUE) {
//pkt->pts= av_rescale_q(ts->video_st->codec->coded_frame->pts, ts->video_st->codec->time_base, ts->video_st->time_base);
pkt->pts = ts->video_st->codec->coded_frame->pts * ts->video_st->time_base.den / ts->video_st->time_base.num / 1000;
//pkt->pts = ts->video_st->codec->coded_frame->pts;
}
if (ts->video_st->codec->coded_frame->key_frame)
pkt->flags |= AV_PKT_FLAG_KEY;
pkt->stream_index= ts->video_st->index;
pkt->data= data;
pkt->size= encoded;
//fprintf(stderr, "VIDEO PTS="LLU" was: "LLU" (%p)\n", pkt->pts, ts->video_st->codec->coded_frame->pts, pl);
gf_mx_p(ts->videoMx);
if (!ts->videoPackets)
ts->videoPackets = pl;
else {
AVPacketList * px = ts->videoPackets;
while (px->next)
px = px->next;
px->next = pl;
}
gf_mx_v(ts->videoMx);
return 0;
}
int main(int argc, char **argv)
{
if(argc != 5)
{
fprintf(stderr, "Usage: %s <segment length> <output location> <filename prefix> <encoding profile>\n", argv[0]);
return 1;
}
struct config_info config;
memset(&config, 0, sizeof(struct config_info));
config.segment_length = atoi(argv[1]);
config.temp_directory = argv[2];
config.filename_prefix = argv[3];
config.encoding_profile = argv[4];
config.input_filename = "pipe://1";
char *output_filename = malloc(sizeof(char) * (strlen(config.temp_directory) + 1 + strlen(config.filename_prefix) + 10));
if (!output_filename)
{
fprintf(stderr, "Segmenter error: Could not allocate space for output filenames\n");
exit(1);
}
// ------------------ Done parsing input --------------
av_register_all();
AVInputFormat *input_format = av_find_input_format("mpegts");
if (!input_format)
{
fprintf(stderr, "Segmenter error: Could not find MPEG-TS demuxer\n");
exit(1);
}
AVFormatContext *input_context = NULL;
int ret = av_open_input_file(&input_context, config.input_filename, input_format, 0, NULL);
if (ret != 0)
{
fprintf(stderr, "Segmenter error: Could not open input file, make sure it is an mpegts file: %d\n", ret);
exit(1);
}
if (av_find_stream_info(input_context) < 0)
{
fprintf(stderr, "Segmenter error: Could not read stream information\n");
exit(1);
}
AVOutputFormat *output_format = av_guess_format("mpegts", NULL, NULL);
if (!output_format)
{
fprintf(stderr, "Segmenter error: Could not find MPEG-TS muxer\n");
exit(1);
}
AVFormatContext *output_context = avformat_alloc_context();
if (!output_context)
{
fprintf(stderr, "Segmenter error: Could not allocated output context");
exit(1);
}
output_context->oformat = output_format;
int video_index = -1;
int audio_index = -1;
AVStream *video_stream;
AVStream *audio_stream;
int i;
for (i = 0; i < input_context->nb_streams && (video_index < 0 || audio_index < 0); i++)
{
switch (input_context->streams[i]->codec->codec_type) {
case AVMEDIA_TYPE_VIDEO:
video_index = i;
input_context->streams[i]->discard = AVDISCARD_NONE;
video_stream = add_output_stream(output_context, input_context->streams[i]);
break;
case AVMEDIA_TYPE_AUDIO:
audio_index = i;
input_context->streams[i]->discard = AVDISCARD_NONE;
audio_stream = add_output_stream(output_context, input_context->streams[i]);
break;
default:
input_context->streams[i]->discard = AVDISCARD_ALL;
break;
}
}
if (av_set_parameters(output_context, NULL) < 0)
{
fprintf(stderr, "Segmenter error: Invalid output format parameters\n");
exit(1);
}
av_dump_format(output_context, 0, config.filename_prefix, 1);
if(video_index >= 0)
{
AVCodec *codec = avcodec_find_decoder(video_stream->codec->codec_id);
if (!codec)
{
fprintf(stderr, "Segmenter error: Could not find video decoder, key frames will not be honored\n");
}
if (avcodec_open(video_stream->codec, codec) < 0)
{
fprintf(stderr, "Segmenter error: Could not open video decoder, key frames will not be honored\n");
}
}
unsigned int output_index = 1;
snprintf(output_filename, strlen(config.temp_directory) + 1 + strlen(config.filename_prefix) + 10, "%s/%s-%05u.ts", config.temp_directory, config.filename_prefix, output_index++);
if (avio_open(&output_context->pb, output_filename, URL_WRONLY) < 0)
{
fprintf(stderr, "Segmenter error: Could not open '%s'\n", output_filename);
exit(1);
}
if (av_write_header(output_context))
{
fprintf(stderr, "Segmenter error: Could not write mpegts header to first output file\n");
exit(1);
}
unsigned int first_segment = 1;
unsigned int last_segment = 0;
double prev_segment_time = 0;
int decode_done;
do
{
double segment_time;
AVPacket packet;
decode_done = av_read_frame(input_context, &packet);
if (decode_done < 0)
{
break;
}
if (av_dup_packet(&packet) < 0)
{
fprintf(stderr, "Segmenter error: Could not duplicate packet");
av_free_packet(&packet);
break;
}
if (packet.stream_index == video_index && (packet.flags & AV_PKT_FLAG_KEY))
{
segment_time = (double)video_stream->pts.val * video_stream->time_base.num / video_stream->time_base.den;
}
else if (video_index < 0)
{
segment_time = (double)audio_stream->pts.val * audio_stream->time_base.num / audio_stream->time_base.den;
}
else
{
segment_time = prev_segment_time;
}
// done writing the current file?
if (segment_time - prev_segment_time >= config.segment_length)
{
avio_flush(output_context->pb);
avio_close(output_context->pb);
output_transfer_command(first_segment, ++last_segment, 0, config.encoding_profile);
snprintf(output_filename, strlen(config.temp_directory) + 1 + strlen(config.filename_prefix) + 10, "%s/%s-%05u.ts", config.temp_directory, config.filename_prefix, output_index++);
if (avio_open(&output_context->pb, output_filename, URL_WRONLY) < 0)
{
fprintf(stderr, "Segmenter error: Could not open '%s'\n", output_filename);
break;
}
prev_segment_time = segment_time;
}
ret = av_interleaved_write_frame(output_context, &packet);
if (ret < 0)
{
fprintf(stderr, "Segmenter error: Could not write frame of stream: %d\n", ret);
}
else if (ret > 0)
{
fprintf(stderr, "Segmenter info: End of stream requested\n");
av_free_packet(&packet);
break;
}
av_free_packet(&packet);
} while (!decode_done);
av_write_trailer(output_context);
if (video_index >= 0)
{
avcodec_close(video_stream->codec);
}
for(i = 0; i < output_context->nb_streams; i++)
{
av_freep(&output_context->streams[i]->codec);
av_freep(&output_context->streams[i]);
}
avio_close(output_context->pb);
av_free(output_context);
output_transfer_command(first_segment, ++last_segment, 1, config.encoding_profile);
return 0;
}
uint8_t lavMuxer::open(const char *filename,uint32_t inbitrate, ADM_MUXER_TYPE type, aviInfo *info,uint32_t videoExtraDataSize,
uint8_t *videoExtraData, WAVHeader *audioheader,uint32_t audioextraSize,uint8_t *audioextraData)
{
AVCodecContext *c;
_type=type;
_fps1000=info->fps1000;
switch(_type)
{
case MUXER_TS:
fmt=guess_format("mpegts", NULL, NULL);
break;
case MUXER_DVD:
fmt = guess_format("dvd", NULL, NULL);
break;
case MUXER_VCD:
fmt = guess_format("vcd", NULL, NULL);
break;
case MUXER_SVCD:
fmt = guess_format("svcd", NULL, NULL);
break;
case MUXER_MP4:
fmt = guess_format("mp4", NULL, NULL);
break;
case MUXER_PSP:
fmt = guess_format("psp", NULL, NULL);
break;
default:
fmt=NULL;
}
if (!fmt)
{
printf("Lav:Cannot guess format\n");
return 0;
}
oc = av_alloc_format_context();
if (!oc)
{
printf("Lav:Cannot allocate context\n");
return 0;
}
oc->oformat = fmt;
snprintf(oc->filename,1000,"file://%s",filename);
// Video
//________
video_st = av_new_stream(oc, 0);
if (!video_st)
{
printf("Lav: new stream failed\n");
return 0;
}
c = video_st->codec;
switch(_type)
{
case MUXER_MP4:
if(isMpeg4Compatible(info->fcc))
{
c->codec_id = CODEC_ID_MPEG4;
c->has_b_frames=1; // in doubt...
}else
{
if(isH264Compatible(info->fcc))
{
c->has_b_frames=1; // in doubt...
c->codec_id = CODEC_ID_H264;
c->codec=new AVCodec;
memset(c->codec,0,sizeof(AVCodec));
c->codec->name=ADM_strdup("H264");
}
else
{
c->codec_id = CODEC_ID_MPEG4; // Default value
printf("Ooops, cant mux that...\n");
printf("Ooops, cant mux that...\n");
printf("Ooops, cant mux that...\n");
//return 0;
}
}
if(videoExtraDataSize)
{
c->extradata=videoExtraData;
c->extradata_size= videoExtraDataSize;
}
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_TS:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_DVD:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_VCD:
c->codec_id = CODEC_ID_MPEG1VIDEO;
c->rc_buffer_size=8*1024*40;
c->rc_max_rate=1152*1000;
c->rc_min_rate=1152*1000;
c->bit_rate=1152*1000;
break;
case MUXER_SVCD:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*112;
c->rc_max_rate=2500*1000;
c->rc_min_rate=0*1000;
if(!inbitrate)
c->bit_rate=2040*1000;
else
c->bit_rate=inbitrate;
break;
default:
ADM_assert(0);
}
c->codec_type = CODEC_TYPE_VIDEO;
c->flags=CODEC_FLAG_QSCALE;
c->width = info->width;
c->height = info->height;
switch(_fps1000)
{
case 25000:
c->time_base= (AVRational){1001,25025};
//c->frame_rate = 25025;
//c->frame_rate_base = 1001;
break;
case 23976:
/*
c->frame_rate = 24000;
c->frame_rate_base = 1001;
break;
*/
if(_type==MUXER_MP4)
{
c->time_base= (AVRational){1001,24000};
break;
}
case 29970:
c->time_base= (AVRational){1001,30000};
//c->frame_rate = 30000;
//c->frame_rate_base = 1001;
break;
default:
if(_type==MUXER_MP4)
{
c->time_base= (AVRational){1000,_fps1000};
break;
}
else
{
GUI_Error_HIG(_("Incompatible frame rate"), NULL);
return 0;
}
}
c->gop_size=15;
c->max_b_frames=2;
c->has_b_frames=1;
// Audio
//________
if(audioheader)
{
audio_st = av_new_stream(oc, 1);
if (!audio_st)
{
printf("Lav: new stream failed\n");
return 0;
}
c = audio_st->codec;
c->frame_size=1024; //For AAC mainly, sample per frame
switch(audioheader->encoding)
{
case WAV_AC3: c->codec_id = CODEC_ID_AC3;break;
case WAV_MP2: c->codec_id = CODEC_ID_MP2;break;
case WAV_MP3:
#warning FIXME : Probe deeper
c->frame_size=1152;
c->codec_id = CODEC_ID_MP3;
break;
case WAV_PCM:
// One chunk is 10 ms (1/100 of fq)
c->frame_size=4;
c->codec_id = CODEC_ID_PCM_S16LE;break;
case WAV_AAC:
c->extradata=audioextraData;
c->extradata_size= audioextraSize;
c->codec_id = CODEC_ID_AAC;
break;
default:
printf("Cant mux that ! audio\n");
printf("Cant mux that ! audio\n");
c->codec_id = CODEC_ID_MP2;
return 0;
break;
}
c->codec_type = CODEC_TYPE_AUDIO;
c->bit_rate = audioheader->byterate*8;
c->rc_buffer_size=(c->bit_rate/(2*8)); // 500 ms worth
_audioFq=c->sample_rate = audioheader->frequency;
c->channels = audioheader->channels;
_audioByterate=audioheader->byterate;
}
// /audio
//----------------------
switch(_type)
{
case MUXER_MP4:
oc->mux_rate=10080*1000; // Needed ?
break;
case MUXER_TS:
oc->mux_rate=10080*1000;
break;
case MUXER_DVD:
oc->packet_size=2048;
oc->mux_rate=10080*1000;
break;
case MUXER_VCD:
oc->packet_size=2324;
oc->mux_rate=2352 * 75 * 8;
break;
case MUXER_SVCD:
oc->packet_size=2324;
oc->mux_rate=2*2352 * 75 * 8; // ?
break;
default:
ADM_assert(0);
}
oc->preload=AV_TIME_BASE/10; // 100 ms preloading
oc->max_delay=200*1000; // 500 ms
if (av_set_parameters(oc, NULL) < 0)
{
printf("Lav: set param failed \n");
return 0;
}
if (url_fopen(&(oc->pb), filename, URL_WRONLY) < 0)
{
printf("Lav: Failed to open file :%s\n",filename);
return 0;
}
av_write_header(oc);
dump_format(oc, 0, filename, 1);
printf("lavformat mpeg muxer initialized\n");
_running=1;
one=(1000*1000*1000)/_fps1000;
_curDTS=one;
return 1;
}
glw_rec_t *
glw_rec_init(const char *filename, int width, int height, int fps)
{
extern int concurrency;
AVCodec *c;
struct glw_rec *gr = calloc(1, sizeof(glw_rec_t));
gr->width = width;
gr->height = height;
gr->fps = fps;
gr->fmt = av_guess_format(NULL, filename, NULL);
if(gr->fmt == NULL) {
TRACE(TRACE_ERROR, "GLWREC",
"Unable to record to %s -- Unknown file format",
filename);
return NULL;
}
gr->oc = avformat_alloc_context();
gr->oc->oformat = gr->fmt;
snprintf(gr->oc->filename, sizeof(gr->oc->filename), "%s", filename);
gr->v_st = av_new_stream(gr->oc, 0);
gr->v_ctx = gr->v_st->codec;
gr->v_ctx->codec_type = AVMEDIA_TYPE_VIDEO;
gr->v_ctx->codec_id = CODEC_ID_FFVHUFF;
gr->v_ctx->width = width;
gr->v_ctx->height = height;
gr->v_ctx->time_base.den = fps;
gr->v_ctx->time_base.num = 1;
gr->v_ctx->pix_fmt = PIX_FMT_RGB32;
gr->v_ctx->coder_type = 1;
if(av_set_parameters(gr->oc, NULL) < 0) {
TRACE(TRACE_ERROR, "GLWREC",
"Unable to record to %s -- Invalid output format parameters",
filename);
return NULL;
}
dump_format(gr->oc, 0, filename, 1);
c = avcodec_find_encoder(gr->v_ctx->codec_id);
if(avcodec_open(gr->v_ctx, c)) {
TRACE(TRACE_ERROR, "GLWREC",
"Unable to record to %s -- Unable to open video codec",
filename);
return NULL;
}
gr->v_ctx->thread_count = concurrency;
if(url_fopen(&gr->oc->pb, filename, URL_WRONLY) < 0) {
TRACE(TRACE_ERROR, "GLWREC",
"Unable to record to %s -- Unable to open file for writing",
filename);
return NULL;
}
/* write the stream header, if any */
av_write_header(gr->oc);
gr->vbuf_size = 2000000;
gr->vbuf_ptr = av_malloc(gr->vbuf_size);
return gr;
}
// ######################################################################
FfmpegEncoder::FfmpegEncoder(const std::string& fname,
const std::string& codecname,
const int bitrate,
const int framerate,
const int frameratebase,
const Dims& dims,
const int bufsz,
const bool useFormatContext)
:
itsFile(0),
itsContext(),
itsFormatContext(0),
itsFrameNumber(0),
itsOutbufSize(bufsz),
itsFrameSizeRange(),
itsUseFormatContext(useFormatContext)
{
GVX_TRACE(__PRETTY_FUNCTION__);
// no need to guard these functions for being called multiple times;
// they all have internal guards
av_register_all();
avcodec_init();
avcodec_register_all();
AVOutputFormat* oformat = NULL;
#if LIBAVCODEC_VERSION_MAJOR >= 53 && LIBAVCODEC_VERSION_MINOR >= 21
if (codecname.compare("List") == 0) { // list available codecs
LINFO("##### Available output codecs (not all may work for video):");
AVOutputFormat* f = av_oformat_next(NULL);
while(f) {
LINFO("%s: %s %d", f->name, f->long_name, f->flags);
f = av_oformat_next(f);
}
LFATAL("Please select a codec from this list");
} else { // format is given
// no av_find_output_format()?? let's do it by hand...
AVOutputFormat* f = av_oformat_next(NULL);
while(f) {
if (codecname.compare(f->name) == 0) { oformat = f; break; }
f = av_oformat_next(f);
}
}
#else
if (codecname.compare("List") == 0) { // list available codecs
LINFO("##### Available output codecs (not all may work for video):");
for(AVOutputFormat* f = first_oformat; f != NULL; f = f->next)
LINFO("%s: %s %d", f->name, f->long_name, f->flags);
LFATAL("Please select a codec from this list");
} else { // format is given
// no av_find_output_format()?? let's do it by hand...
for(AVOutputFormat* f = first_oformat; f != NULL; f = f->next)
if (codecname.compare(f->name) == 0)
{ oformat = f; break; }
}
#endif
if (oformat == 0)
LFATAL("No such video codec '%s';\n"
"try re-running with --output-codec=List to see a list\n"
"of available codecs", codecname.c_str());
char ext[100]; ext[0] = '.'; uint i;
for (i = 0; i < strlen(oformat->extensions); i ++)
if (oformat->extensions[i] == ',') break;
else ext[i+1] = oformat->extensions[i];
ext[i+1] = '\0';
LINFO("Using output format '%s' (%s), extension %s", oformat->name,
oformat->long_name, ext);
std::string oname(fname);
std::string::size_type idx1 = oname.rfind('/', oname.npos);
std::string::size_type idx2 = oname.rfind('.', oname.npos);
// must check that idx2 is valid; otherwise if we do
// oname.erase(idx2) with e.g. idx2==npos then we will get a
// std::out_of_range exception
if (idx2 < oname.size() && idx2 > idx1)
oname.erase(idx2, oname.npos);
oname.append(ext);
LINFO("Output file: %s", oname.c_str());
if (itsUseFormatContext)
{
#ifdef INVT_FFMPEG_HAS_FORMATCONTEXT_FUNCTIONS
LINFO("Using FormatContext to output data");
#ifdef AVMEDIA_TYPE_VIDEO
itsFormatContext = avformat_alloc_context();
#else
itsFormatContext = av_alloc_format_context();
#endif
if (!itsFormatContext)
LFATAL("Cannot allocate format context");
itsFormatContext->oformat = oformat;
itsAVStream = av_new_stream(itsFormatContext, 0);
if (!itsAVStream)
LFATAL("Can not allocate AVStream");
#else
LFATAL("Need a new version of ffmpeg libs for this option");
itsFormatContext = NULL;
#endif
}
AVCodec* const codec = avcodec_find_encoder(oformat->video_codec);
if (codec == NULL) LFATAL("codec not found");
#if defined(INVT_FFMPEG_HAS_DEFAULTS_FUNCTIONS)
avcodec_get_context_defaults(&itsContext);
#else
{
AVCodecContext* const tmp = avcodec_alloc_context();
memcpy(&itsContext, tmp, sizeof(AVCodecContext));
free(tmp);
}
#endif
itsContext.bit_rate = bitrate;
// Be sure to set itsContext.pix_fmt -- it may occasionally
// appear to work to leave pix_fmt unset, because the value we want,
// PIX_FMT_YUV420P, has the enum value of 0, so if the uninitialized
// memory for pix_fmt happens to have the value 0, then we'll slip
// through without setting it explicitly.
itsContext.pix_fmt = PIX_FMT_YUV420P;
/* resolution must be a multiple of two */
itsContext.width = dims.w();
itsContext.height = dims.h();
#if defined(INVT_FFMPEG_AVCODECCONTEXT_HAS_TIME_BASE)
AVRational time_base = { frameratebase, framerate };
itsContext.time_base = time_base;
const int frb = frameratebase;
#elif LIBAVCODEC_VERSION_INT >= 0x000406 && LIBAVCODEC_BUILD > 4665
itsContext.frame_rate = framerate;
const int frb = frameratebase;
itsContext.frame_rate_base = frb;
#else
itsContext.frame_rate = framerate;
const int frb = FRAME_RATE_BASE;
#endif
itsContext.gop_size = 10; /* emit one intra frame every ten frames */
if(codec->id != CODEC_ID_MPEG4 &&
codec->id != CODEC_ID_MPEG1VIDEO &&
codec->id != CODEC_ID_MPEG2VIDEO)
itsContext.max_b_frames = 0;
else
itsContext.max_b_frames = 1;
itsFrameNumber = 0;
LINFO("using max_b_frames=%i bitrate=%u width=%u height=%u framerate=%u frameratebase=%u",
itsContext.max_b_frames, itsContext.bit_rate, itsContext.width, itsContext.height, framerate, frb);
if (avcodec_open(&itsContext, codec) < 0)
LFATAL("could not open codec\n");
if (itsUseFormatContext)
{
#ifdef INVT_FFMPEG_HAS_FORMATCONTEXT_FUNCTIONS
AVCodecContext *c = itsAVStream->codec;
c->codec_id = itsContext.codec_id;
#ifdef CODEC_TYPE_VIDEO
c->codec_type = CODEC_TYPE_VIDEO;
#else
#ifdef AVMEDIA_TYPE_VIDEO
c->codec_type = AVMEDIA_TYPE_VIDEO;
#endif
#endif
/* put sample parameters */
c->bit_rate = itsContext.bit_rate;
/* resolution must be a multiple of two */
c->width = itsContext.width;
c->height = itsContext.height;
/* time base: this is the fundamental unit of time (in seconds) in terms
of which frame timestamps are represented. for fixed-fps content,
timebase should be 1/framerate and timestamp increments should be
identically 1. */
#if defined(INVT_FFMPEG_AVCODECCONTEXT_HAS_TIME_BASE)
c->time_base.den = itsContext.time_base.den;
c->time_base.num = itsContext.time_base.num;
#endif
c->gop_size = 12; /* emit one intra frame every twelve frames at most */
c->pix_fmt = itsContext.pix_fmt;
/* set the output parameters (must be done even if no
parameters). */
if (av_set_parameters(itsFormatContext, NULL) < 0)
LFATAL("Invalid output format parameters");
#if defined(INVT_FFMPEG_URL_OPEN_FUNC_TAKES_SINGLE_POINTER)
#if defined(INVT_FFMPEG_AVFORMATCONTEXT_BYTEIO_ISPOINTER)
if (url_fopen(itsFormatContext->pb, oname.c_str(), URL_WRONLY) < 0)
LFATAL("Could not open '%s'", oname.c_str());
#else
if (url_fopen(&itsFormatContext->pb, oname.c_str(), URL_WRONLY) < 0)
LFATAL("Could not open '%s'", oname.c_str());
#endif
#else
#if defined(INVT_FFMPEG_AVFORMATCONTEXT_BYTEIO_ISPOINTER)
if (url_fopen(&itsFormatContext->pb, oname.c_str(), URL_WRONLY) < 0)
LFATAL("Could not open '%s'", oname.c_str());
#else
LFATAL("Could not open '%s' ffmpeg version mismatch", oname.c_str());
#endif
#endif //INVT_FFMPEG_URL_OPEN_FUNC_TAKES_SINGLE_POINTER)
/* write the stream header, if any */
av_write_header(itsFormatContext);
#else
LFATAL("Need a new version of FFMPEG for this option");
#endif
} else {
itsFile = fopen(oname.c_str(), "w");
if (itsFile==NULL)
LFATAL("could not open file! %s", oname.c_str());
}
LINFO("EnCoder Inited");
}
static struct proxy_output_ctx * alloc_proxy_output_ffmpeg(
struct anim * anim,
AVStream * st, int proxy_size, int width, int height,
int quality)
{
struct proxy_output_ctx * rv = MEM_callocN(
sizeof(struct proxy_output_ctx), "alloc_proxy_output");
char fname[FILE_MAXDIR+FILE_MAXFILE];
// JPEG requires this
width = round_up(width, 8);
height = round_up(height, 8);
rv->proxy_size = proxy_size;
rv->anim = anim;
get_proxy_filename(rv->anim, rv->proxy_size, fname, TRUE);
BLI_make_existing_file(fname);
rv->of = avformat_alloc_context();
rv->of->oformat = av_guess_format("avi", NULL, NULL);
BLI_snprintf(rv->of->filename, sizeof(rv->of->filename), "%s", fname);
fprintf(stderr, "Starting work on proxy: %s\n", rv->of->filename);
rv->st = av_new_stream(rv->of, 0);
rv->c = rv->st->codec;
rv->c->codec_type = AVMEDIA_TYPE_VIDEO;
rv->c->codec_id = CODEC_ID_MJPEG;
rv->c->width = width;
rv->c->height = height;
rv->of->oformat->video_codec = rv->c->codec_id;
rv->codec = avcodec_find_encoder(rv->c->codec_id);
if (!rv->codec) {
fprintf(stderr, "No ffmpeg MJPEG encoder available? "
"Proxy not built!\n");
av_free(rv->of);
return NULL;
}
if (rv->codec->pix_fmts) {
rv->c->pix_fmt = rv->codec->pix_fmts[0];
} else {
rv->c->pix_fmt = PIX_FMT_YUVJ420P;
}
rv->c->sample_aspect_ratio
= rv->st->sample_aspect_ratio
= st->codec->sample_aspect_ratio;
rv->c->time_base.den = 25;
rv->c->time_base.num = 1;
rv->st->time_base = rv->c->time_base;
if (rv->of->flags & AVFMT_GLOBALHEADER) {
rv->c->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
if (av_set_parameters(rv->of, NULL) < 0) {
fprintf(stderr, "Couldn't set output parameters? "
"Proxy not built!\n");
av_free(rv->of);
return 0;
}
if (avio_open(&rv->of->pb, fname, AVIO_FLAG_WRITE) < 0) {
fprintf(stderr, "Couldn't open outputfile! "
"Proxy not built!\n");
av_free(rv->of);
return 0;
}
avcodec_open(rv->c, rv->codec);
rv->video_buffersize = 2000000;
rv->video_buffer = (uint8_t*)MEM_mallocN(
rv->video_buffersize, "FFMPEG video buffer");
rv->orig_height = st->codec->height;
if (st->codec->width != width || st->codec->height != height
|| st->codec->pix_fmt != rv->c->pix_fmt) {
rv->frame = avcodec_alloc_frame();
avpicture_fill((AVPicture*) rv->frame,
MEM_mallocN(avpicture_get_size(
rv->c->pix_fmt,
round_up(width, 16), height),
"alloc proxy output frame"),
rv->c->pix_fmt, round_up(width, 16), height);
rv->sws_ctx = sws_getContext(
st->codec->width,
st->codec->height,
st->codec->pix_fmt,
width, height,
rv->c->pix_fmt,
SWS_FAST_BILINEAR | SWS_PRINT_INFO,
NULL, NULL, NULL);
}
av_write_header(rv->of);
return rv;
}
