#define LOG_TAG "FFmpegExtractor"
#include <utils/Log.h>
+#include <stdint.h>
#include <limits.h> /* INT_MAX */
+#include <inttypes.h>
#include <media/stagefright/foundation/ABitReader.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/hexdump.h>
#include <media/stagefright/DataSource.h>
#include <media/stagefright/MediaBuffer.h>
-#include <media/stagefright/MediaDebug.h>
+#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MediaSource.h>
#include "include/avc_utils.h"
#include "utils/common_utils.h"
#include "utils/ffmpeg_utils.h"
+#include "utils/ffmpeg_cmdutils.h"
#include "FFmpegExtractor.h"
#define DEBUG_READ_ENTRY 0
FFmpegExtractor::FFmpegExtractor(const sp<DataSource> &source)
: mDataSource(source),
- mReaderThreadStarted(false),
- mInitCheck(NO_INIT) {
- LOGV("FFmpegExtractor::FFmpegExtractor");
+ mInitCheck(NO_INIT),
+ mReaderThreadStarted(false) {
+ ALOGV("FFmpegExtractor::FFmpegExtractor");
- int err;
- const char *url = mDataSource->getNamURI();
- if (url == NULL) {
- LOGI("url is error!");
- return;
- }
- // is it right?
- if (!strcmp(url, "-")) {
- av_strlcpy(mFilename, "pipe:", strlen("pipe:") + 1);
- } else {
- av_strlcpy(mFilename, url, strlen(url) + 1);
- }
- LOGI("url: %s, mFilename: %s", url, mFilename);
+ buildFileName(source);
- err = initStreams();
+ int err = initStreams();
if (err < 0) {
- LOGE("failed to init ffmpeg");
+ ALOGE("failed to init ffmpeg");
return;
}
(mFormatCtx->pb ? !mFormatCtx->pb->error : 1) &&
(mDefersToCreateVideoTrack || mDefersToCreateAudioTrack)) {
// FIXME, i am so lazy! Should use pthread_cond_wait to wait conditions
- NamDelay(5);
+ usleep(5000);
}
- LOGV("mProbePkts: %d, mEOF: %d, pb->error(if has): %d, mDefersToCreateVideoTrack: %d, mDefersToCreateAudioTrack: %d",
+ ALOGV("mProbePkts: %d, mEOF: %d, pb->error(if has): %d, mDefersToCreateVideoTrack: %d, mDefersToCreateAudioTrack: %d",
mProbePkts, mEOF, mFormatCtx->pb ? mFormatCtx->pb->error : 0, mDefersToCreateVideoTrack, mDefersToCreateAudioTrack);
mInitCheck = OK;
}
FFmpegExtractor::~FFmpegExtractor() {
- LOGV("FFmpegExtractor::~FFmpegExtractor");
+ ALOGV("FFmpegExtractor::~FFmpegExtractor");
// stop reader here if no track!
stopReaderThread();
}
sp<MediaSource> FFmpegExtractor::getTrack(size_t index) {
- LOGV("FFmpegExtractor::getTrack[%d]", index);
+ ALOGV("FFmpegExtractor::getTrack[%d]", index);
if (mInitCheck != OK) {
return NULL;
}
sp<MetaData> FFmpegExtractor::getTrackMetaData(size_t index, uint32_t flags) {
- LOGV("FFmpegExtractor::getTrackMetaData[%d]", index);
+ ALOGV("FFmpegExtractor::getTrackMetaData[%d]", index);
if (mInitCheck != OK) {
return NULL;
}
sp<MetaData> FFmpegExtractor::getMetaData() {
- LOGV("FFmpegExtractor::getMetaData");
+ ALOGV("FFmpegExtractor::getMetaData");
if (mInitCheck != OK) {
return NULL;
}
uint32_t FFmpegExtractor::flags() const {
- LOGV("FFmpegExtractor::flags");
+ ALOGV("FFmpegExtractor::flags");
if (mInitCheck != OK) {
- return NULL;
+ return 0;
}
uint32_t flags = CAN_PAUSE;
int FFmpegExtractor::check_extradata(AVCodecContext *avctx)
{
- const char *name;
- bool *defersToCreateTrack;
- AVBitStreamFilterContext **bsfc;
+ const char *name = NULL;
+ bool *defersToCreateTrack = NULL;
+ AVBitStreamFilterContext **bsfc = NULL;
// init
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
avctx->codec_id == CODEC_ID_MP1 ||
avctx->codec_id == CODEC_ID_MP2 ||
avctx->codec_id == CODEC_ID_AC3 ||
+ avctx->codec_id == CODEC_ID_DTS ||
avctx->codec_id == CODEC_ID_H263 ||
avctx->codec_id == CODEC_ID_H263P ||
avctx->codec_id == CODEC_ID_H263I ||
if (avctx->codec_id != CODEC_ID_AAC) {
int is_compatible = is_extradata_compatible_with_android(avctx);
if (!is_compatible) {
- LOGI("%s extradata is not compatible with android, should to extract it from bitstream",
+ ALOGI("%s extradata is not compatible with android, should to extract it from bitstream",
av_get_media_type_string(avctx->codec_type));
*defersToCreateTrack = true;
*bsfc = NULL; // H264 don't need bsfc, only AAC?
}
if (avctx->extradata_size <= 0) {
- LOGI("No %s extradata found, should to extract it from bitstream",
+ ALOGI("No %s extradata found, should to extract it from bitstream",
av_get_media_type_string(avctx->codec_type));
*defersToCreateTrack = true;
//CHECK(name != NULL);
if (!*bsfc && name) {
*bsfc = av_bitstream_filter_init(name);
if (!*bsfc) {
- LOGE("Cannot open the %s BSF!", name);
+ ALOGE("Cannot open the %s BSF!", name);
*defersToCreateTrack = false;
return -1;
} else {
- LOGV("open the %s bsf", name);
+ ALOGV("open the %s bsf", name);
return 0;
}
} else {
secs %= 60;
hours = mins / 60;
mins %= 60;
- LOGI("the time is %02d:%02d:%02d.%02d",
+ ALOGI("the time is %02d:%02d:%02d.%02d",
hours, mins, secs, (100 * us) / AV_TIME_BASE);
}
int FFmpegExtractor::stream_component_open(int stream_index)
{
- AVCodecContext *avctx;
- sp<MetaData> meta;
+ AVCodecContext *avctx = NULL;
+ sp<MetaData> meta = NULL;
bool isAVC = false;
bool supported = false;
- uint32_t type;
- const void *data;
- size_t size;
- int ret;
+ uint32_t type = 0;
+ const void *data = NULL;
+ size_t size = 0;
+ int ret = 0;
- LOGI("stream_index: %d", stream_index);
- if (stream_index < 0 || stream_index >= mFormatCtx->nb_streams)
+ ALOGI("stream_index: %d", stream_index);
+ if (stream_index < 0 || stream_index >= (int)mFormatCtx->nb_streams)
return -1;
avctx = mFormatCtx->streams[stream_index]->codec;
case CODEC_ID_WMALOSSLESS:
case CODEC_ID_RV40:
case CODEC_ID_COOK:
+ case CODEC_ID_APE:
+ case CODEC_ID_DTS:
+ case CODEC_ID_FLAC:
supported = true;
break;
default:
}
if (!supported) {
- LOGE("unsupport the codec, id: 0x%0x", avctx->codec_id);
+ ALOGE("unsupport the codec, id: 0x%0x", avctx->codec_id);
return -1;
}
- LOGV("support the codec");
+ ALOGV("support the codec");
unsigned streamType;
ssize_t index = mTracks.indexOfKey(stream_index);
if (index >= 0) {
- LOGE("this track already exists");
+ ALOGE("this track already exists");
return 0;
}
char tagbuf[32];
av_get_codec_tag_string(tagbuf, sizeof(tagbuf), avctx->codec_tag);
- LOGV("Tag %s/0x%08x with codec id '%d'\n", tagbuf, avctx->codec_tag, avctx->codec_id);
+ ALOGV("Tag %s/0x%08x with codec id '%d'\n", tagbuf, avctx->codec_tag, avctx->codec_id);
switch (avctx->codec_type) {
case AVMEDIA_TYPE_VIDEO:
}
if (avctx->extradata) {
- LOGV("video stream extradata:");
+ ALOGV("video stream extradata:");
hexdump(avctx->extradata, avctx->extradata_size);
} else {
- LOGV("video stream no extradata, but we can ignore it.");
+ ALOGV("video stream no extradata, but we can ignore it.");
}
meta = new MetaData;
if (avctx->extradata[0] == 1 /* configurationVersion */) {
// H.264 bitstream without start codes.
isAVC = true;
- LOGV("AVC");
+ ALOGV("AVC");
if (avctx->width == 0 || avctx->height == 0) {
int32_t width, height;
} else {
// H.264 bitstream with start codes.
isAVC = false;
- LOGV("H264");
+ ALOGV("H264");
/* set NULL to release meta as we will new a meta in MakeAVCCodecSpecificData() fxn */
meta->clear();
}
break;
case CODEC_ID_MPEG4:
- LOGV("MPEG4");
+ ALOGV("MPEG4");
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
{
sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
case CODEC_ID_H263:
case CODEC_ID_H263P:
case CODEC_ID_H263I:
- LOGV("H263");
+ ALOGV("H263");
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
break;
case CODEC_ID_MPEG2VIDEO:
- LOGV("MPEG2VIDEO");
+ ALOGV("MPEG2VIDEO");
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
{
sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
}
break;
case CODEC_ID_VC1:
- LOGV("VC1");
+ ALOGV("VC1");
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
break;
case CODEC_ID_WMV1:
- LOGV("WMV1");
+ ALOGV("WMV1");
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
meta->setInt32(kKeyWMVVersion, kTypeWMVVer_7);
break;
case CODEC_ID_WMV2:
- LOGV("WMV2");
+ ALOGV("WMV2");
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
meta->setInt32(kKeyWMVVersion, kTypeWMVVer_8);
break;
case CODEC_ID_WMV3:
- LOGV("WMV3");
+ ALOGV("WMV3");
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
meta->setInt32(kKeyWMVVersion, kTypeWMVVer_9);
break;
case CODEC_ID_RV40:
- LOGV("RV40");
+ ALOGV("RV40");
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
break;
break;
}
- LOGI("width: %d, height: %d, bit_rate: %d", avctx->width, avctx->height, avctx->bit_rate);
+ ALOGI("width: %d, height: %d, bit_rate: %d",
+ avctx->width, avctx->height, avctx->bit_rate);
meta->setInt32(kKeyWidth, avctx->width);
meta->setInt32(kKeyHeight, avctx->height);
if (mVideoStream->duration != AV_NOPTS_VALUE) {
int64_t duration = mVideoStream->duration * av_q2d(mVideoStream->time_base) * 1000000;
printTime(duration);
- LOGV("video startTime: %lld", mVideoStream->start_time);
+ ALOGV("video startTime: %lld", mVideoStream->start_time);
meta->setInt64(kKeyDuration, duration);
} else {
// default when no stream duration
meta->setInt64(kKeyDuration, mFormatCtx->duration);
}
- LOGV("create a video track");
+ ALOGV("create a video track");
index = mTracks.add(
stream_index, new Track(this, meta, isAVC, mVideoStream, &mVideoQ));
}
if (avctx->extradata) {
- LOGV("audio stream extradata:");
+ ALOGV("audio stream extradata:");
hexdump(avctx->extradata, avctx->extradata_size);
} else {
- LOGV("audio stream no extradata, but we can ignore it.");
+ ALOGV("audio stream no extradata, but we can ignore it.");
}
switch(avctx->codec_id) {
case CODEC_ID_MP1:
- LOGV("MP1");
+ ALOGV("MP1");
meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I);
break;
case CODEC_ID_MP2:
- LOGV("MP2");
+ ALOGV("MP2");
meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
break;
case CODEC_ID_MP3:
- LOGV("MP3");
+ ALOGV("MP3");
meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
break;
case CODEC_ID_AC3:
- LOGV("AC3");
+ ALOGV("AC3");
meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
break;
case CODEC_ID_AAC:
- LOGV("AAC");
+ ALOGV("AAC");
uint32_t sr;
const uint8_t *header;
uint8_t profile, sf_index, channel;
sf_index = (header[0] & 0x07) << 1 | (header[1] & 0x80) >> 7;
sr = get_sample_rate(sf_index);
if (sr == 0) {
- LOGE("unsupport the sample rate");
+ ALOGE("unsupport the sample rate");
return -1;
}
channel = (header[1] >> 3) & 0xf;
- LOGV("profile: %d, sf_index: %d, channel: %d", profile, sf_index, channel);
+ ALOGV("profile: %d, sf_index: %d, channel: %d", profile, sf_index, channel);
meta = MakeAACCodecSpecificData(profile, sf_index, channel);
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
break;
case CODEC_ID_WMAV1: // TODO, version?
- LOGV("WMAV1");
+ ALOGV("WMAV1");
meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
break;
case CODEC_ID_WMAV2:
- LOGV("WMAV2");
+ ALOGV("WMAV2");
meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
meta->setInt32(kKeyWMAVersion, kTypeWMA);
break;
case CODEC_ID_WMAPRO:
- LOGV("WMAPRO");
+ ALOGV("WMAPRO");
meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
meta->setInt32(kKeyWMAVersion, kTypeWMAPro);
break;
case CODEC_ID_WMALOSSLESS:
- LOGV("WMALOSSLESS");
+ ALOGV("WMALOSSLESS");
meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
meta->setInt32(kKeyWMAVersion, kTypeWMALossLess);
break;
case CODEC_ID_COOK: // audio codec in RMVB
- LOGV("COOK");
+ ALOGV("COOK");
meta = new MetaData;
meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
break;
+ case CODEC_ID_APE:
+ ALOGV("APE");
+ meta = new MetaData;
+ meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
+ meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ break;
+ case CODEC_ID_DTS:
+ ALOGV("DTS");
+ meta = new MetaData;
+ meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
+ meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ break;
+ case CODEC_ID_FLAC:
+ ALOGV("FLAC");
+ meta = new MetaData;
+ meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
+ meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ break;
default:
CHECK(!"Should not be here. Unsupported codec.");
break;
}
- LOGI("bit_rate: %d, sample_rate: %d, channels: %d", avctx->bit_rate, avctx->sample_rate, avctx->channels);
+ ALOGI("bit_rate: %d, sample_rate: %d, channels: %d, bits_per_coded_sample: %d",
+ avctx->bit_rate, avctx->sample_rate, avctx->channels, avctx->bits_per_coded_sample);
meta->setInt32(kKeySampleRate, avctx->sample_rate);
meta->setInt32(kKeyChannelCount, avctx->channels);
+ meta->setInt32(kKeyBitspersample, avctx->bits_per_coded_sample);
meta->setInt32(kKeyBitRate, avctx->bit_rate);
meta->setInt32(kKeyBlockAlign, avctx->block_align);
if (mAudioStream->duration != AV_NOPTS_VALUE) {
int64_t duration = mAudioStream->duration * av_q2d(mAudioStream->time_base) * 1000000;
printTime(duration);
- LOGV("audio startTime: %lld", mAudioStream->start_time);
+ ALOGV("audio startTime: %lld", mAudioStream->start_time);
meta->setInt64(kKeyDuration, duration);
} else {
// default when no stream duration
meta->setInt64(kKeyDuration, mFormatCtx->duration);
}
- LOGV("create a audio track");
+ ALOGV("create a audio track");
index = mTracks.add(
stream_index, new Track(this, meta, false, mAudioStream, &mAudioQ));
{
AVCodecContext *avctx;
- if (stream_index < 0 || stream_index >= mFormatCtx->nb_streams)
+ if (stream_index < 0 || stream_index >= (int)mFormatCtx->nb_streams)
return;
avctx = mFormatCtx->streams[stream_index]->codec;
switch (avctx->codec_type) {
case AVMEDIA_TYPE_VIDEO:
- LOGV("packet_queue_abort videoq");
+ ALOGV("packet_queue_abort videoq");
packet_queue_abort(&mVideoQ);
/* wait until the end */
while (!mAbortRequest && !mVideoEOSReceived) {
- LOGV("wait for video received");
- NamDelay(10);
+ ALOGV("wait for video received");
+ usleep(10000);
}
- LOGV("packet_queue_end videoq");
+ ALOGV("packet_queue_end videoq");
packet_queue_end(&mVideoQ);
break;
case AVMEDIA_TYPE_AUDIO:
- LOGV("packet_queue_abort audioq");
+ ALOGV("packet_queue_abort audioq");
packet_queue_abort(&mAudioQ);
while (!mAbortRequest && !mAudioEOSReceived) {
- LOGV("wait for audio received");
- NamDelay(10);
+ ALOGV("wait for audio received");
+ usleep(10000);
}
- LOGV("packet_queue_end audioq");
+ ALOGV("packet_queue_end audioq");
packet_queue_end(&mAudioQ);
break;
case AVMEDIA_TYPE_SUBTITLE:
if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
errbuf_ptr = strerror(AVUNERROR(err));
- LOGI("%s: %s\n", filename, errbuf_ptr);
+ ALOGI("%s: %s\n", filename, errbuf_ptr);
+}
+
+void FFmpegExtractor::buildFileName(const sp<DataSource> &source)
+{
+#if 1
+ ALOGI("android-source:%p", &source);
+ // pass the addr of smart pointer("source")
+ snprintf(mFilename, sizeof(mFilename), "android-source:%p", &source);
+ ALOGI("build mFilename: %s", mFilename);
+#else
+ const char *url = mDataSource->getNamURI();
+ if (url == NULL) {
+ ALOGI("url is error!");
+ return;
+ }
+ // is it right?
+ if (!strcmp(url, "-")) {
+ av_strlcpy(mFilename, "pipe:", strlen("pipe:") + 1);
+ } else {
+ av_strlcpy(mFilename, url, strlen(url) + 1);
+ }
+ ALOGI("build url: %s, mFilename: %s", url, mFilename);
+#endif
}
void FFmpegExtractor::setFFmpegDefaultOpts()
#else
mAudioDisable = 0;
#endif
- mShowStatus = 1;
+ mShowStatus = 0;
mSeekByBytes = 0; /* seek by bytes 0=off 1=on -1=auto" */
mDuration = AV_NOPTS_VALUE;
mSeekPos = AV_NOPTS_VALUE;
int FFmpegExtractor::initStreams()
{
- int err, i;
- status_t status;
+ int err = 0;
+ int i = 0;
+ status_t status = UNKNOWN_ERROR;
int eof = 0;
int ret = 0, audio_ret = 0, video_ret = 0;
int pkt_in_play_range = 0;
- AVDictionaryEntry *t;
- AVDictionary **opts;
- int orig_nb_streams;
+ AVDictionaryEntry *t = NULL;
+ AVDictionary **opts = NULL;
+ int orig_nb_streams = 0;
int st_index[AVMEDIA_TYPE_NB] = {0};
int wanted_stream[AVMEDIA_TYPE_NB] = {0};
st_index[AVMEDIA_TYPE_AUDIO] = -1;
mFormatCtx = avformat_alloc_context();
mFormatCtx->interrupt_callback.callback = decode_interrupt_cb;
mFormatCtx->interrupt_callback.opaque = this;
- LOGV("mFilename: %s", mFilename);
+ ALOGV("mFilename: %s", mFilename);
err = avformat_open_input(&mFormatCtx, mFilename, NULL, &format_opts);
if (err < 0) {
print_error_ex(mFilename, err);
goto fail;
}
if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
- LOGE("Option %s not found.\n", t->key);
+ ALOGE("Option %s not found.\n", t->key);
//ret = AVERROR_OPTION_NOT_FOUND;
ret = -1;
goto fail;
err = avformat_find_stream_info(mFormatCtx, opts);
if (err < 0) {
- LOGE("%s: could not find codec parameters\n", mFilename);
+ ALOGE("%s: could not find codec parameters\n", mFilename);
ret = -1;
goto fail;
}
if (mSeekByBytes < 0)
mSeekByBytes = !!(mFormatCtx->iformat->flags & AVFMT_TS_DISCONT);
- for (i = 0; i < mFormatCtx->nb_streams; i++)
+ for (i = 0; i < (int)mFormatCtx->nb_streams; i++)
mFormatCtx->streams[i]->discard = AVDISCARD_ALL;
if (!mVideoDisable)
st_index[AVMEDIA_TYPE_VIDEO] =
mFormatCtx->start_time != AV_NOPTS_VALUE) {
int hours, mins, secs, us;
- LOGV("file startTime: %lld", mFormatCtx->start_time);
+ ALOGV("file startTime: %lld", mFormatCtx->start_time);
mDuration = mFormatCtx->duration;
secs %= 60;
hours = mins / 60;
mins %= 60;
- LOGI("the duration is %02d:%02d:%02d.%02d",
+ ALOGI("the duration is %02d:%02d:%02d.%02d",
hours, mins, secs, (100 * us) / AV_TIME_BASE);
}
}
if ( audio_ret < 0 && video_ret < 0) {
- LOGE("%s: could not open codecs\n", mFilename);
+ ALOGE("%s: could not open codecs\n", mFilename);
ret = -1;
goto fail;
}
}
status_t FFmpegExtractor::startReaderThread() {
- LOGV("Starting reader thread");
+ ALOGV("Starting reader thread");
Mutex::Autolock autoLock(mLock);
if (mReaderThreadStarted)
pthread_create(&mReaderThread, &attr, ReaderWrapper, this);
pthread_attr_destroy(&attr);
mReaderThreadStarted = true;
- LOGD("Reader thread started");
+ ALOGD("Reader thread started");
return OK;
}
void FFmpegExtractor::stopReaderThread() {
- LOGV("Stopping reader thread");
+ ALOGV("Stopping reader thread");
Mutex::Autolock autoLock(mLock);
if (!mReaderThreadStarted) {
- LOGD("Reader thread have been stopped");
+ ALOGD("Reader thread have been stopped");
return;
}
void *dummy;
pthread_join(mReaderThread, &dummy);
mReaderThreadStarted = false;
- LOGD("Reader thread stopped");
+ ALOGD("Reader thread stopped");
}
// static
int eof = 0;
int pkt_in_play_range = 0;
- LOGV("FFmpegExtractor::readerEntry");
+ ALOGV("FFmpegExtractor::readerEntry");
mVideoEOSReceived = false;
mAudioEOSReceived = false;
(mFormatCtx->pb && !strncmp(mFilename, "mmsh:", 5)))) {
/* wait 10 ms to avoid trying to get another packet */
/* XXX: horrible */
- NamDelay(10);
+ usleep(10000);
continue;
}
#endif
if (mSeekReq) {
- LOGV("readerEntry, mSeekReq: %d", mSeekReq);
+ ALOGV("readerEntry, mSeekReq: %d", mSeekReq);
ret = avformat_seek_file(mFormatCtx, -1, INT64_MIN, mSeekPos, INT64_MAX, mSeekFlags);
if (ret < 0) {
- LOGE("%s: error while seeking", mFormatCtx->filename);
+ ALOGE("%s: error while seeking", mFormatCtx->filename);
} else {
if (mAudioStreamIdx >= 0) {
packet_queue_flush(&mAudioQ);
|| ( (mAudioQ .size > MIN_AUDIOQ_SIZE || mAudioStreamIdx < 0)
&& (mVideoQ .nb_packets > MIN_FRAMES || mVideoStreamIdx < 0))) {
#if DEBUG_READ_ENTRY
- LOGV("readerEntry, is full, fuck");
+ ALOGV("readerEntry, is full, fuck");
#endif
/* wait 10 ms */
- NamDelay(10);
+ usleep(10000);
continue;
}
pkt->stream_index = mAudioStreamIdx;
packet_queue_put(&mAudioQ, pkt);
}
- NamDelay(10);
+ usleep(10000);
#if DEBUG_READ_ENTRY
- LOGV("readerEntry, eof = 1, mVideoQ.size: %d, mVideoQ.nb_packets: %d, mAudioQ.size: %d, mAudioQ.nb_packets: %d",
+ ALOGV("readerEntry, eof = 1, mVideoQ.size: %d, mVideoQ.nb_packets: %d, mAudioQ.size: %d, mAudioQ.nb_packets: %d",
mVideoQ.size, mVideoQ.nb_packets, mAudioQ.size, mAudioQ.nb_packets);
#endif
if (mAudioQ.size + mVideoQ.size == 0) {
if (ret < 0) {
if (ret == AVERROR_EOF || url_feof(mFormatCtx->pb))
if (ret == AVERROR_EOF) {
- //LOGV("ret == AVERROR_EOF");
+ //ALOGV("ret == AVERROR_EOF");
}
if (url_feof(mFormatCtx->pb)) {
- //LOGV("url_feof(mFormatCtx->pb)");
+ //ALOGV("url_feof(mFormatCtx->pb)");
}
eof = 1;
mEOF = true;
if (mFormatCtx->pb && mFormatCtx->pb->error) {
- LOGE("mFormatCtx->pb->error: %d", mFormatCtx->pb->error);
+ ALOGE("mFormatCtx->pb->error: %d", mFormatCtx->pb->error);
break;
}
- NamDelay(100);
+ usleep(100000);
continue;
}
stream_component_open(mVideoStreamIdx);
if (!mDefersToCreateVideoTrack)
- LOGI("probe packet counter: %d when create video track ok", mProbePkts);
+ ALOGI("probe packet counter: %d when create video track ok", mProbePkts);
if (mProbePkts == EXTRACTOR_MAX_PROBE_PACKETS)
- LOGI("probe packet counter to max: %d, create video track: %d",
+ ALOGI("probe packet counter to max: %d, create video track: %d",
mProbePkts, !mDefersToCreateVideoTrack);
}
} else if (pkt->stream_index == mAudioStreamIdx) {
}
stream_component_open(mAudioStreamIdx);
if (!mDefersToCreateAudioTrack)
- LOGI("probe packet counter: %d when create audio track ok", mProbePkts);
+ ALOGI("probe packet counter: %d when create audio track ok", mProbePkts);
if (mProbePkts == EXTRACTOR_MAX_PROBE_PACKETS)
- LOGI("probe packet counter to max: %d, create audio track: %d",
+ ALOGI("probe packet counter to max: %d, create audio track: %d",
mProbePkts, !mDefersToCreateAudioTrack);
}
}
}
/* wait until the end */
while (!mAbortRequest) {
- NamDelay(100);
+ usleep(100000);
}
ret = 0;
fail:
- LOGI("reader thread goto end...");
+ ALOGI("reader thread goto end...");
/* close each stream */
if (mAudioStreamIdx >= 0)
// The number of bytes used to encode the length of a NAL unit.
mNALLengthSize = 1 + (ptr[4] & 3);
- LOGV("the stream is AVC, the length of a NAL unit: %d", mNALLengthSize);
+ ALOGV("the stream is AVC, the length of a NAL unit: %d", mNALLengthSize);
mNal2AnnexB = true;
}
status_t status = OK;
if (options && options->getSeekTo(&seekTimeUs, &mode)) {
- LOGV("~~~%s seekTimeUs: %lld, mode: %d", av_get_media_type_string(mMediaType), seekTimeUs, mode);
+ ALOGV("~~~%s seekTimeUs: %lld, mode: %d", av_get_media_type_string(mMediaType), seekTimeUs, mode);
/* add the stream start time */
if (mStream->start_time != AV_NOPTS_VALUE)
seekTimeUs += mStream->start_time * av_q2d(mStream->time_base) * 1000000;
- LOGV("~~~%s seekTimeUs[+startTime]: %lld, mode: %d", av_get_media_type_string(mMediaType), seekTimeUs, mode);
+ ALOGV("~~~%s seekTimeUs[+startTime]: %lld, mode: %d", av_get_media_type_string(mMediaType), seekTimeUs, mode);
if (mExtractor->stream_seek(seekTimeUs, mMediaType) == SEEK)
seeking = true;
}
if (pkt.data == flush_pkt.data) {
- LOGV("read %s flush pkt", av_get_media_type_string(mMediaType));
+ ALOGV("read %s flush pkt", av_get_media_type_string(mMediaType));
av_free_packet(&pkt);
mFirstKeyPktTimestamp = AV_NOPTS_VALUE;
goto retry;
} else if (pkt.data == NULL && pkt.size == 0) {
- LOGV("read %s eos pkt", av_get_media_type_string(mMediaType));
+ ALOGV("read %s eos pkt", av_get_media_type_string(mMediaType));
av_free_packet(&pkt);
mExtractor->reachedEOS(mMediaType);
return ERROR_END_OF_STREAM;
if (waitKeyPkt) {
if (!key) {
- LOGV("drop the no key packet");
+ ALOGV("drop the no key packet");
av_free_packet(&pkt);
goto retry;
} else {
- LOGV("~~~~~~ got the key packet");
+ ALOGV("~~~~~~ got the key packet");
waitKeyPkt = false;
}
}
}
if (pktTS < mFirstKeyPktTimestamp) {
- LOGV("drop the packet with the backward timestamp, maybe them are B-frames after I-frame ^_^");
+ ALOGV("drop the packet with the backward timestamp, maybe them are B-frames after I-frame ^_^");
av_free_packet(&pkt);
goto retry;
}
status = ERROR_MALFORMED;
break;
}
- dst += mNALLengthSize;
- ptr += mNALLengthSize;
+ dst += mNALLengthSize;
+ ptr += mNALLengthSize;
len -= mNALLengthSize;
memcpy(dst, ptr, nal_len);
}
if (status != OK) {
- LOGV("status != OK");
+ ALOGV("status != OK");
mediaBuffer->release();
mediaBuffer = NULL;
av_free_packet(&pkt);
timeUs = (int64_t)((pktTS - start_time) * av_q2d(mStream->time_base) * 1000000);
#if 0
- LOGV("read %s pkt, size: %d, key: %d, pts: %lld, dts: %lld, timeUs[-startTime]: %llu us (%.2f secs)",
+ ALOGV("read %s pkt, size: %d, key: %d, pts: %lld, dts: %lld, timeUs[-startTime]: %llu us (%.2f secs)",
av_get_media_type_string(mMediaType), pkt.size, key, pkt.pts, pkt.dts, timeUs, timeUs/1E6);
#endif
// LegacySniffFFMPEG
typedef struct {
- const char *extension;
+ const char *format;
const char *container;
-} extmap;
-
-static extmap FILE_EXTS[] = {
- {".mp4", MEDIA_MIMETYPE_CONTAINER_MPEG4},
- {".3gp", MEDIA_MIMETYPE_CONTAINER_MPEG4},
- {".mp3", MEDIA_MIMETYPE_AUDIO_MPEG},
- {".mov", MEDIA_MIMETYPE_CONTAINER_MOV},
- {".mkv", MEDIA_MIMETYPE_CONTAINER_MATROSKA},
- {".ts", MEDIA_MIMETYPE_CONTAINER_TS},
- {".avi", MEDIA_MIMETYPE_CONTAINER_AVI},
- {".asf", MEDIA_MIMETYPE_CONTAINER_ASF},
- {".rm ", MEDIA_MIMETYPE_CONTAINER_RM},
-#if 0
- {".wmv", MEDIA_MIMETYPE_CONTAINER_WMV},
- {".wma", MEDIA_MIMETYPE_CONTAINER_WMA},
- {".mpg", MEDIA_MIMETYPE_CONTAINER_MPG},
- {".flv", MEDIA_MIMETYPE_CONTAINER_FLV},
- {".divx", MEDIA_MIMETYPE_CONTAINER_DIVX},
- {".mp2", MEDIA_MIMETYPE_CONTAINER_MP2},
- {".ape", MEDIA_MIMETYPE_CONTAINER_APE},
- {".ra", MEDIA_MIMETYPE_CONTAINER_RA},
-#endif
+} formatmap;
+
+static formatmap FILE_FORMATS[] = {
+ {"mpeg", MEDIA_MIMETYPE_CONTAINER_MPEG2PS },
+ {"mpegts", MEDIA_MIMETYPE_CONTAINER_TS },
+ {"mov,mp4,m4a,3gp,3g2,mj2", MEDIA_MIMETYPE_CONTAINER_MOV },
+ {"matroska,webm", MEDIA_MIMETYPE_CONTAINER_MATROSKA },
+ {"asf", MEDIA_MIMETYPE_CONTAINER_ASF },
+ {"rm", MEDIA_MIMETYPE_CONTAINER_RM },
+ {"flv", MEDIA_MIMETYPE_CONTAINER_FLV },
+ {"avi", MEDIA_MIMETYPE_CONTAINER_AVI },
+ {"wav", MEDIA_MIMETYPE_CONTAINER_WAV },
+ {"ape", MEDIA_MIMETYPE_CONTAINER_APE },
+ {"dts", MEDIA_MIMETYPE_CONTAINER_DTS },
+ {"flac", MEDIA_MIMETYPE_CONTAINER_FLAC },
};
-const char *LegacySniffFFMPEG(const char * uri)
+static void adjustMOVConfidence(AVFormatContext *ic, float *confidence)
+{
+ AVDictionary *tags = NULL;
+ AVDictionaryEntry *tag = NULL;
+
+ tags = ic->metadata;
+
+ //NOTE: You can use command to show these tags,
+ //e.g. "ffprobe -show_format 2012.mov"
+
+ tag = av_dict_get(tags, "major_brand", NULL, 0);
+ if (!tag) {
+ return;
+ }
+
+ ALOGV("major_brand tag is:%s", tag->value);
+
+ //when MEDIA_MIMETYPE_CONTAINER_MOV
+ //WTF, MPEG4Extractor.cpp can not extractor mov format
+ //NOTE: isCompatibleBrand(MPEG4Extractor.cpp)
+ // Won't promise that the following file types can be played.
+ // Just give these file types a chance.
+ // FOURCC('q', 't', ' ', ' '), // Apple's QuickTime
+ //So......
+ if (!strcmp(tag->value, "qt ")) {
+ ALOGI("format is mov, confidence should be larger than mpeg4");
+ //the MEDIA_MIMETYPE_CONTAINER_MPEG4 of confidence is 0.4f
+ *confidence = 0.41f;
+ }
+}
+
+static void adjustVideoCodecConfidence(AVFormatContext *ic,
+ enum AVCodecID codec_id, float *confidence)
+{
+ //add to here
+}
+
+static void adjustAudioCodecConfidence(AVFormatContext *ic,
+ enum AVCodecID codec_id, float *confidence)
+{
+ switch (codec_id) {
+ case CODEC_ID_AC3:
+ //TODO. if the other stream(e.g. mp3) is supported by stagefright
+ ALOGI("ffmpeg can demux ac3 only");
+ *confidence = 0.88f;
+ default:
+ break;
+ }
+}
+
+static void adjustCodecConfidence(AVFormatContext *ic, float *confidence)
+{
+ unsigned int idx = 0;
+ AVCodecContext *avctx = NULL;
+ AVMediaType codec_type = AVMEDIA_TYPE_UNKNOWN;
+ enum AVCodecID codec_id = AV_CODEC_ID_NONE;
+
+ for (idx = 0; idx < ic->nb_streams; idx++)
+ {
+ avctx = ic->streams[idx]->codec;
+ codec_type = avctx->codec_type;
+ codec_id = avctx->codec_id;
+
+ if (codec_type == AVMEDIA_TYPE_VIDEO) {
+ adjustVideoCodecConfidence(ic, codec_id, confidence);
+ } else if (codec_type == AVMEDIA_TYPE_AUDIO) {
+ adjustAudioCodecConfidence(ic, codec_id, confidence);
+ }
+ }
+}
+
+static void adjustConfidenceIfNeeded(const char *mime,
+ AVFormatContext *ic, float *confidence)
+{
+ //check mime
+ if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MOV)) {
+ adjustMOVConfidence(ic, confidence);
+ } else {
+ //add to here;
+ }
+
+ //check codec
+ adjustCodecConfidence(ic, confidence);
+}
+
+static const char *LegacySniffFFMPEG(const char *uri, float *confidence)
{
size_t i;
+ int err;
const char *container = NULL;
+ AVFormatContext *ic = NULL;
- LOGI("list the file extensions suppoted by ffmpeg: ");
- LOGI("========================================");
- for (i = 0; i < NELEM(FILE_EXTS); ++i) {
- LOGV("file_exts[%02d]: %s", i, FILE_EXTS[i].extension);
+ status_t status = initFFmpeg();
+ if (status != OK) {
+ ALOGE("could not init ffmpeg");
+ return NULL;
}
- LOGI("========================================");
-
- int lenURI = strlen(uri);
- for (i = 0; i < NELEM(FILE_EXTS); ++i) {
- int len = strlen(FILE_EXTS[i].extension);
- int start = lenURI - len;
- if (start > 0) {
- if (!av_strncasecmp(uri + start, FILE_EXTS[i].extension, len)) {
- container = FILE_EXTS[i].container;
- break;
- }
+
+ ic = avformat_alloc_context();
+ err = avformat_open_input(&ic, uri, NULL, NULL);
+ if (err < 0) {
+ ALOGE("avformat_open_input faild, uri: %s err: %d", uri, err);
+ return NULL;
+ }
+
+ av_dump_format(ic, 0, uri, 0);
+
+ ALOGI("FFmpegExtrator, uri: %s, format_name: %s, format_long_name: %s",
+ uri, ic->iformat->name, ic->iformat->long_name);
+
+ ALOGI("list the formats suppoted by ffmpeg: ");
+ ALOGI("========================================");
+ for (i = 0; i < NELEM(FILE_FORMATS); ++i) {
+ ALOGV("format_names[%02d]: %s", i, FILE_FORMATS[i].format);
+ }
+ ALOGI("========================================");
+
+ for (i = 0; i < NELEM(FILE_FORMATS); ++i) {
+ int len = strlen(FILE_FORMATS[i].format);
+ if (!av_strncasecmp(ic->iformat->name, FILE_FORMATS[i].format, len)) {
+ container = FILE_FORMATS[i].container;
+ break;
}
}
- return container;
-}
+ if (container) {
+ adjustConfidenceIfNeeded(container, ic, confidence);
+ }
-// BetterSniffFFMPEG
-typedef struct {
- const char *format;
- const char *container;
-} formatmap;
+ avformat_close_input(&ic);
+ av_free(ic);
-static formatmap FILE_FORMATS[] = {
- {"mpegts", MEDIA_MIMETYPE_CONTAINER_TS},
- {"mov,mp4,m4a,3gp,3g2,mj2", MEDIA_MIMETYPE_CONTAINER_MOV},
- {"asf", MEDIA_MIMETYPE_CONTAINER_ASF},
- {"rm", MEDIA_MIMETYPE_CONTAINER_RM},
-};
+ return container;
+}
-const char *BetterSniffFFMPEG(const char * uri)
+static const char *BetterSniffFFMPEG(const sp<DataSource> &source, float *confidence)
{
size_t i;
+ int err;
+ size_t len = 0;
+ char url[128] = {0};
const char *container = NULL;
AVFormatContext *ic = NULL;
status_t status = initFFmpeg();
if (status != OK) {
- LOGE("could not init ffmpeg");
- return false;
+ ALOGE("could not init ffmpeg");
+ return NULL;
}
+ ALOGI("android-source:%p", &source);
+
+ // pass the addr of smart pointer("source")
+ snprintf(url, sizeof(url), "android-source:%p", &source);
+
ic = avformat_alloc_context();
- avformat_open_input(&ic, uri, NULL, NULL);
+ err = avformat_open_input(&ic, url, NULL, NULL);
+ if (err < 0) {
+ ALOGE("avformat_open_input faild, url: %s err: %d", url, err);
+ return NULL;
+ }
- av_dump_format(ic, 0, uri, 0);
+ av_dump_format(ic, 0, url, 0);
- LOGI("FFmpegExtrator, uri: %s, format_name: %s, format_long_name: %s", uri, ic->iformat->name, ic->iformat->long_name);
+ ALOGI("FFmpegExtrator, url: %s, format_name: %s, format_long_name: %s",
+ url, ic->iformat->name, ic->iformat->long_name);
- LOGI("list the format suppoted by ffmpeg: ");
- LOGI("========================================");
+ ALOGI("list the formats suppoted by ffmpeg: ");
+ ALOGI("========================================");
for (i = 0; i < NELEM(FILE_FORMATS); ++i) {
- LOGV("format_names[%02d]: %s", i, FILE_FORMATS[i].format);
+ ALOGV("format_names[%02d]: %s", i, FILE_FORMATS[i].format);
}
- LOGI("========================================");
+ ALOGI("========================================");
for (i = 0; i < NELEM(FILE_FORMATS); ++i) {
int len = strlen(FILE_FORMATS[i].format);
}
}
+ if (container) {
+ adjustConfidenceIfNeeded(container, ic, confidence);
+ }
+
avformat_close_input(&ic);
av_free(ic);
bool SniffFFMPEG(
const sp<DataSource> &source, String8 *mimeType, float *confidence,
sp<AMessage> *meta) {
- LOGV("SniffFFMPEG");
- const char *uri, *container = NULL;
+ ALOGV("SniffFFMPEG");
- uri = source->getNamURI();
+ *confidence = 0.08f; // be the last resort, by default
- if (!uri)
- return false;
+ const char *container = BetterSniffFFMPEG(source, confidence);
+ if (!container) {
+ String8 uri = source->getUri();
+ if (uri.empty())
+ return false;
- LOGI("ffmpeg uri: %s", uri);
+ ALOGW("sniff through BetterSniffFFMPEG failed, try LegacySniffFFMPEG");
- container = BetterSniffFFMPEG(uri);
- if (!container) {
- LOGW("sniff through LegacySniffFFMPEG, only check the file extension");
- container = LegacySniffFFMPEG(uri);
+ container = LegacySniffFFMPEG(uri, confidence);
+ if (container) {
+ ALOGI("sniff through LegacySniffFFMPEG success");
+ }
+ } else {
+ ALOGI("sniff through BetterSniffFFMPEG success");
}
if (container == NULL)
return false;
- LOGV("found container: %s", container);
+ ALOGV("found container: %s", container);
- *confidence = 0.88f; // Slightly larger than other extractor's confidence
mimeType->setTo(container);
/* use MPEG4Extractor(not extended extractor) for HTTP source only */
if (!av_strcasecmp(container, MEDIA_MIMETYPE_CONTAINER_MPEG4)
&& (source->flags() & DataSource::kIsCachingDataSource)) {
- return true;
+ return true;
}
+ ALOGD("ffmpeg detected media content as '%s' with confidence %.2f",
+ container, *confidence);
+
*meta = new AMessage;
(*meta)->setString("extended-extractor", "extended-extractor");
(*meta)->setString("extended-extractor-subtype", "ffmpegextractor");
+ //*confidence = 0.88f;
+
+ if (*confidence > 0.08f) {
+ (*meta)->setString("extended-extractor-use", "ffmpegextractor");
+ }
+
return true;
}
+MediaExtractor *CreateFFmpegExtractor(const sp<DataSource> &source, const char *mime, const sp<AMessage> &meta) {
+ MediaExtractor *ret = NULL;
+ AString notuse;
+ if (meta.get() && meta->findString("extended-extractor", ¬use) && (
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG4) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEG) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MOV) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MATROSKA) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_TS) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2PS) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_AVI) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_ASF) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WEBM) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WMV) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPG) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FLV) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_DIVX) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_RM) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WAV) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FLAC) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_APE) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_DTS) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MP2) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_RA) ||
+ !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WMA))) {
+ ret = new FFmpegExtractor(source);
+ }
+
+ ALOGD("%ssupported mime: %s", (ret ? "" : "un"), mime);
+ return ret;
+}
+
} // namespace android
+
+extern "C" void getExtractorPlugin(android::MediaExtractor::Plugin *plugin)
+{
+ plugin->sniff = android::SniffFFMPEG;
+ plugin->create = android::CreateFFmpegExtractor;
+}
OSDN Git Service
