public void stop() throws Exception {
// Free the RGB image
if (buffer != null) {
av_free(buffer);
buffer = null;
}
if (pFrameRGB != null) {
av_free(pFrameRGB);
pFrameRGB = null;
}
// Free the YUV frame
if (pFrame != null) {
av_free(pFrame);
pFrame = null;
}
// Close the codec
if (pCodecCtx != null) {
avcodec_close(pCodecCtx);
pCodecCtx = null;
}
// Close the video file
if (pFormatCtx != null && !pFormatCtx.isNull()) {
av_close_input_file(pFormatCtx);
pFormatCtx = null;
}
if (return_image != null) {
return_image.release();
return_image = null;
}
}
public void trigger() throws Exception {
if (pFormatCtx == null || pFormatCtx.isNull()) {
throw new Exception("Could not trigger: No AVFormatContext. (Has start() been called?)");
}
for (int i = 0; i < triggerFlushSize; i++) {
if (av_read_frame(pFormatCtx, packet) < 0) {
return;
}
av_free_packet(packet);
}
}
void startUnsafe() throws Exception {
int ret;
picture = null;
tmp_picture = null;
picture_buf = null;
frame = null;
video_outbuf = null;
audio_outbuf = null;
oc = null;
video_c = null;
audio_c = null;
video_st = null;
audio_st = null;
got_video_packet = new int[1];
got_audio_packet = new int[1];
/* auto detect the output format from the name. */
String format_name = format == null || format.length() == 0 ? null : format;
if ((oformat = av_guess_format(format_name, filename, null)) == null) {
int proto = filename.indexOf("://");
if (proto > 0) {
format_name = filename.substring(0, proto);
}
if ((oformat = av_guess_format(format_name, filename, null)) == null) {
throw new Exception(
"av_guess_format() error: Could not guess output format for \""
+ filename
+ "\" and "
+ format
+ " format.");
}
}
format_name = oformat.name().getString();
/* allocate the output media context */
if ((oc = avformat_alloc_context()) == null) {
throw new Exception("avformat_alloc_context() error: Could not allocate format context");
}
oc.oformat(oformat);
oc.filename().putString(filename);
/* add the audio and video streams using the format codecs
and initialize the codecs */
if (imageWidth > 0 && imageHeight > 0) {
if (videoCodec != AV_CODEC_ID_NONE) {
oformat.video_codec(videoCodec);
} else if ("flv".equals(format_name)) {
oformat.video_codec(AV_CODEC_ID_FLV1);
} else if ("mp4".equals(format_name)) {
oformat.video_codec(AV_CODEC_ID_MPEG4);
} else if ("3gp".equals(format_name)) {
oformat.video_codec(AV_CODEC_ID_H263);
} else if ("avi".equals(format_name)) {
oformat.video_codec(AV_CODEC_ID_HUFFYUV);
}
/* find the video encoder */
if ((video_codec = avcodec_find_encoder_by_name(videoCodecName)) == null
&& (video_codec = avcodec_find_encoder(oformat.video_codec())) == null) {
release();
throw new Exception("avcodec_find_encoder() error: Video codec not found.");
}
oformat.video_codec(video_codec.id());
AVRational frame_rate = av_d2q(frameRate, 1001000);
AVRational supported_framerates = video_codec.supported_framerates();
if (supported_framerates != null) {
int idx = av_find_nearest_q_idx(frame_rate, supported_framerates);
frame_rate = supported_framerates.position(idx);
}
/* add a video output stream */
if ((video_st = avformat_new_stream(oc, video_codec)) == null) {
release();
throw new Exception("avformat_new_stream() error: Could not allocate video stream.");
}
video_c = video_st.codec();
video_c.codec_id(oformat.video_codec());
video_c.codec_type(AVMEDIA_TYPE_VIDEO);
/* put sample parameters */
video_c.bit_rate(videoBitrate);
/* resolution must be a multiple of two, but round up to 16 as often required */
video_c.width((imageWidth + 15) / 16 * 16);
video_c.height(imageHeight);
if (aspectRatio > 0) {
AVRational r = av_d2q(aspectRatio, 255);
video_c.sample_aspect_ratio(r);
video_st.sample_aspect_ratio(r);
}
/* 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. */
video_c.time_base(av_inv_q(frame_rate));
video_st.time_base(av_inv_q(frame_rate));
if (gopSize >= 0) {
video_c.gop_size(gopSize); /* emit one intra frame every gopSize frames at most */
}
if (videoQuality >= 0) {
video_c.flags(video_c.flags() | CODEC_FLAG_QSCALE);
video_c.global_quality((int) Math.round(FF_QP2LAMBDA * videoQuality));
}
if (pixelFormat != AV_PIX_FMT_NONE) {
video_c.pix_fmt(pixelFormat);
} else if (video_c.codec_id() == AV_CODEC_ID_RAWVIDEO
|| video_c.codec_id() == AV_CODEC_ID_PNG
|| video_c.codec_id() == AV_CODEC_ID_HUFFYUV
|| video_c.codec_id() == AV_CODEC_ID_FFV1) {
video_c.pix_fmt(AV_PIX_FMT_RGB32); // appropriate for common lossless formats
} else {
video_c.pix_fmt(AV_PIX_FMT_YUV420P); // lossy, but works with about everything
}
if (video_c.codec_id() == AV_CODEC_ID_MPEG2VIDEO) {
/* just for testing, we also add B frames */
video_c.max_b_frames(2);
} else if (video_c.codec_id() == AV_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. */
video_c.mb_decision(2);
} else if (video_c.codec_id() == AV_CODEC_ID_H263) {
// H.263 does not support any other resolution than the following
if (imageWidth <= 128 && imageHeight <= 96) {
video_c.width(128).height(96);
} else if (imageWidth <= 176 && imageHeight <= 144) {
video_c.width(176).height(144);
} else if (imageWidth <= 352 && imageHeight <= 288) {
video_c.width(352).height(288);
} else if (imageWidth <= 704 && imageHeight <= 576) {
video_c.width(704).height(576);
} else {
video_c.width(1408).height(1152);
}
} else if (video_c.codec_id() == AV_CODEC_ID_H264) {
// default to constrained baseline to produce content that plays back on anything,
// without any significant tradeoffs for most use cases
video_c.profile(AVCodecContext.FF_PROFILE_H264_CONSTRAINED_BASELINE);
}
// some formats want stream headers to be separate
if ((oformat.flags() & AVFMT_GLOBALHEADER) != 0) {
video_c.flags(video_c.flags() | CODEC_FLAG_GLOBAL_HEADER);
}
if ((video_codec.capabilities() & CODEC_CAP_EXPERIMENTAL) != 0) {
video_c.strict_std_compliance(AVCodecContext.FF_COMPLIANCE_EXPERIMENTAL);
}
}
/*
* add an audio output stream
*/
if (audioChannels > 0 && audioBitrate > 0 && sampleRate > 0) {
if (audioCodec != AV_CODEC_ID_NONE) {
oformat.audio_codec(audioCodec);
} else if ("flv".equals(format_name)
|| "mp4".equals(format_name)
|| "3gp".equals(format_name)) {
oformat.audio_codec(AV_CODEC_ID_AAC);
} else if ("avi".equals(format_name)) {
oformat.audio_codec(AV_CODEC_ID_PCM_S16LE);
}
/* find the audio encoder */
if ((audio_codec = avcodec_find_encoder_by_name(audioCodecName)) == null
&& (audio_codec = avcodec_find_encoder(oformat.audio_codec())) == null) {
release();
throw new Exception("avcodec_find_encoder() error: Audio codec not found.");
}
if ((audio_st = avformat_new_stream(oc, audio_codec)) == null) {
release();
throw new Exception("avformat_new_stream() error: Could not allocate audio stream.");
}
audio_c = audio_st.codec();
audio_c.codec_id(oformat.audio_codec());
audio_c.codec_type(AVMEDIA_TYPE_AUDIO);
/* put sample parameters */
audio_c.bit_rate(audioBitrate);
audio_c.sample_rate(sampleRate);
audio_c.channels(audioChannels);
audio_c.channel_layout(av_get_default_channel_layout(audioChannels));
if (sampleFormat != AV_SAMPLE_FMT_NONE) {
audio_c.sample_fmt(sampleFormat);
} else {
// use AV_SAMPLE_FMT_S16 by default, if available
audio_c.sample_fmt(AV_SAMPLE_FMT_FLTP);
IntPointer formats = audio_c.codec().sample_fmts();
for (int i = 0; formats.get(i) != -1; i++) {
if (formats.get(i) == AV_SAMPLE_FMT_S16) {
audio_c.sample_fmt(AV_SAMPLE_FMT_S16);
break;
}
}
}
audio_c.time_base().num(1).den(sampleRate);
audio_st.time_base().num(1).den(sampleRate);
switch (audio_c.sample_fmt()) {
case AV_SAMPLE_FMT_U8:
case AV_SAMPLE_FMT_U8P:
audio_c.bits_per_raw_sample(8);
break;
case AV_SAMPLE_FMT_S16:
case AV_SAMPLE_FMT_S16P:
audio_c.bits_per_raw_sample(16);
break;
case AV_SAMPLE_FMT_S32:
case AV_SAMPLE_FMT_S32P:
audio_c.bits_per_raw_sample(32);
break;
case AV_SAMPLE_FMT_FLT:
case AV_SAMPLE_FMT_FLTP:
audio_c.bits_per_raw_sample(32);
break;
case AV_SAMPLE_FMT_DBL:
case AV_SAMPLE_FMT_DBLP:
audio_c.bits_per_raw_sample(64);
break;
default:
assert false;
}
if (audioQuality >= 0) {
audio_c.flags(audio_c.flags() | CODEC_FLAG_QSCALE);
audio_c.global_quality((int) Math.round(FF_QP2LAMBDA * audioQuality));
}
// some formats want stream headers to be separate
if ((oformat.flags() & AVFMT_GLOBALHEADER) != 0) {
audio_c.flags(audio_c.flags() | CODEC_FLAG_GLOBAL_HEADER);
}
if ((audio_codec.capabilities() & CODEC_CAP_EXPERIMENTAL) != 0) {
audio_c.strict_std_compliance(AVCodecContext.FF_COMPLIANCE_EXPERIMENTAL);
}
}
av_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 != null) {
AVDictionary options = new AVDictionary(null);
if (videoQuality >= 0) {
av_dict_set(options, "crf", "" + videoQuality, 0);
}
for (Entry<String, String> e : videoOptions.entrySet()) {
av_dict_set(options, e.getKey(), e.getValue(), 0);
}
/* open the codec */
if ((ret = avcodec_open2(video_c, video_codec, options)) < 0) {
release();
throw new Exception("avcodec_open2() error " + ret + ": Could not open video codec.");
}
av_dict_free(options);
video_outbuf = null;
if ((oformat.flags() & AVFMT_RAWPICTURE) == 0) {
/* allocate output buffer */
/* XXX: API change will be done */
/* buffers passed into lav* can be allocated any way you prefer,
as long as they're aligned enough for the architecture, and
they're freed appropriately (such as using av_free for buffers
allocated with av_malloc) */
video_outbuf_size =
Math.max(256 * 1024, 8 * video_c.width() * video_c.height()); // a la ffmpeg.c
video_outbuf = new BytePointer(av_malloc(video_outbuf_size));
}
/* allocate the encoded raw picture */
if ((picture = av_frame_alloc()) == null) {
release();
throw new Exception("av_frame_alloc() error: Could not allocate picture.");
}
picture.pts(0); // magic required by libx264
int size = avpicture_get_size(video_c.pix_fmt(), video_c.width(), video_c.height());
if ((picture_buf = new BytePointer(av_malloc(size))).isNull()) {
release();
throw new Exception("av_malloc() error: Could not allocate picture buffer.");
}
/* if the output format is not equal to the image format, then a temporary
picture is needed too. It is then converted to the required output format */
if ((tmp_picture = av_frame_alloc()) == null) {
release();
throw new Exception("av_frame_alloc() error: Could not allocate temporary picture.");
}
AVDictionary metadata = new AVDictionary(null);
for (Entry<String, String> e : videoMetadata.entrySet()) {
av_dict_set(metadata, e.getKey(), e.getValue(), 0);
}
video_st.metadata(metadata);
}
if (audio_st != null) {
AVDictionary options = new AVDictionary(null);
if (audioQuality >= 0) {
av_dict_set(options, "crf", "" + audioQuality, 0);
}
for (Entry<String, String> e : audioOptions.entrySet()) {
av_dict_set(options, e.getKey(), e.getValue(), 0);
}
/* open the codec */
if ((ret = avcodec_open2(audio_c, audio_codec, options)) < 0) {
release();
throw new Exception("avcodec_open2() error " + ret + ": Could not open audio codec.");
}
av_dict_free(options);
audio_outbuf_size = 256 * 1024;
audio_outbuf = new BytePointer(av_malloc(audio_outbuf_size));
/* ugly hack for PCM codecs (will be removed ASAP with new PCM
support to compute the input frame size in samples */
if (audio_c.frame_size() <= 1) {
audio_outbuf_size = FF_MIN_BUFFER_SIZE;
audio_input_frame_size = audio_outbuf_size / audio_c.channels();
switch (audio_c.codec_id()) {
case AV_CODEC_ID_PCM_S16LE:
case AV_CODEC_ID_PCM_S16BE:
case AV_CODEC_ID_PCM_U16LE:
case AV_CODEC_ID_PCM_U16BE:
audio_input_frame_size >>= 1;
break;
default:
break;
}
} else {
audio_input_frame_size = audio_c.frame_size();
}
// int bufferSize = audio_input_frame_size * audio_c.bits_per_raw_sample()/8 *
// audio_c.channels();
int planes =
av_sample_fmt_is_planar(audio_c.sample_fmt()) != 0 ? (int) audio_c.channels() : 1;
int data_size =
av_samples_get_buffer_size(
(IntPointer) null,
audio_c.channels(),
audio_input_frame_size,
audio_c.sample_fmt(),
1)
/ planes;
samples_out = new BytePointer[planes];
for (int i = 0; i < samples_out.length; i++) {
samples_out[i] = new BytePointer(av_malloc(data_size)).capacity(data_size);
}
samples_in = new Pointer[AVFrame.AV_NUM_DATA_POINTERS];
samples_in_ptr = new PointerPointer(AVFrame.AV_NUM_DATA_POINTERS);
samples_out_ptr = new PointerPointer(AVFrame.AV_NUM_DATA_POINTERS);
/* allocate the audio frame */
if ((frame = av_frame_alloc()) == null) {
release();
throw new Exception("av_frame_alloc() error: Could not allocate audio frame.");
}
frame.pts(0); // magic required by libvorbis and webm
AVDictionary metadata = new AVDictionary(null);
for (Entry<String, String> e : audioMetadata.entrySet()) {
av_dict_set(metadata, e.getKey(), e.getValue(), 0);
}
audio_st.metadata(metadata);
}
/* open the output file, if needed */
if ((oformat.flags() & AVFMT_NOFILE) == 0) {
AVIOContext pb = new AVIOContext(null);
if ((ret = avio_open(pb, filename, AVIO_FLAG_WRITE)) < 0) {
release();
throw new Exception(
"avio_open error() error " + ret + ": Could not open '" + filename + "'");
}
oc.pb(pb);
}
AVDictionary options = new AVDictionary(null);
for (Entry<String, String> e : this.options.entrySet()) {
av_dict_set(options, e.getKey(), e.getValue(), 0);
}
AVDictionary metadata = new AVDictionary(null);
for (Entry<String, String> e : this.metadata.entrySet()) {
av_dict_set(metadata, e.getKey(), e.getValue(), 0);
}
/* write the stream header, if any */
avformat_write_header(oc.metadata(metadata), options);
av_dict_free(options);
}
public IplImage grab() throws Exception {
if (pFormatCtx == null || pFormatCtx.isNull()) {
throw new Exception("Could not grab: No AVFormatContext. (Has start() been called?)");
}
boolean done = false;
long pts = 0;
while (!done) {
if (av_read_frame(pFormatCtx, packet) < 0) {
// throw new Exception("Could not read frame");
return null; // end of file?
}
// Is this a packet from the video stream?
if (packet.stream_index() == videoStream) {
// Decode video frame
int len = avcodec_decode_video2(pCodecCtx, pFrame, frameFinished, packet);
LongPointer opaque = new LongPointer(pFrame.opaque());
if (packet.dts() != AV_NOPTS_VALUE) {
pts = packet.dts();
} else if (!opaque.isNull() && opaque.get() != AV_NOPTS_VALUE) {
pts = opaque.get();
} else {
pts = 0;
}
AVRational time_base = pStream.time_base();
pts = 1000 * pts * time_base.num() / time_base.den();
// Did we get a video frame?
if (len > 0 && frameFinished[0] != 0) {
switch (colorMode) {
case BGR:
case GRAY:
// Deinterlace Picture
if (deinterlace) {
avpicture_deinterlace(
pFrame, pFrame, pCodecCtx.pix_fmt(), pCodecCtx.width(), pCodecCtx.height());
}
// Convert the image from its native format to RGB
sws_scale(
img_convert_ctx,
new PointerPointer(pFrame),
pFrame.linesize(),
0,
pCodecCtx.height(),
new PointerPointer(pFrameRGB),
pFrameRGB.linesize());
return_image.imageData(buffer);
return_image.widthStep(pFrameRGB.linesize(0));
break;
case RAW:
assert (pCodecCtx.width() == return_image.width()
&& pCodecCtx.height() == return_image.height());
return_image.imageData(pFrame.data(0));
return_image.widthStep(pFrame.linesize(0));
break;
default:
assert (false);
}
return_image.imageSize(return_image.height() * return_image.widthStep());
done = true;
}
}
// Free the packet that was allocated by av_read_frame
av_free_packet(packet);
}
return_image.timestamp = pts;
return return_image;
}
public void start() throws Exception {
// Open video file
AVInputFormat f = null;
if (format != null && format.length() > 0) {
f = av_find_input_format(format);
if (f == null) {
throw new Exception("Could not find input format \"" + format + "\".");
}
}
AVFormatParameters fp = null;
if (frameRate > 0 || bpp > 0 || imageWidth > 0 || imageHeight > 0) {
fp = new AVFormatParameters();
fp.time_base(av_d2q(1 / frameRate, FFmpegFrameRecorder.DEFAULT_FRAME_RATE_BASE));
fp.sample_rate(bpp);
fp.channels(colorMode == ColorMode.BGR ? 3 : 1);
fp.width(imageWidth);
fp.height(imageHeight);
}
if (av_open_input_file(pFormatCtx, filename, f, 0, fp) != 0) {
throw new Exception("Could not open file \"" + filename + "\".");
}
// Retrieve stream information
if (av_find_stream_info(pFormatCtx) < 0) {
throw new Exception("Could not find stream information.");
}
// Dump information about file onto standard error
dump_format(pFormatCtx, 0, filename, 0);
// Find the first video stream
videoStream = -1;
int nb_streams = pFormatCtx.nb_streams();
for (int i = 0; i < nb_streams; i++) {
pStream = pFormatCtx.streams(i);
// Get a pointer to the codec context for the video stream
pCodecCtx = pStream.codec();
if (pCodecCtx.codec_type() == CODEC_TYPE_VIDEO) {
videoStream = i;
break;
}
}
if (videoStream == -1) {
throw new Exception("Did not find a video stream.");
}
// Find the decoder for the video stream
pCodec = avcodec_find_decoder(pCodecCtx.codec_id());
if (pCodec == null) {
throw new Exception("Unsupported codec or codec not found: " + pCodecCtx.codec_id() + ".");
}
// Open codec
if (avcodec_open(pCodecCtx, pCodec) < 0) {
throw new Exception("Could not open codec.");
}
// Allocate video frame
pFrame = avcodec_alloc_frame();
// Allocate an AVFrame structure
pFrameRGB = avcodec_alloc_frame();
if (pFrameRGB == null) {
throw new Exception("Could not allocate frame.");
}
int width = getImageWidth() > 0 ? getImageWidth() : pCodecCtx.width();
int height = getImageHeight() > 0 ? getImageHeight() : pCodecCtx.height();
switch (colorMode) {
case BGR:
// Determine required buffer size and allocate buffer
numBytes = avpicture_get_size(PIX_FMT_BGR24, width, height);
buffer = new BytePointer(av_malloc(numBytes));
// Assign appropriate parts of buffer to image planes in pFrameRGB
// Note that pFrameRGB is an AVFrame, but AVFrame is a superset
// of AVPicture
avpicture_fill(pFrameRGB, buffer, PIX_FMT_BGR24, width, height);
// Convert the image into BGR format that OpenCV uses
img_convert_ctx =
sws_getContext(
pCodecCtx.width(),
pCodecCtx.height(),
pCodecCtx.pix_fmt(),
width,
height,
PIX_FMT_BGR24,
SWS_BILINEAR,
null,
null,
null);
if (img_convert_ctx == null) {
throw new Exception("Cannot initialize the conversion context.");
}
return_image = IplImage.createHeader(width, height, IPL_DEPTH_8U, 3);
break;
case GRAY:
numBytes = avpicture_get_size(PIX_FMT_GRAY8, width, height);
buffer = new BytePointer(av_malloc(numBytes));
avpicture_fill(pFrameRGB, buffer, PIX_FMT_GRAY8, width, height);
// Convert the image into GRAY format that OpenCV uses
img_convert_ctx =
sws_getContext(
pCodecCtx.width(),
pCodecCtx.height(),
pCodecCtx.pix_fmt(),
width,
height,
PIX_FMT_GRAY8,
SWS_BILINEAR,
null,
null,
null);
if (img_convert_ctx == null) {
throw new Exception("Cannot initialize the conversion context.");
}
return_image = IplImage.createHeader(width, height, IPL_DEPTH_8U, 1);
break;
case RAW:
numBytes = 0;
buffer = null;
img_convert_ctx = null;
return_image =
IplImage.createHeader(pCodecCtx.width(), pCodecCtx.height(), IPL_DEPTH_8U, 1);
break;
default:
assert (false);
}
}
