|
|
|
package org.bytedeco.javacv;
|
|
|
|
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.AV_PKT_FLAG_KEY;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.av_jni_set_java_vm;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.av_packet_unref;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_alloc_context3;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_decode_audio4;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_decode_video2;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_find_decoder;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_find_decoder_by_name;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_flush_buffers;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_free_context;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_open2;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_parameters_to_context;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avcodec.avcodec_register_all;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avdevice.avdevice_register_all;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.AVSEEK_FLAG_BACKWARD;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.AVSEEK_SIZE;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.av_dump_format;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.av_find_input_format;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.av_guess_sample_aspect_ratio;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.av_read_frame;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.av_register_all;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.avformat_alloc_context;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.avformat_close_input;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.avformat_find_stream_info;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.avformat_free_context;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.avformat_network_init;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.avformat_open_input;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.avformat_seek_file;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avformat.avio_alloc_context;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AVMEDIA_TYPE_AUDIO;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AVMEDIA_TYPE_VIDEO;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_DICT_IGNORE_SUFFIX;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_LOG_INFO;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_NOPTS_VALUE;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_PICTURE_TYPE_I;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_PIX_FMT_BGR24;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_PIX_FMT_GRAY8;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_PIX_FMT_NONE;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_DBL;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_DBLP;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_FLT;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_FLTP;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_NONE;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_S16;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_S16P;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_S32;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_S32P;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_U8;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_SAMPLE_FMT_U8P;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.AV_TIME_BASE;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_d2q;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_dict_free;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_dict_get;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_dict_set;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_frame_alloc;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_frame_free;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_frame_get_best_effort_timestamp;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_frame_unref;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_free;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_get_bytes_per_sample;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_get_default_channel_layout;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_get_pix_fmt_name;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_image_fill_arrays;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_image_fill_linesizes;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_image_get_buffer_size;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_log_get_level;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_malloc;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_sample_fmt_is_planar;
|
|
|
|
import static org.bytedeco.ffmpeg.global.avutil.av_samples_get_buffer_size;
|
|
|
|
import static org.bytedeco.ffmpeg.global.swresample.swr_alloc_set_opts;
|
|
|
|
import static org.bytedeco.ffmpeg.global.swresample.swr_convert;
|
|
|
|
import static org.bytedeco.ffmpeg.global.swresample.swr_free;
|
|
|
|
import static org.bytedeco.ffmpeg.global.swresample.swr_get_out_samples;
|
|
|
|
import static org.bytedeco.ffmpeg.global.swresample.swr_init;
|
|
|
|
import static org.bytedeco.ffmpeg.global.swscale.SWS_BILINEAR;
|
|
|
|
import static org.bytedeco.ffmpeg.global.swscale.sws_freeContext;
|
|
|
|
import static org.bytedeco.ffmpeg.global.swscale.sws_getCachedContext;
|
|
|
|
import static org.bytedeco.ffmpeg.global.swscale.sws_scale;
|
|
|
|
|
|
|
|
import java.io.BufferedInputStream;
|
|
|
|
import java.io.File;
|
|
|
|
import java.io.IOException;
|
|
|
|
import java.io.InputStream;
|
|
|
|
import java.nio.Buffer;
|
|
|
|
import java.nio.ByteBuffer;
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.EnumSet;
|
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.Map;
|
|
|
|
import java.util.Map.Entry;
|
|
|
|
|
|
|
|
import org.bytedeco.ffmpeg.avcodec.AVCodec;
|
|
|
|
import org.bytedeco.ffmpeg.avcodec.AVCodecContext;
|
|
|
|
import org.bytedeco.ffmpeg.avcodec.AVCodecParameters;
|
|
|
|
import org.bytedeco.ffmpeg.avcodec.AVPacket;
|
|
|
|
import org.bytedeco.ffmpeg.avformat.AVFormatContext;
|
|
|
|
import org.bytedeco.ffmpeg.avformat.AVIOContext;
|
|
|
|
import org.bytedeco.ffmpeg.avformat.AVInputFormat;
|
|
|
|
import org.bytedeco.ffmpeg.avformat.AVStream;
|
|
|
|
import org.bytedeco.ffmpeg.avformat.Read_packet_Pointer_BytePointer_int;
|
|
|
|
import org.bytedeco.ffmpeg.avformat.Seek_Pointer_long_int;
|
|
|
|
import org.bytedeco.ffmpeg.avutil.AVDictionary;
|
|
|
|
import org.bytedeco.ffmpeg.avutil.AVDictionaryEntry;
|
|
|
|
import org.bytedeco.ffmpeg.avutil.AVFrame;
|
|
|
|
import org.bytedeco.ffmpeg.avutil.AVRational;
|
|
|
|
import org.bytedeco.ffmpeg.swresample.SwrContext;
|
|
|
|
import org.bytedeco.ffmpeg.swscale.SwsContext;
|
|
|
|
import org.bytedeco.javacpp.BytePointer;
|
|
|
|
import org.bytedeco.javacpp.DoublePointer;
|
|
|
|
import org.bytedeco.javacpp.IntPointer;
|
|
|
|
import org.bytedeco.javacpp.Loader;
|
|
|
|
import org.bytedeco.javacpp.Pointer;
|
|
|
|
import org.bytedeco.javacpp.PointerPointer;
|
|
|
|
import org.bytedeco.javacpp.PointerScope;
|
|
|
|
|
|
|
|
public class FFmpegFrameGrabber extends FrameGrabber {
|
|
|
|
|
|
|
|
public static String[] getDeviceDescriptions() throws Exception {
|
|
|
|
tryLoad();
|
|
|
|
throw new UnsupportedOperationException("Device enumeration not support by FFmpeg.");
|
|
|
|
}
|
|
|
|
|
|
|
|
public static FFmpegFrameGrabber createDefault(File deviceFile) throws Exception {
|
|
|
|
return new FFmpegFrameGrabber(deviceFile);
|
|
|
|
}
|
|
|
|
|
|
|
|
public static FFmpegFrameGrabber createDefault(String devicePath) throws Exception {
|
|
|
|
return new FFmpegFrameGrabber(devicePath);
|
|
|
|
}
|
|
|
|
|
|
|
|
public static FFmpegFrameGrabber createDefault(int deviceNumber) throws Exception {
|
|
|
|
throw new Exception(FFmpegFrameGrabber.class + " does not support device numbers.");
|
|
|
|
}
|
|
|
|
|
|
|
|
private static Exception loadingException = null;
|
|
|
|
|
|
|
|
public static void tryLoad() throws Exception {
|
|
|
|
if (loadingException != null) {
|
|
|
|
throw loadingException;
|
|
|
|
} else {
|
|
|
|
try {
|
|
|
|
Loader.load(org.bytedeco.ffmpeg.global.avutil.class);
|
|
|
|
Loader.load(org.bytedeco.ffmpeg.global.swresample.class);
|
|
|
|
Loader.load(org.bytedeco.ffmpeg.global.avcodec.class);
|
|
|
|
Loader.load(org.bytedeco.ffmpeg.global.avformat.class);
|
|
|
|
Loader.load(org.bytedeco.ffmpeg.global.swscale.class);
|
|
|
|
|
|
|
|
// Register all formats and codecs
|
|
|
|
av_jni_set_java_vm(Loader.getJavaVM(), null);
|
|
|
|
avcodec_register_all();
|
|
|
|
av_register_all();
|
|
|
|
avformat_network_init();
|
|
|
|
|
|
|
|
Loader.load(org.bytedeco.ffmpeg.global.avdevice.class);
|
|
|
|
avdevice_register_all();
|
|
|
|
} catch (Throwable t) {
|
|
|
|
if (t instanceof Exception) {
|
|
|
|
throw loadingException = (Exception) t;
|
|
|
|
} else {
|
|
|
|
throw loadingException = new Exception("Failed to load " + FFmpegFrameGrabber.class, t);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static {
|
|
|
|
try {
|
|
|
|
tryLoad();
|
|
|
|
FFmpegLockCallback.init();
|
|
|
|
} catch (Exception ex) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public FFmpegFrameGrabber(File file) {
|
|
|
|
this(file.getAbsolutePath());
|
|
|
|
}
|
|
|
|
|
|
|
|
public FFmpegFrameGrabber(String filename) {
|
|
|
|
this.filename = filename;
|
|
|
|
this.pixelFormat = AV_PIX_FMT_NONE;
|
|
|
|
this.sampleFormat = AV_SAMPLE_FMT_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Calls {@code FFmpegFrameGrabber(inputStream, Integer.MAX_VALUE - 8)} so that
|
|
|
|
* the whole input stream is seekable.
|
|
|
|
*/
|
|
|
|
public FFmpegFrameGrabber(InputStream inputStream) {
|
|
|
|
this(inputStream, Integer.MAX_VALUE - 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
public FFmpegFrameGrabber(InputStream inputStream, int maximumSize) {
|
|
|
|
this.inputStream = inputStream;
|
|
|
|
this.closeInputStream = true;
|
|
|
|
this.pixelFormat = AV_PIX_FMT_NONE;
|
|
|
|
this.sampleFormat = AV_SAMPLE_FMT_NONE;
|
|
|
|
this.maximumSize = maximumSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void release() throws Exception {
|
|
|
|
synchronized (org.bytedeco.ffmpeg.global.avcodec.class) {
|
|
|
|
releaseUnsafe();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void releaseUnsafe() throws Exception {
|
|
|
|
if (pkt != null && pkt2 != null) {
|
|
|
|
if (pkt2.size() > 0) {
|
|
|
|
av_packet_unref(pkt);
|
|
|
|
}
|
|
|
|
pkt = pkt2 = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Free the RGB image
|
|
|
|
if (image_ptr != null) {
|
|
|
|
for (int i = 0; i < image_ptr.length; i++) {
|
|
|
|
av_free(image_ptr[i]);
|
|
|
|
}
|
|
|
|
image_ptr = null;
|
|
|
|
}
|
|
|
|
if (picture_rgb != null) {
|
|
|
|
av_frame_free(picture_rgb);
|
|
|
|
picture_rgb = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Free the native format picture frame
|
|
|
|
if (picture != null) {
|
|
|
|
av_frame_free(picture);
|
|
|
|
picture = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close the video codec
|
|
|
|
if (video_c != null) {
|
|
|
|
avcodec_free_context(video_c);
|
|
|
|
video_c = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Free the audio samples frame
|
|
|
|
if (samples_frame != null) {
|
|
|
|
av_frame_free(samples_frame);
|
|
|
|
samples_frame = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close the audio codec
|
|
|
|
if (audio_c != null) {
|
|
|
|
avcodec_free_context(audio_c);
|
|
|
|
audio_c = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close the video file
|
|
|
|
if (inputStream == null && oc != null && !oc.isNull()) {
|
|
|
|
avformat_close_input(oc);
|
|
|
|
oc = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (img_convert_ctx != null) {
|
|
|
|
sws_freeContext(img_convert_ctx);
|
|
|
|
img_convert_ctx = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (samples_ptr_out != null) {
|
|
|
|
for (int i = 0; i < samples_ptr_out.length; i++) {
|
|
|
|
av_free(samples_ptr_out[i].position(0));
|
|
|
|
}
|
|
|
|
samples_ptr_out = null;
|
|
|
|
samples_buf_out = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (samples_convert_ctx != null) {
|
|
|
|
swr_free(samples_convert_ctx);
|
|
|
|
samples_convert_ctx = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
got_frame = null;
|
|
|
|
frameGrabbed = false;
|
|
|
|
frame = null;
|
|
|
|
timestamp = 0;
|
|
|
|
frameNumber = 0;
|
|
|
|
|
|
|
|
if (inputStream != null) {
|
|
|
|
try {
|
|
|
|
if (oc == null) {
|
|
|
|
// when called a second time
|
|
|
|
if (closeInputStream) {
|
|
|
|
inputStream.close();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
inputStream.reset();
|
|
|
|
}
|
|
|
|
} catch (IOException ex) {
|
|
|
|
throw new Exception("Error on InputStream.close(): ", ex);
|
|
|
|
} finally {
|
|
|
|
inputStreams.remove(oc);
|
|
|
|
if (avio != null) {
|
|
|
|
if (avio.buffer() != null) {
|
|
|
|
av_free(avio.buffer());
|
|
|
|
avio.buffer(null);
|
|
|
|
}
|
|
|
|
av_free(avio);
|
|
|
|
avio = null;
|
|
|
|
}
|
|
|
|
if (oc != null) {
|
|
|
|
avformat_free_context(oc);
|
|
|
|
oc = null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected void finalize() throws Throwable {
|
|
|
|
super.finalize();
|
|
|
|
release();
|
|
|
|
}
|
|
|
|
|
|
|
|
static Map<Pointer, InputStream> inputStreams = Collections.synchronizedMap(new HashMap<Pointer, InputStream>());
|
|
|
|
|
|
|
|
static class ReadCallback extends Read_packet_Pointer_BytePointer_int {
|
|
|
|
@Override
|
|
|
|
public int call(Pointer opaque, BytePointer buf, int buf_size) {
|
|
|
|
try {
|
|
|
|
byte[] b = new byte[buf_size];
|
|
|
|
InputStream is = inputStreams.get(opaque);
|
|
|
|
int size = is.read(b, 0, buf_size);
|
|
|
|
if (size < 0) {
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
buf.put(b, 0, size);
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
} catch (Throwable t) {
|
|
|
|
System.err.println("Error on InputStream.read(): " + t);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static class SeekCallback extends Seek_Pointer_long_int {
|
|
|
|
@Override
|
|
|
|
public long call(Pointer opaque, long offset, int whence) {
|
|
|
|
try {
|
|
|
|
InputStream is = inputStreams.get(opaque);
|
|
|
|
long size = 0;
|
|
|
|
switch (whence) {
|
|
|
|
case 0:
|
|
|
|
is.reset();
|
|
|
|
break; // SEEK_SET
|
|
|
|
case 1:
|
|
|
|
break; // SEEK_CUR
|
|
|
|
case 2: // SEEK_END
|
|
|
|
is.reset();
|
|
|
|
while (true) {
|
|
|
|
long n = is.skip(Long.MAX_VALUE);
|
|
|
|
if (n == 0)
|
|
|
|
break;
|
|
|
|
size += n;
|
|
|
|
}
|
|
|
|
offset += size;
|
|
|
|
is.reset();
|
|
|
|
break;
|
|
|
|
case AVSEEK_SIZE:
|
|
|
|
long remaining = 0;
|
|
|
|
while (true) {
|
|
|
|
long n = is.skip(Long.MAX_VALUE);
|
|
|
|
if (n == 0)
|
|
|
|
break;
|
|
|
|
remaining += n;
|
|
|
|
}
|
|
|
|
is.reset();
|
|
|
|
while (true) {
|
|
|
|
long n = is.skip(Long.MAX_VALUE);
|
|
|
|
if (n == 0)
|
|
|
|
break;
|
|
|
|
size += n;
|
|
|
|
}
|
|
|
|
offset = size - remaining;
|
|
|
|
is.reset();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
long remaining = offset;
|
|
|
|
while (remaining > 0) {
|
|
|
|
long skipped = is.skip(remaining);
|
|
|
|
if (skipped == 0)
|
|
|
|
break; // end of the stream
|
|
|
|
remaining -= skipped;
|
|
|
|
}
|
|
|
|
return whence == AVSEEK_SIZE ? size : 0;
|
|
|
|
} catch (Throwable t) {
|
|
|
|
System.err.println("Error on InputStream.reset() or skip(): " + t);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static ReadCallback readCallback = new ReadCallback();
|
|
|
|
static SeekCallback seekCallback = new SeekCallback();
|
|
|
|
static {
|
|
|
|
PointerScope s = PointerScope.getInnerScope();
|
|
|
|
if (s != null) {
|
|
|
|
s.detach(readCallback);
|
|
|
|
s.detach(seekCallback);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private InputStream inputStream;
|
|
|
|
private boolean closeInputStream;
|
|
|
|
private int maximumSize;
|
|
|
|
private AVIOContext avio;
|
|
|
|
private String filename;
|
|
|
|
private AVFormatContext oc;
|
|
|
|
private AVStream video_st, audio_st;
|
|
|
|
private AVCodecContext video_c, audio_c;
|
|
|
|
private AVFrame picture, picture_rgb;
|
|
|
|
private BytePointer[] image_ptr;
|
|
|
|
private Buffer[] image_buf;
|
|
|
|
private AVFrame samples_frame;
|
|
|
|
private BytePointer[] samples_ptr;
|
|
|
|
private Buffer[] samples_buf;
|
|
|
|
private BytePointer[] samples_ptr_out;
|
|
|
|
private Buffer[] samples_buf_out;
|
|
|
|
private AVPacket pkt, pkt2;
|
|
|
|
private int sizeof_pkt;
|
|
|
|
private int[] got_frame;
|
|
|
|
private SwsContext img_convert_ctx;
|
|
|
|
private SwrContext samples_convert_ctx;
|
|
|
|
private int samples_channels, samples_format, samples_rate;
|
|
|
|
private boolean frameGrabbed;
|
|
|
|
private Frame frame;
|
|
|
|
|
|
|
|
public boolean isCloseInputStream() {
|
|
|
|
return closeInputStream;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setCloseInputStream(boolean closeInputStream) {
|
|
|
|
this.closeInputStream = closeInputStream;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Is there a video stream?
|
|
|
|
*
|
|
|
|
* @return {@code video_st!=null;}
|
|
|
|
*/
|
|
|
|
public boolean hasVideo() {
|
|
|
|
return video_st != null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Is there an audio stream?
|
|
|
|
*
|
|
|
|
* @return {@code audio_st!=null;}
|
|
|
|
*/
|
|
|
|
public boolean hasAudio() {
|
|
|
|
return audio_st != null;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public double getGamma() {
|
|
|
|
// default to a gamma of 2.2 for cheap Webcams, DV cameras, etc.
|
|
|
|
if (gamma == 0.0) {
|
|
|
|
return 2.2;
|
|
|
|
} else {
|
|
|
|
return gamma;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String getFormat() {
|
|
|
|
if (oc == null) {
|
|
|
|
return super.getFormat();
|
|
|
|
} else {
|
|
|
|
return oc.iformat().name().getString();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getImageWidth() {
|
|
|
|
return imageWidth > 0 || video_c == null ? super.getImageWidth() : video_c.width();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getImageHeight() {
|
|
|
|
return imageHeight > 0 || video_c == null ? super.getImageHeight() : video_c.height();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getAudioChannels() {
|
|
|
|
return audioChannels > 0 || audio_c == null ? super.getAudioChannels() : audio_c.channels();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getPixelFormat() {
|
|
|
|
if (imageMode == ImageMode.COLOR || imageMode == ImageMode.GRAY) {
|
|
|
|
if (pixelFormat == AV_PIX_FMT_NONE) {
|
|
|
|
return imageMode == ImageMode.COLOR ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_GRAY8;
|
|
|
|
} else {
|
|
|
|
return pixelFormat;
|
|
|
|
}
|
|
|
|
} else if (video_c != null) { // RAW
|
|
|
|
return video_c.pix_fmt();
|
|
|
|
} else {
|
|
|
|
return super.getPixelFormat();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getVideoCodec() {
|
|
|
|
return video_c == null ? super.getVideoCodec() : video_c.codec_id();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getVideoBitrate() {
|
|
|
|
return video_c == null ? super.getVideoBitrate() : (int) video_c.bit_rate();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public double getAspectRatio() {
|
|
|
|
if (video_st == null) {
|
|
|
|
return super.getAspectRatio();
|
|
|
|
} else {
|
|
|
|
AVRational r = av_guess_sample_aspect_ratio(oc, video_st, picture);
|
|
|
|
double a = (double) r.num() / r.den();
|
|
|
|
return a == 0.0 ? 1.0 : a;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Returns {@link #getVideoFrameRate()} */
|
|
|
|
@Override
|
|
|
|
public double getFrameRate() {
|
|
|
|
return getVideoFrameRate();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Estimation of audio frames per second
|
|
|
|
*
|
|
|
|
* @return (double) getSampleRate()) / samples_frame.nb_samples() if
|
|
|
|
* samples_frame.nb_samples() is not zero, otherwise return 0
|
|
|
|
*/
|
|
|
|
public double getAudioFrameRate() {
|
|
|
|
if (audio_st == null) {
|
|
|
|
return 0.0;
|
|
|
|
} else {
|
|
|
|
if (samples_frame == null || samples_frame.nb_samples() == 0) {
|
|
|
|
try {
|
|
|
|
grabFrame(true, false, false, false);
|
|
|
|
frameGrabbed = true;
|
|
|
|
} catch (Exception e) {
|
|
|
|
return 0.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (samples_frame != null || samples_frame.nb_samples() != 0)
|
|
|
|
return ((double) getSampleRate()) / samples_frame.nb_samples();
|
|
|
|
else
|
|
|
|
return 0.0;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public double getVideoFrameRate() {
|
|
|
|
if (video_st == null) {
|
|
|
|
return super.getFrameRate();
|
|
|
|
} else {
|
|
|
|
AVRational r = video_st.avg_frame_rate();
|
|
|
|
if (r.num() == 0 && r.den() == 0) {
|
|
|
|
r = video_st.r_frame_rate();
|
|
|
|
}
|
|
|
|
return (double) r.num() / r.den();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getAudioCodec() {
|
|
|
|
return audio_c == null ? super.getAudioCodec() : audio_c.codec_id();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getAudioBitrate() {
|
|
|
|
return audio_c == null ? super.getAudioBitrate() : (int) audio_c.bit_rate();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getSampleFormat() {
|
|
|
|
if (sampleMode == SampleMode.SHORT || sampleMode == SampleMode.FLOAT) {
|
|
|
|
if (sampleFormat == AV_SAMPLE_FMT_NONE) {
|
|
|
|
return sampleMode == SampleMode.SHORT ? AV_SAMPLE_FMT_S16 : AV_SAMPLE_FMT_FLT;
|
|
|
|
} else {
|
|
|
|
return sampleFormat;
|
|
|
|
}
|
|
|
|
} else if (audio_c != null) { // RAW
|
|
|
|
return audio_c.sample_fmt();
|
|
|
|
} else {
|
|
|
|
return super.getSampleFormat();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public int getSampleRate() {
|
|
|
|
return sampleRate > 0 || audio_c == null ? super.getSampleRate() : audio_c.sample_rate();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Map<String, String> getMetadata() {
|
|
|
|
if (oc == null) {
|
|
|
|
return super.getMetadata();
|
|
|
|
}
|
|
|
|
AVDictionaryEntry entry = null;
|
|
|
|
Map<String, String> metadata = new HashMap<String, String>();
|
|
|
|
while ((entry = av_dict_get(oc.metadata(), "", entry, AV_DICT_IGNORE_SUFFIX)) != null) {
|
|
|
|
metadata.put(entry.key().getString(), entry.value().getString());
|
|
|
|
}
|
|
|
|
return metadata;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Map<String, String> getVideoMetadata() {
|
|
|
|
if (video_st == null) {
|
|
|
|
return super.getVideoMetadata();
|
|
|
|
}
|
|
|
|
AVDictionaryEntry entry = null;
|
|
|
|
Map<String, String> metadata = new HashMap<String, String>();
|
|
|
|
while ((entry = av_dict_get(video_st.metadata(), "", entry, AV_DICT_IGNORE_SUFFIX)) != null) {
|
|
|
|
metadata.put(entry.key().getString(), entry.value().getString());
|
|
|
|
}
|
|
|
|
return metadata;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Map<String, String> getAudioMetadata() {
|
|
|
|
if (audio_st == null) {
|
|
|
|
return super.getAudioMetadata();
|
|
|
|
}
|
|
|
|
AVDictionaryEntry entry = null;
|
|
|
|
Map<String, String> metadata = new HashMap<String, String>();
|
|
|
|
while ((entry = av_dict_get(audio_st.metadata(), "", entry, AV_DICT_IGNORE_SUFFIX)) != null) {
|
|
|
|
metadata.put(entry.key().getString(), entry.value().getString());
|
|
|
|
}
|
|
|
|
return metadata;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String getMetadata(String key) {
|
|
|
|
if (oc == null) {
|
|
|
|
return super.getMetadata(key);
|
|
|
|
}
|
|
|
|
AVDictionaryEntry entry = av_dict_get(oc.metadata(), key, null, 0);
|
|
|
|
return entry == null || entry.value() == null ? null : entry.value().getString();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String getVideoMetadata(String key) {
|
|
|
|
if (video_st == null) {
|
|
|
|
return super.getVideoMetadata(key);
|
|
|
|
}
|
|
|
|
AVDictionaryEntry entry = av_dict_get(video_st.metadata(), key, null, 0);
|
|
|
|
return entry == null || entry.value() == null ? null : entry.value().getString();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String getAudioMetadata(String key) {
|
|
|
|
if (audio_st == null) {
|
|
|
|
return super.getAudioMetadata(key);
|
|
|
|
}
|
|
|
|
AVDictionaryEntry entry = av_dict_get(audio_st.metadata(), key, null, 0);
|
|
|
|
return entry == null || entry.value() == null ? null : entry.value().getString();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* default override of super.setFrameNumber implies setting of a frame close to
|
|
|
|
* a video frame having that number
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void setFrameNumber(int frameNumber) throws Exception {
|
|
|
|
if (hasVideo())
|
|
|
|
setTimestamp(Math.round(1000000L * frameNumber / getFrameRate()));
|
|
|
|
else
|
|
|
|
super.frameNumber = frameNumber;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* if there is video stream tries to seek to video frame with corresponding
|
|
|
|
* timestamp otherwise sets super.frameNumber only because frameRate==0 if there
|
|
|
|
* is no video stream
|
|
|
|
*/
|
|
|
|
public void setVideoFrameNumber(int frameNumber) throws Exception {
|
|
|
|
// best guess, AVSEEK_FLAG_FRAME has not been implemented in FFmpeg...
|
|
|
|
if (hasVideo())
|
|
|
|
setVideoTimestamp(Math.round(1000000L * frameNumber / getFrameRate()));
|
|
|
|
else
|
|
|
|
super.frameNumber = frameNumber;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* if there is audio stream tries to seek to audio frame with corresponding
|
|
|
|
* timestamp ignoring otherwise
|
|
|
|
*/
|
|
|
|
public void setAudioFrameNumber(int frameNumber) throws Exception {
|
|
|
|
// best guess, AVSEEK_FLAG_FRAME has not been implemented in FFmpeg...
|
|
|
|
if (hasAudio())
|
|
|
|
setAudioTimestamp(Math.round(1000000L * frameNumber / getAudioFrameRate()));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* setTimestamp without checking frame content (using old code used in JavaCV
|
|
|
|
* versions prior to 1.4.1)
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void setTimestamp(long timestamp) throws Exception {
|
|
|
|
setTimestamp(timestamp, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* setTimestamp with possibility to select between old quick seek code or new
|
|
|
|
* code doing check of frame content. The frame check can be useful with
|
|
|
|
* corrupted files, when seeking may end up with an empty frame not containing
|
|
|
|
* video nor audio
|
|
|
|
*/
|
|
|
|
public void setTimestamp(long timestamp, boolean checkFrame) throws Exception {
|
|
|
|
setTimestamp(timestamp, checkFrame ? EnumSet.of(Frame.Type.VIDEO, Frame.Type.AUDIO) : null);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** setTimestamp with resulting video frame type if there is a video stream */
|
|
|
|
public void setVideoTimestamp(long timestamp) throws Exception {
|
|
|
|
setTimestamp(timestamp, EnumSet.of(Frame.Type.VIDEO));
|
|
|
|
}
|
|
|
|
|
|
|
|
/** setTimestamp with resulting audio frame type if there is an audio stream */
|
|
|
|
public void setAudioTimestamp(long timestamp) throws Exception {
|
|
|
|
setTimestamp(timestamp, EnumSet.of(Frame.Type.AUDIO));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* setTimestamp with a priority the resulting frame should be: video
|
|
|
|
* (frameTypesToSeek contains only Frame.Type.VIDEO), audio (frameTypesToSeek
|
|
|
|
* contains only Frame.Type.AUDIO), or any (frameTypesToSeek contains both)
|
|
|
|
*/
|
|
|
|
private void setTimestamp(long timestamp, EnumSet<Frame.Type> frameTypesToSeek) throws Exception {
|
|
|
|
int ret;
|
|
|
|
if (oc == null) {
|
|
|
|
super.setTimestamp(timestamp);
|
|
|
|
} else {
|
|
|
|
timestamp = timestamp * AV_TIME_BASE / 1000000L;
|
|
|
|
/* add the stream start time */
|
|
|
|
if (oc.start_time() != AV_NOPTS_VALUE) {
|
|
|
|
timestamp += oc.start_time();
|
|
|
|
}
|
|
|
|
if ((ret = avformat_seek_file(oc, -1, Long.MIN_VALUE, timestamp, Long.MAX_VALUE,
|
|
|
|
AVSEEK_FLAG_BACKWARD)) < 0) {
|
|
|
|
throw new Exception(
|
|
|
|
"avformat_seek_file() error " + ret + ": Could not seek file to timestamp " + timestamp + ".");
|
|
|
|
}
|
|
|
|
if (video_c != null) {
|
|
|
|
avcodec_flush_buffers(video_c);
|
|
|
|
}
|
|
|
|
if (audio_c != null) {
|
|
|
|
avcodec_flush_buffers(audio_c);
|
|
|
|
}
|
|
|
|
if (pkt2.size() > 0) {
|
|
|
|
pkt2.size(0);
|
|
|
|
av_packet_unref(pkt);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* After the call of ffmpeg's avformat_seek_file(...) with the flag set to
|
|
|
|
* AVSEEK_FLAG_BACKWARD the decoding position should be located before the
|
|
|
|
* requested timestamp in a closest position from which all the active streams
|
|
|
|
* can be decoded successfully. The following seeking consists of two stages: 1.
|
|
|
|
* Grab frames till the frame corresponding to that "closest" position (the
|
|
|
|
* first frame containing decoded data).
|
|
|
|
*
|
|
|
|
* 2. Grab frames till the desired timestamp is reached. The number of steps is
|
|
|
|
* restricted by doubled estimation of frames between that "closest" position
|
|
|
|
* and the desired position.
|
|
|
|
*
|
|
|
|
* frameTypesToSeek parameter sets the preferred type of frames to seek. It can
|
|
|
|
* be chosen from three possible types: VIDEO, AUDIO or any of them. The setting
|
|
|
|
* means only a preference in the type. That is, if VIDEO or AUDIO is specified
|
|
|
|
* but the file does not have video or audio stream - any type will be used
|
|
|
|
* instead.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* TODO Sometimes the ffmpeg's avformat_seek_file(...) function brings us not to
|
|
|
|
* a position before the desired but few frames after.... What can be a the
|
|
|
|
* solution in this case if we really need a frame-precision seek? Probably we
|
|
|
|
* may try to request even earlier timestamp and look if this will bring us
|
|
|
|
* before the desired position.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (frameTypesToSeek != null) { // new code providing check of frame content while seeking to the timestamp
|
|
|
|
boolean has_video = hasVideo();
|
|
|
|
boolean has_audio = hasAudio();
|
|
|
|
|
|
|
|
if (has_video || has_audio) {
|
|
|
|
if ((frameTypesToSeek.contains(Frame.Type.VIDEO) && !has_video)
|
|
|
|
|| (frameTypesToSeek.contains(Frame.Type.AUDIO) && !has_audio))
|
|
|
|
frameTypesToSeek = EnumSet.of(Frame.Type.VIDEO, Frame.Type.AUDIO);
|
|
|
|
|
|
|
|
long initialSeekPosition = Long.MIN_VALUE;
|
|
|
|
long maxSeekSteps = 0;
|
|
|
|
long count = 0;
|
|
|
|
Frame seekFrame = null;
|
|
|
|
|
|
|
|
while (count++ < 1000) { // seek to a first frame containing video or audio after
|
|
|
|
// avformat_seek_file(...)
|
|
|
|
seekFrame = grabFrame(true, true, false, false);
|
|
|
|
if (seekFrame == null)
|
|
|
|
return; // is it better to throw NullPointerException?
|
|
|
|
EnumSet<Frame.Type> frameTypes = seekFrame.getTypes();
|
|
|
|
frameTypes.retainAll(frameTypesToSeek);
|
|
|
|
if (!frameTypes.isEmpty()) {
|
|
|
|
initialSeekPosition = seekFrame.timestamp;
|
|
|
|
// the position closest to the requested timestamp from which it can be reached
|
|
|
|
// by sequential grabFrame calls
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (has_video && this.getFrameRate() > 0) {
|
|
|
|
// estimation of video frame duration
|
|
|
|
double deltaTimeStamp = 1000000.0 / this.getFrameRate();
|
|
|
|
if (initialSeekPosition < timestamp - deltaTimeStamp / 2)
|
|
|
|
maxSeekSteps = (long) (10 * (timestamp - initialSeekPosition) / deltaTimeStamp);
|
|
|
|
} else if (has_audio && this.getAudioFrameRate() > 0) {
|
|
|
|
// estimation of audio frame duration
|
|
|
|
double deltaTimeStamp = 1000000.0 / this.getAudioFrameRate();
|
|
|
|
if (initialSeekPosition < timestamp - deltaTimeStamp / 2)
|
|
|
|
maxSeekSteps = (long) (10 * (timestamp - initialSeekPosition) / deltaTimeStamp);
|
|
|
|
} else
|
|
|
|
// zero frameRate
|
|
|
|
if (initialSeekPosition < timestamp - 1L)
|
|
|
|
maxSeekSteps = 1000;
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
while (count < maxSeekSteps) {
|
|
|
|
seekFrame = grabFrame(true, true, false, false);
|
|
|
|
if (seekFrame == null)
|
|
|
|
return; // is it better to throw NullPointerException?
|
|
|
|
EnumSet<Frame.Type> frameTypes = seekFrame.getTypes();
|
|
|
|
frameTypes.retainAll(frameTypesToSeek);
|
|
|
|
if (!frameTypes.isEmpty()) {
|
|
|
|
count++;
|
|
|
|
if (this.timestamp >= timestamp - 1)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
frameGrabbed = true;
|
|
|
|
}
|
|
|
|
} else { // old quick seeking code used in JavaCV versions prior to 1.4.1
|
|
|
|
/*
|
|
|
|
* comparing to timestamp +/- 1 avoids rouding issues for framerates which are
|
|
|
|
* no proper divisors of 1000000, e.g. where av_frame_get_best_effort_timestamp
|
|
|
|
* in grabFrame sets this.timestamp to ...666 and the given timestamp has been
|
|
|
|
* rounded to ...667 (or vice versa)
|
|
|
|
*/
|
|
|
|
int count = 0; // prevent infinite loops with corrupted files
|
|
|
|
while (this.timestamp > timestamp + 1 && grabFrame(true, true, false, false) != null
|
|
|
|
&& count++ < 1000) {
|
|
|
|
// flush frames if seeking backwards
|
|
|
|
}
|
|
|
|
count = 0;
|
|
|
|
while (this.timestamp < timestamp - 1 && grabFrame(true, true, false, false) != null
|
|
|
|
&& count++ < 1000) {
|
|
|
|
// decode up to the desired frame
|
|
|
|
}
|
|
|
|
frameGrabbed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Returns {@link #getLengthInVideoFrames()} */
|
|
|
|
@Override
|
|
|
|
public int getLengthInFrames() {
|
|
|
|
// best guess...
|
|
|
|
return getLengthInVideoFrames();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public long getLengthInTime() {
|
|
|
|
return oc.duration() * 1000000L / AV_TIME_BASE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns
|
|
|
|
* {@code (int) Math.round(getLengthInTime() * getFrameRate() / 1000000L)},
|
|
|
|
* which is an approximation in general.
|
|
|
|
*/
|
|
|
|
public int getLengthInVideoFrames() {
|
|
|
|
// best guess...
|
|
|
|
return (int) Math.round(getLengthInTime() * getFrameRate() / 1000000L);
|
|
|
|
}
|
|
|
|
|
|
|
|
public int getLengthInAudioFrames() {
|
|
|
|
// best guess...
|
|
|
|
double afr = getAudioFrameRate();
|
|
|
|
if (afr > 0)
|
|
|
|
return (int) (getLengthInTime() * afr / 1000000L);
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
public AVFormatContext getFormatContext() {
|
|
|
|
return oc;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void start(String streamCode) throws Exception {
|
|
|
|
synchronized (org.bytedeco.ffmpeg.global.avcodec.class) {
|
|
|
|
startUnsafe(streamCode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void startUnsafe(String streamCode) throws Exception {
|
|
|
|
if (oc != null && !oc.isNull()) {
|
|
|
|
throw new Exception("start() has already been called: Call stop() before calling start() again.");
|
|
|
|
}
|
|
|
|
|
|
|
|
int ret;
|
|
|
|
img_convert_ctx = null;
|
|
|
|
oc = new AVFormatContext(null);
|
|
|
|
video_c = null;
|
|
|
|
audio_c = null;
|
|
|
|
pkt = new AVPacket();
|
|
|
|
pkt2 = new AVPacket();
|
|
|
|
sizeof_pkt = pkt.sizeof();
|
|
|
|
got_frame = new int[1];
|
|
|
|
frameGrabbed = false;
|
|
|
|
frame = new Frame();
|
|
|
|
timestamp = 0;
|
|
|
|
frameNumber = 0;
|
|
|
|
|
|
|
|
pkt2.size(0);
|
|
|
|
|
|
|
|
// Open video file
|
|
|
|
AVInputFormat f = null;
|
|
|
|
if (format != null && format.length() > 0) {
|
|
|
|
if ((f = av_find_input_format(format)) == null) {
|
|
|
|
throw new Exception("av_find_input_format() error: Could not find input format \"" + format + "\".");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
AVDictionary options = new AVDictionary(null);
|
|
|
|
if (frameRate > 0) {
|
|
|
|
AVRational r = av_d2q(frameRate, 1001000);
|
|
|
|
av_dict_set(options, "framerate", r.num() + "/" + r.den(), 0);
|
|
|
|
}
|
|
|
|
if (pixelFormat >= 0) {
|
|
|
|
av_dict_set(options, "pixel_format", av_get_pix_fmt_name(pixelFormat).getString(), 0);
|
|
|
|
} else if (imageMode != ImageMode.RAW) {
|
|
|
|
av_dict_set(options, "pixel_format", imageMode == ImageMode.COLOR ? "bgr24" : "gray8", 0);
|
|
|
|
}
|
|
|
|
if (imageWidth > 0 && imageHeight > 0) {
|
|
|
|
av_dict_set(options, "video_size", imageWidth + "x" + imageHeight, 0);
|
|
|
|
}
|
|
|
|
if (sampleRate > 0) {
|
|
|
|
av_dict_set(options, "sample_rate", "" + sampleRate, 0);
|
|
|
|
}
|
|
|
|
if (audioChannels > 0) {
|
|
|
|
av_dict_set(options, "channels", "" + audioChannels, 0);
|
|
|
|
}
|
|
|
|
for (Entry<String, String> e : this.options.entrySet()) {
|
|
|
|
av_dict_set(options, e.getKey(), e.getValue(), 0);
|
|
|
|
}
|
|
|
|
if (inputStream != null) {
|
|
|
|
if (!inputStream.markSupported()) {
|
|
|
|
inputStream = new BufferedInputStream(inputStream);
|
|
|
|
}
|
|
|
|
inputStream.mark(maximumSize);
|
|
|
|
oc = avformat_alloc_context();
|
|
|
|
avio = avio_alloc_context(new BytePointer(av_malloc(4096)), 4096, 0, oc, readCallback, null, seekCallback);
|
|
|
|
oc.pb(avio);
|
|
|
|
|
|
|
|
filename = inputStream.toString();
|
|
|
|
inputStreams.put(oc, inputStream);
|
|
|
|
}
|
|
|
|
if ((ret = avformat_open_input(oc, filename, f, options)) < 0) {
|
|
|
|
av_dict_set(options, "pixel_format", null, 0);
|
|
|
|
if ((ret = avformat_open_input(oc, filename, f, options)) < 0) {
|
|
|
|
throw new Exception("avformat_open_input() error " + ret + ": Could not open input \"" + filename
|
|
|
|
+ "\". (Has setFormat() been called?)");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
av_dict_free(options);
|
|
|
|
|
|
|
|
oc.max_delay(maxDelay);
|
|
|
|
// Retrieve stream information
|
|
|
|
// 限制avformat_find_stream_info接口内部读取的最大数据量
|
|
|
|
oc.probesize(Integer.parseInt(streamCode));
|
|
|
|
// 设置avformat_find_stream_info这个函数的持续时长，超过这个时间不结束也会结束
|
|
|
|
oc.max_analyze_duration(5 * AV_TIME_BASE);
|
|
|
|
// 将avformat_find_stream_info内部读取的数据包不放入AVFormatContext的缓冲区packet_buffer中
|
|
|
|
// oc.flags(AVFormatContext.AVFMT_FLAG_NOBUFFER);
|
|
|
|
|
|
|
|
AVDictionary optionOut = new AVDictionary(null);
|
|
|
|
if ((ret = avformat_find_stream_info(oc, (PointerPointer) null)) < 0) {
|
|
|
|
throw new Exception("avformat_find_stream_info() error " + ret + ": Could not find stream information.");
|
|
|
|
}
|
|
|
|
if (av_log_get_level() >= AV_LOG_INFO) {
|
|
|
|
// Dump information about file onto standard error
|
|
|
|
av_dump_format(oc, 0, filename, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find the first video and audio stream, unless the user specified otherwise
|
|
|
|
video_st = audio_st = null;
|
|
|
|
AVCodecParameters video_par = null, audio_par = null;
|
|
|
|
int nb_streams = oc.nb_streams();
|
|
|
|
for (int i = 0; i < nb_streams; i++) {
|
|
|
|
AVStream st = oc.streams(i);
|
|
|
|
// Get a pointer to the codec context for the video or audio stream
|
|
|
|
AVCodecParameters par = st.codecpar();
|
|
|
|
if (video_st == null && par.codec_type() == AVMEDIA_TYPE_VIDEO && (videoStream < 0 || videoStream == i)) {
|
|
|
|
video_st = st;
|
|
|
|
video_par = par;
|
|
|
|
videoStream = i;
|
|
|
|
} else if (audio_st == null && par.codec_type() == AVMEDIA_TYPE_AUDIO
|
|
|
|
&& (audioStream < 0 || audioStream == i)) {
|
|
|
|
audio_st = st;
|
|
|
|
audio_par = par;
|
|
|
|
audioStream = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (video_st == null && audio_st == null) {
|
|
|
|
throw new Exception("Did not find a video or audio stream inside \"" + filename + "\" for videoStream == "
|
|
|
|
+ videoStream + " and audioStream == " + audioStream + ".");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (video_st != null) {
|
|
|
|
// Find the decoder for the video stream
|
|
|
|
AVCodec codec = avcodec_find_decoder_by_name(videoCodecName);
|
|
|
|
if (codec == null) {
|
|
|
|
codec = avcodec_find_decoder(video_par.codec_id());
|
|
|
|
}
|
|
|
|
if (codec == null) {
|
|
|
|
throw new Exception("avcodec_find_decoder() error: Unsupported video format or codec not found: "
|
|
|
|
+ video_par.codec_id() + ".");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a codec context for the decoder */
|
|
|
|
if ((video_c = avcodec_alloc_context3(codec)) == null) {
|
|
|
|
throw new Exception("avcodec_alloc_context3() error: Could not allocate video decoding context.");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* copy the stream parameters from the muxer */
|
|
|
|
if ((ret = avcodec_parameters_to_context(video_c, video_st.codecpar())) < 0) {
|
|
|
|
releaseUnsafe();
|
|
|
|
throw new Exception(
|
|
|
|
"avcodec_parameters_to_context() error: Could not copy the video stream parameters.");
|
|
|
|
}
|
|
|
|
|
|
|
|
options = new AVDictionary(null);
|
|
|
|
for (Entry<String, String> e : videoOptions.entrySet()) {
|
|
|
|
av_dict_set(options, e.getKey(), e.getValue(), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Enable multithreading when available
|
|
|
|
video_c.thread_count(0);
|
|
|
|
|
|
|
|
// Open video codec
|
|
|
|
if ((ret = avcodec_open2(video_c, codec, options)) < 0) {
|
|
|
|
throw new Exception("avcodec_open2() error " + ret + ": Could not open video codec.");
|
|
|
|
}
|
|
|
|
av_dict_free(options);
|
|
|
|
|
|
|
|
// Hack to correct wrong frame rates that seem to be generated by some codecs
|
|
|
|
if (video_c.time_base().num() > 1000 && video_c.time_base().den() == 1) {
|
|
|
|
video_c.time_base().den(1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Allocate video frame and an AVFrame structure for the RGB image
|
|
|
|
if ((picture = av_frame_alloc()) == null) {
|
|
|
|
throw new Exception("av_frame_alloc() error: Could not allocate raw picture frame.");
|
|
|
|
}
|
|
|
|
if ((picture_rgb = av_frame_alloc()) == null) {
|
|
|
|
throw new Exception("av_frame_alloc() error: Could not allocate RGB picture frame.");
|
|
|
|
}
|
|
|
|
|
|
|
|
initPictureRGB();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (audio_st != null) {
|
|
|
|
// Find the decoder for the audio stream
|
|
|
|
AVCodec codec = avcodec_find_decoder_by_name(audioCodecName);
|
|
|
|
if (codec == null) {
|
|
|
|
codec = avcodec_find_decoder(audio_par.codec_id());
|
|
|
|
}
|
|
|
|
if (codec == null) {
|
|
|
|
// throw new Exception("avcodec_find_decoder() error: Unsupported audio format or codec not found: "
|
|
|
|
// + audio_par.codec_id() + ".");
|
|
|
|
} else {
|
|
|
|
/* Allocate a codec context for the decoder */
|
|
|
|
if ((audio_c = avcodec_alloc_context3(codec)) == null) {
|
|
|
|
throw new Exception("avcodec_alloc_context3() error: Could not allocate audio decoding context.");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* copy the stream parameters from the muxer */
|
|
|
|
if ((ret = avcodec_parameters_to_context(audio_c, audio_st.codecpar())) < 0) {
|
|
|
|
releaseUnsafe();
|
|
|
|
throw new Exception(
|
|
|
|
"avcodec_parameters_to_context() error: Could not copy the audio stream parameters.");
|
|
|
|
}
|
|
|
|
|
|
|
|
options = new AVDictionary(null);
|
|
|
|
for (Entry<String, String> e : audioOptions.entrySet()) {
|
|
|
|
av_dict_set(options, e.getKey(), e.getValue(), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Enable multithreading when available
|
|
|
|
audio_c.thread_count(0);
|
|
|
|
|
|
|
|
// Open audio codec
|
|
|
|
if ((ret = avcodec_open2(audio_c, codec, options)) < 0) {
|
|
|
|
throw new Exception("avcodec_open2() error " + ret + ": Could not open audio codec.");
|
|
|
|
}
|
|
|
|
av_dict_free(options);
|
|
|
|
|
|
|
|
// Allocate audio samples frame
|
|
|
|
if ((samples_frame = av_frame_alloc()) == null) {
|
|
|
|
throw new Exception("av_frame_alloc() error: Could not allocate audio frame.");
|
|
|
|
}
|
|
|
|
samples_ptr = new BytePointer[] { null };
|
|
|
|
samples_buf = new Buffer[] { null };
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void initPictureRGB() {
|
|
|
|
int width = imageWidth > 0 ? imageWidth : video_c.width();
|
|
|
|
int height = imageHeight > 0 ? imageHeight : video_c.height();
|
|
|
|
|
|
|
|
switch (imageMode) {
|
|
|
|
case COLOR:
|
|
|
|
case GRAY:
|
|
|
|
// If size changes I new allocation is needed -> free the old one.
|
|
|
|
if (image_ptr != null) {
|
|
|
|
// First kill all references, then free it.
|
|
|
|
image_buf = null;
|
|
|
|
BytePointer[] temp = image_ptr;
|
|
|
|
image_ptr = null;
|
|
|
|
av_free(temp[0]);
|
|
|
|
}
|
|
|
|
int fmt = getPixelFormat();
|
|
|
|
|
|
|
|
// work around bug in swscale: https://trac.ffmpeg.org/ticket/1031
|
|
|
|
int align = 32;
|
|
|
|
int stride = width;
|
|
|
|
for (int i = 1; i <= align; i += i) {
|
|
|
|
stride = (width + (i - 1)) & ~(i - 1);
|
|
|
|
av_image_fill_linesizes(picture_rgb.linesize(), fmt, stride);
|
|
|
|
if ((picture_rgb.linesize(0) & (align - 1)) == 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Determine required buffer size and allocate buffer
|
|
|
|
int size = av_image_get_buffer_size(fmt, stride, height, 1);
|
|
|
|
image_ptr = new BytePointer[] { new BytePointer(av_malloc(size)).capacity(size) };
|
|
|
|
image_buf = new Buffer[] { image_ptr[0].asBuffer() };
|
|
|
|
|
|
|
|
// Assign appropriate parts of buffer to image planes in picture_rgb
|
|
|
|
// Note that picture_rgb is an AVFrame, but AVFrame is a superset of AVPicture
|
|
|
|
av_image_fill_arrays(new PointerPointer(picture_rgb), picture_rgb.linesize(), image_ptr[0], fmt, stride,
|
|
|
|
height, 1);
|
|
|
|
picture_rgb.format(fmt);
|
|
|
|
picture_rgb.width(width);
|
|
|
|
picture_rgb.height(height);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RAW:
|
|
|
|
image_ptr = new BytePointer[] { null };
|
|
|
|
image_buf = new Buffer[] { null };
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void stop() throws Exception {
|
|
|
|
release();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void trigger() throws Exception {
|
|
|
|
if (oc == null || oc.isNull()) {
|
|
|
|
throw new Exception("Could not trigger: No AVFormatContext. (Has start() been called?)");
|
|
|
|
}
|
|
|
|
if (pkt2.size() > 0) {
|
|
|
|
pkt2.size(0);
|
|
|
|
av_packet_unref(pkt);
|
|
|
|
}
|
|
|
|
for (int i = 0; i < numBuffers + 1; i++) {
|
|
|
|
if (av_read_frame(oc, pkt) < 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
av_packet_unref(pkt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void processImage() throws Exception {
|
|
|
|
frame.imageWidth = imageWidth > 0 ? imageWidth : video_c.width();
|
|
|
|
frame.imageHeight = imageHeight > 0 ? imageHeight : video_c.height();
|
|
|
|
frame.imageDepth = Frame.DEPTH_UBYTE;
|
|
|
|
switch (imageMode) {
|
|
|
|
case COLOR:
|
|
|
|
case GRAY:
|
|
|
|
// Deinterlace Picture
|
|
|
|
if (deinterlace) {
|
|
|
|
throw new Exception("Cannot deinterlace: Functionality moved to FFmpegFrameFilter.");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Has the size changed?
|
|
|
|
if (frame.imageWidth != picture_rgb.width() || frame.imageHeight != picture_rgb.height()) {
|
|
|
|
initPictureRGB();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert the image into BGR or GRAY format that OpenCV uses
|
|
|
|
img_convert_ctx = sws_getCachedContext(img_convert_ctx, video_c.width(), video_c.height(),
|
|
|
|
video_c.pix_fmt(), frame.imageWidth, frame.imageHeight, getPixelFormat(),
|
|
|
|
imageScalingFlags != 0 ? imageScalingFlags : SWS_BILINEAR, null, null, (DoublePointer) null);
|
|
|
|
if (img_convert_ctx == null) {
|
|
|
|
throw new Exception("sws_getCachedContext() error: Cannot initialize the conversion context.");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert the image from its native format to RGB or GRAY
|
|
|
|
sws_scale(img_convert_ctx, new PointerPointer(picture), picture.linesize(), 0, video_c.height(),
|
|
|
|
new PointerPointer(picture_rgb), picture_rgb.linesize());
|
|
|
|
frame.imageStride = picture_rgb.linesize(0);
|
|
|
|
frame.image = image_buf;
|
|
|
|
frame.opaque = picture_rgb;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RAW:
|
|
|
|
frame.imageStride = picture.linesize(0);
|
|
|
|
BytePointer ptr = picture.data(0);
|
|
|
|
if (ptr != null && !ptr.equals(image_ptr[0])) {
|
|
|
|
image_ptr[0] = ptr.capacity(frame.imageHeight * frame.imageStride);
|
|
|
|
image_buf[0] = ptr.asBuffer();
|
|
|
|
}
|
|
|
|
frame.image = image_buf;
|
|
|
|
frame.opaque = picture;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert false;
|
|
|
|
}
|
|
|
|
frame.image[0].limit(frame.imageHeight * frame.imageStride);
|
|
|
|
frame.imageChannels = frame.imageStride / frame.imageWidth;
|
|
|
|
}
|
|
|
|
|
|
|
|
private void processSamples() throws Exception {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
int sample_format = samples_frame.format();
|
|
|
|
int planes = av_sample_fmt_is_planar(sample_format) != 0 ? (int) samples_frame.channels() : 1;
|
|
|
|
int data_size = av_samples_get_buffer_size((IntPointer) null, audio_c.channels(), samples_frame.nb_samples(),
|
|
|
|
audio_c.sample_fmt(), 1) / planes;
|
|
|
|
if (samples_buf == null || samples_buf.length != planes) {
|
|
|
|
samples_ptr = new BytePointer[planes];
|
|
|
|
samples_buf = new Buffer[planes];
|
|
|
|
}
|
|
|
|
frame.sampleRate = audio_c.sample_rate();
|
|
|
|
frame.audioChannels = audio_c.channels();
|
|
|
|
frame.samples = samples_buf;
|
|
|
|
frame.opaque = samples_frame;
|
|
|
|
int sample_size = data_size / av_get_bytes_per_sample(sample_format);
|
|
|
|
for (int i = 0; i < planes; i++) {
|
|
|
|
BytePointer p = samples_frame.data(i);
|
|
|
|
if (!p.equals(samples_ptr[i]) || samples_ptr[i].capacity() < data_size) {
|
|
|
|
samples_ptr[i] = p.capacity(data_size);
|
|
|
|
ByteBuffer b = p.asBuffer();
|
|
|
|
switch (sample_format) {
|
|
|
|
case AV_SAMPLE_FMT_U8:
|
|
|
|
case AV_SAMPLE_FMT_U8P:
|
|
|
|
samples_buf[i] = b;
|
|
|
|
break;
|
|
|
|
case AV_SAMPLE_FMT_S16:
|
|
|
|
case AV_SAMPLE_FMT_S16P:
|
|
|
|
samples_buf[i] = b.asShortBuffer();
|
|
|
|
break;
|
|
|
|
case AV_SAMPLE_FMT_S32:
|
|
|
|
case AV_SAMPLE_FMT_S32P:
|
|
|
|
samples_buf[i] = b.asIntBuffer();
|
|
|
|
break;
|
|
|
|
case AV_SAMPLE_FMT_FLT:
|
|
|
|
case AV_SAMPLE_FMT_FLTP:
|
|
|
|
samples_buf[i] = b.asFloatBuffer();
|
|
|
|
break;
|
|
|
|
case AV_SAMPLE_FMT_DBL:
|
|
|
|
case AV_SAMPLE_FMT_DBLP:
|
|
|
|
samples_buf[i] = b.asDoubleBuffer();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
samples_buf[i].position(0).limit(sample_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (audio_c.channels() != getAudioChannels() || audio_c.sample_fmt() != getSampleFormat()
|
|
|
|
|| audio_c.sample_rate() != getSampleRate()) {
|
|
|
|
if (samples_convert_ctx == null || samples_channels != getAudioChannels()
|
|
|
|
|| samples_format != getSampleFormat() || samples_rate != getSampleRate()) {
|
|
|
|
samples_convert_ctx = swr_alloc_set_opts(samples_convert_ctx,
|
|
|
|
av_get_default_channel_layout(getAudioChannels()), getSampleFormat(), getSampleRate(),
|
|
|
|
av_get_default_channel_layout(audio_c.channels()), audio_c.sample_fmt(), audio_c.sample_rate(),
|
|
|
|
0, null);
|
|
|
|
if (samples_convert_ctx == null) {
|
|
|
|
throw new Exception("swr_alloc_set_opts() error: Cannot allocate the conversion context.");
|
|
|
|
} else if ((ret = swr_init(samples_convert_ctx)) < 0) {
|
|
|
|
throw new Exception("swr_init() error " + ret + ": Cannot initialize the conversion context.");
|
|
|
|
}
|
|
|
|
samples_channels = getAudioChannels();
|
|
|
|
samples_format = getSampleFormat();
|
|
|
|
samples_rate = getSampleRate();
|
|
|
|
}
|
|
|
|
|
|
|
|
int sample_size_in = samples_frame.nb_samples();
|
|
|
|
int planes_out = av_sample_fmt_is_planar(samples_format) != 0 ? (int) samples_frame.channels() : 1;
|
|
|
|
int sample_size_out = swr_get_out_samples(samples_convert_ctx, sample_size_in);
|
|
|
|
int sample_bytes_out = av_get_bytes_per_sample(samples_format);
|
|
|
|
int buffer_size_out = sample_size_out * sample_bytes_out * (planes_out > 1 ? 1 : samples_channels);
|
|
|
|
if (samples_buf_out == null || samples_buf.length != planes_out
|
|
|
|
|| samples_ptr_out[0].capacity() < buffer_size_out) {
|
|
|
|
for (int i = 0; samples_ptr_out != null && i < samples_ptr_out.length; i++) {
|
|
|
|
av_free(samples_ptr_out[i].position(0));
|
|
|
|
}
|
|
|
|
samples_ptr_out = new BytePointer[planes_out];
|
|
|
|
samples_buf_out = new Buffer[planes_out];
|
|
|
|
|
|
|
|
for (int i = 0; i < planes_out; i++) {
|
|
|
|
samples_ptr_out[i] = new BytePointer(av_malloc(buffer_size_out)).capacity(buffer_size_out);
|
|
|
|
ByteBuffer b = samples_ptr_out[i].asBuffer();
|
|
|
|
switch (samples_format) {
|
|
|
|
case AV_SAMPLE_FMT_U8:
|
|
|
|
case AV_SAMPLE_FMT_U8P:
|
|
|
|
samples_buf_out[i] = b;
|
|
|
|
break;
|
|
|
|
case AV_SAMPLE_FMT_S16:
|
|
|
|
case AV_SAMPLE_FMT_S16P:
|
|
|
|
samples_buf_out[i] = b.asShortBuffer();
|
|
|
|
break;
|
|
|
|
case AV_SAMPLE_FMT_S32:
|
|
|
|
case AV_SAMPLE_FMT_S32P:
|
|
|
|
samples_buf_out[i] = b.asIntBuffer();
|
|
|
|
break;
|
|
|
|
case AV_SAMPLE_FMT_FLT:
|
|
|
|
case AV_SAMPLE_FMT_FLTP:
|
|
|
|
samples_buf_out[i] = b.asFloatBuffer();
|
|
|
|
break;
|
|
|
|
case AV_SAMPLE_FMT_DBL:
|
|
|
|
case AV_SAMPLE_FMT_DBLP:
|
|
|
|
samples_buf_out[i] = b.asDoubleBuffer();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
frame.sampleRate = samples_rate;
|
|
|
|
frame.audioChannels = samples_channels;
|
|
|
|
frame.samples = samples_buf_out;
|
|
|
|
|
|
|
|
if ((ret = swr_convert(samples_convert_ctx, new PointerPointer(samples_ptr_out), sample_size_out,
|
|
|
|
new PointerPointer(samples_ptr), sample_size_in)) < 0) {
|
|
|
|
throw new Exception("swr_convert() error " + ret + ": Cannot convert audio samples.");
|
|
|
|
}
|
|
|
|
for (int i = 0; i < planes_out; i++) {
|
|
|
|
samples_ptr_out[i].position(0).limit(ret * (planes_out > 1 ? 1 : samples_channels));
|
|
|
|
samples_buf_out[i].position(0).limit(ret * (planes_out > 1 ? 1 : samples_channels));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public Frame grab() throws Exception {
|
|
|
|
return grabFrame(true, true, true, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
public Frame grabImage() throws Exception {
|
|
|
|
return grabFrame(false, true, true, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
public Frame grabSamples() throws Exception {
|
|
|
|
return grabFrame(true, false, true, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
public Frame grabKeyFrame() throws Exception {
|
|
|
|
return grabFrame(false, true, true, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
public Frame grabFrame(boolean doAudio, boolean doVideo, boolean doProcessing, boolean keyFrames) throws Exception {
|
|
|
|
if (oc == null || oc.isNull()) {
|
|
|
|
throw new Exception("Could not grab: No AVFormatContext. (Has start() been called?)");
|
|
|
|
} else if ((!doVideo || video_st == null) && (!doAudio || audio_st == null)) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
boolean videoFrameGrabbed = frameGrabbed && frame.image != null;
|
|
|
|
boolean audioFrameGrabbed = frameGrabbed && frame.samples != null;
|
|
|
|
frameGrabbed = false;
|
|
|
|
frame.keyFrame = false;
|
|
|
|
frame.imageWidth = 0;
|
|
|
|
frame.imageHeight = 0;
|
|
|
|
frame.imageDepth = 0;
|
|
|
|
frame.imageChannels = 0;
|
|
|
|
frame.imageStride = 0;
|
|
|
|
frame.image = null;
|
|
|
|
frame.sampleRate = 0;
|
|
|
|
frame.audioChannels = 0;
|
|
|
|
frame.samples = null;
|
|
|
|
frame.opaque = null;
|
|
|
|
if (doVideo && videoFrameGrabbed) {
|
|
|
|
if (doProcessing) {
|
|
|
|
processImage();
|
|
|
|
}
|
|
|
|
frame.keyFrame = picture.key_frame() != 0;
|
|
|
|
return frame;
|
|
|
|
} else if (doAudio && audioFrameGrabbed) {
|
|
|
|
if (doProcessing) {
|
|
|
|
processSamples();
|
|
|
|
}
|
|
|
|
frame.keyFrame = samples_frame.key_frame() != 0;
|
|
|
|
return frame;
|
|
|
|
}
|
|
|
|
boolean done = false;
|
|
|
|
while (!done) {
|
|
|
|
if (pkt2.size() <= 0) {
|
|
|
|
if (av_read_frame(oc, pkt) < 0) {
|
|
|
|
if (doVideo && video_st != null) {
|
|
|
|
// The video codec may have buffered some frames
|
|
|
|
pkt.stream_index(video_st.index());
|
|
|
|
pkt.flags(AV_PKT_FLAG_KEY);
|
|
|
|
pkt.data(null);
|
|
|
|
pkt.size(0);
|
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Is this a packet from the video stream?
|
|
|
|
if (doVideo && video_st != null && pkt.stream_index() == video_st.index()
|
|
|
|
&& (!keyFrames || pkt.flags() == AV_PKT_FLAG_KEY)) {
|
|
|
|
// Decode video frame
|
|
|
|
int len = avcodec_decode_video2(video_c, picture, got_frame, pkt);
|
|
|
|
|
|
|
|
// Did we get a video frame?
|
|
|
|
if (len >= 0 && got_frame[0] != 0 && (!keyFrames || picture.pict_type() == AV_PICTURE_TYPE_I)) {
|
|
|
|
long pts = av_frame_get_best_effort_timestamp(picture);
|
|
|
|
AVRational time_base = video_st.time_base();
|
|
|
|
timestamp = 1000000L * pts * time_base.num() / time_base.den();
|
|
|
|
// best guess, AVCodecContext.frame_number = number of decoded frames...
|
|
|
|
frameNumber = (int) Math.round(timestamp * getFrameRate() / 1000000L);
|
|
|
|
frame.image = image_buf;
|
|
|
|
if (doProcessing) {
|
|
|
|
processImage();
|
|
|
|
}
|
|
|
|
done = true;
|
|
|
|
frame.timestamp = timestamp;
|
|
|
|
frame.keyFrame = picture.key_frame() != 0;
|
|
|
|
} else if (pkt.data() == null && pkt.size() == 0) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
} else if (doAudio && audio_st != null && pkt.stream_index() == audio_st.index()) {
|
|
|
|
if (pkt2.size() <= 0) {
|
|
|
|
// HashMap is unacceptably slow on Android
|
|
|
|
// pkt2.put(pkt);
|
|
|
|
BytePointer.memcpy(pkt2, pkt, sizeof_pkt);
|
|
|
|
}
|
|
|
|
av_frame_unref(samples_frame);
|
|
|
|
// Decode audio frame
|
|
|
|
int len = avcodec_decode_audio4(audio_c, samples_frame, got_frame, pkt2);
|
|
|
|
if (len <= 0) {
|
|
|
|
// On error, trash the whole packet
|
|
|
|
pkt2.size(0);
|
|
|
|
} else {
|
|
|
|
pkt2.data(pkt2.data().position(len));
|
|
|
|
pkt2.size(pkt2.size() - len);
|
|
|
|
if (got_frame[0] != 0) {
|
|
|
|
long pts = av_frame_get_best_effort_timestamp(samples_frame);
|
|
|
|
AVRational time_base = audio_st.time_base();
|
|
|
|
timestamp = 1000000L * pts * time_base.num() / time_base.den();
|
|
|
|
frame.samples = samples_buf;
|
|
|
|
/* if a frame has been decoded, output it */
|
|
|
|
if (doProcessing) {
|
|
|
|
processSamples();
|
|
|
|
}
|
|
|
|
done = true;
|
|
|
|
frame.timestamp = timestamp;
|
|
|
|
frame.keyFrame = samples_frame.key_frame() != 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pkt2.size() <= 0) {
|
|
|
|
// Free the packet that was allocated by av_read_frame
|
|
|
|
av_packet_unref(pkt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return frame;
|
|
|
|
}
|
|
|
|
|
|
|
|
public AVPacket grabPacket() throws Exception {
|
|
|
|
if (oc == null || oc.isNull()) {
|
|
|
|
throw new Exception("Could not trigger: No AVFormatContext. (Has start() been called?)");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the next frame of a stream.
|
|
|
|
if (av_read_frame(oc, pkt) < 0) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pkt;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void start() throws Exception {
|
|
|
|
|
|
|
|
}
|
|
|
|
} |
...
|
...
|
|
