OSDN > Finden Software > System > OS Verteilung > Live CD > Android-x86 > SCM > git > external-stagefright-plugins > Commit

Android-x86
Fork
external-gbm_gralloc
hardware-powerbtnd
hardware-intel-libva
manifest
device-generic-x86_64
device-generic-common
system-bt
hardware-intel-intel-driver
external-bluetooth-bluedroid
build
device-generic-x86
packages-apps-Camera2
device-viewsonic-viewpad10
packages-apps-Taskbar
packages-apps-Gallery2
system-media
hardware-intel-common-libva
external-vboxguest-linux-modules
system-netd
hardware-intel-common-vaapi
external-swiftshader
external-efibootmgr
device-generic-openthos
packages-apps-Settings
hardware-ril
packages-apps-CMFileManager
packages-apps-Eleven
external-toybox
external-drm_hwcomposer
hardware-libhardware_legacy
system-extras
hardware-libsensors
hardware-liblights
hardware-broadcom-libbt
packages-apps-TSCalibration2
system-core
packages-apps-Bluetooth
device-generic-firmware
device-generic-goldfish
external-s2tc
device-asus
device-amd
device-common
device-hp-tx2500
device-ibm-thinkpad
device-lenovo-s103t
device-tegatech-tegav2
external-srec
external-webkit
external-wpa_supplicant_6
packages-apps-AndroidTerm
packages-apps-FileManager
external-tslib
external-modules-rtl8723au
packages-inputmethods-PinyinIME
sdk
system-bluetooth
hardware-alsa_sound
device-asus-laptop
device-amd-persimmon
development
device-dell-sparta
device-vm-vm
hardware-wacom-input
libcore
packages-apps-Browser
packages-apps-Camera
prebuilt
device-motion-m1400
device-viliv-s5
packages-apps-Superuser
device-asus-eeepc
device-generic-goldfish-opengl
external-mplayer
external-wpa_supplicant
frameworks-policies-base
ndk
packages-apps-Calendar
packages-apps-ConnectBot
packages-apps-Contacts
packages-apps-DeskClock
packages-apps-LIME
packages-apps-Music
packages-providers-DownloadProvider
packages-wallpapers-Basic
packages-wallpapers-MagicSmoke
packages-wallpapers-MusicVisualization
packages-providers-ImProvider
packages-apps-AlarmClock
packages-apps-IM
packages-apps-Launcher
packages-apps-SoundRecorder
external-opencore
vendor-intel-houdini
vendor-samsung-q1u
external-dhcpcd
hardware-menlow-psb
hardware-menlow-ioport
push
external-eject
external-v86d
external-koush-Superuser
external-koush-Widgets
frameworks-native
external-libpciaccess
external-bluetooth-bluez
external-libtruezip
external-stagefright-plugins
external-ntfs-3g
external-parted
hardware-intel-hwcomposer
external-mesa
external-ffmpeg
external-llvm
external-libdrm
external-e2fsprogs
external-bluetooth-glib
hardware-broadcom-wlan
external-drm_gralloc
hardware-gps
external-busybox
kernel
external-alsa-lib
external-alsa-utils
system-vold
frameworks-base
frameworks-av
external-bluetooth-sbc
packages-apps-Trebuchet
dalvik
hardware-x86power
packages-services-Analytics
external-ppp
packages-apps-Launcher3
external-wpa_supplicant_8
hardware-intel-audio_media
hardware-intel-libsensors
hardware-libaudio
hardware-libcamera
external-googleanalytics
hardware-libhardware
hardware-interfaces
bootable-newinstaller
art
external-efivar
hardware-memtrack
system-connectivity-wificond
bionic
external-kernel-drivers
external-drm_framebuffer
external-exfat
external-openssh
external-wireless-tools
external-mksh
external-libffi
external-musl-libc
system-hardware-interfaces
external-minigbm
external-IA-Hardware-Composer
external-drmfb-composer
external-alsa-ucm-conf
external-libncurses
external-llvm-project
system-linkerconfig
Spenden

R/O
HTTP
SSH
HTTPS

external-stagefright-plugins: Commit

external/stagefright-plugins

Commit MetaInfo

Revision	f8884c8dc29c84d08f7a9c3d6131fcf1228ad63b (tree)
Zeit	2019-10-08 12:20:29
Autor	Michael Goffioul <michael.goffioul@gmai...>
Commiter	Chih-Wei Huang

Log Message

Port to pie-x86

Ändern Zusammenfassung

modified: Android.mk (diff)
modified: extractor/Android.mk (diff)
modified: extractor/FFmpegExtractor.cpp (diff)
modified: extractor/FFmpegExtractor.h (diff)
modified: omx/Android.mk (diff)
modified: omx/FFmpegOMXPlugin.cpp (diff)
modified: omx/SoftFFmpegVideo.cpp (diff)
modified: utils/Android.mk (diff)
modified: utils/codec_utils.cpp (diff)
modified: utils/codec_utils.h (diff)
modified: utils/ffmpeg_source.cpp (diff)
modified: utils/ffmpeg_utils.cpp (diff)

Diff

--- a/Android.mk

+++ b/Android.mk

		@@ -21,4 +21,4 @@ LOCAL_PATH := $(call my-dir)
21	21	SF_COMMON_MK := $(LOCAL_PATH)/common.mk
22	22	AV_CODEC_LIB := $(if $(filter true,$(BOARD_USE_LIBAV)),libav,ffmpeg)
23	23
24		-#include $(call first-makefiles-under,$(LOCAL_PATH))
	24	+include $(call first-makefiles-under,$(LOCAL_PATH))

--- a/extractor/Android.mk

+++ b/extractor/Android.mk

		@@ -7,10 +7,11 @@ LOCAL_SRC_FILES := \
7	7
8	8	LOCAL_SHARED_LIBRARIES += \
9	9	libbinder \
10		- libmedia \
	10	+ libmediaextractor \
11	11	libffmpeg_utils \
12	12	liblog \
13	13
14	14	LOCAL_MODULE:= libffmpeg_extractor
	15	+LOCAL_MODULE_RELATIVE_PATH := extractors
15	16
16	17	include $(BUILD_SHARED_LIBRARY)

--- a/extractor/FFmpegExtractor.cpp

+++ b/extractor/FFmpegExtractor.cpp

		@@ -26,20 +26,20 @@
26	26	#include <utils/misc.h>
27	27	#include <utils/String8.h>
28	28	#include <cutils/properties.h>
	29	+#include <media/DataSource.h>
	30	+#include <media/MediaSource.h>
29	31	#include <media/stagefright/foundation/ABitReader.h>
30	32	#include <media/stagefright/foundation/ABuffer.h>
31	33	#include <media/stagefright/foundation/ADebug.h>
32	34	#include <media/stagefright/foundation/AMessage.h>
	35	+#include <media/stagefright/foundation/avc_utils.h>
33	36	#include <media/stagefright/foundation/hexdump.h>
34		-#include <media/stagefright/DataSource.h>
35	37	#include <media/stagefright/MediaBuffer.h>
36	38	#include <media/stagefright/foundation/ADebug.h>
37	39	#include <media/stagefright/MediaDefs.h>
38	40	#include <media/stagefright/MediaErrors.h>
39		-#include <media/stagefright/MediaSource.h>
40	41	#include <media/stagefright/MetaData.h>
41	42	#include <media/stagefright/Utils.h>
42		-#include "include/avc_utils.h"
43	43
44	44	#include "utils/codec_utils.h"
45	45	#include "utils/ffmpeg_cmdutils.h"

		@@ -70,15 +70,18 @@ enum {
70	70
71	71	namespace android {
72	72
73		-struct FFmpegSource : public MediaSource {
74		- FFmpegSource(const sp<FFmpegExtractor> &extractor, size_t index);
	73	+static const char findMatchingContainer(const char name);
	74	+static MediaExtractor CreateFFMPEGExtractor(DataSourceBase source, void *meta);
75	75
76		- virtual status_t start(MetaData *params);
	76	+struct FFmpegSource : public MediaTrack {
	77	+ FFmpegSource(FFmpegExtractor *extractor, size_t index);
	78	+
	79	+ virtual status_t start(MetaDataBase *params);
77	80	virtual status_t stop();
78		- virtual sp<MetaData> getFormat();
	81	+ virtual status_t getFormat(MetaDataBase &meta);
79	82
80	83	virtual status_t read(
81		- MediaBuffer *buffer, const ReadOptions options);
	84	+ MediaBufferBase *buffer, const ReadOptions options);
82	85
83	86	protected:
84	87	virtual ~FFmpegSource();

		@@ -86,7 +89,7 @@ protected:
86	89	private:
87	90	friend struct FFmpegExtractor;
88	91
89		- sp<FFmpegExtractor> mExtractor;
	92	+ FFmpegExtractor *mExtractor;
90	93	size_t mTrackIndex;
91	94
92	95	enum AVMediaType mMediaType;

		@@ -110,9 +113,8 @@ private:
110	113
111	114	////////////////////////////////////////////////////////////////////////////////
112	115
113		-FFmpegExtractor::FFmpegExtractor(const sp<DataSource> &source, const sp<AMessage> &meta)
	116	+FFmpegExtractor::FFmpegExtractor(DataSourceBase *source, const sp<AMessage> &meta)
114	117	: mDataSource(source),
115		- mMeta(new MetaData),
116	118	mInitCheck(NO_INIT),
117	119	mFormatCtx(NULL),
118	120	mReaderThreadStarted(false),

		@@ -159,7 +161,7 @@ size_t FFmpegExtractor::countTracks() {
159	161	return mInitCheck == OK ? mTracks.size() : 0;
160	162	}
161	163
162		-sp<IMediaSource> FFmpegExtractor::getTrack(size_t index) {
	164	+MediaTrack* FFmpegExtractor::getTrack(size_t index) {
163	165	ALOGV("FFmpegExtractor::getTrack[%zu]", index);
164	166
165	167	if (mInitCheck != OK) {

		@@ -173,32 +175,33 @@ sp<IMediaSource> FFmpegExtractor::getTrack(size_t index) {
173	175	return new FFmpegSource(this, index);
174	176	}
175	177
176		-sp<MetaData> FFmpegExtractor::getTrackMetaData(size_t index, uint32_t flags __unused) {
	178	+status_t FFmpegExtractor::getTrackMetaData(MetaDataBase &meta, size_t index, uint32_t flags __unused) {
177	179	ALOGV("FFmpegExtractor::getTrackMetaData[%zu]", index);
178	180
179	181	if (mInitCheck != OK) {
180		- return NULL;
	182	+ return UNKNOWN_ERROR;
181	183	}
182	184
183	185	if (index >= mTracks.size()) {
184		- return NULL;
	186	+ return UNKNOWN_ERROR;
185	187	}
186	188
187	189	/* Quick and dirty, just get a frame 1/4 in */
188	190	if (mTracks.itemAt(index).mIndex == mVideoStreamIdx &&
189	191	mFormatCtx->duration != AV_NOPTS_VALUE) {
190		- mTracks.itemAt(index).mMeta->setInt64(
	192	+ mTracks.editItemAt(index).mMeta.setInt64(
191	193	kKeyThumbnailTime, mFormatCtx->duration / 4);
192	194	}
193	195
194		- return mTracks.itemAt(index).mMeta;
	196	+ meta = mTracks.itemAt(index).mMeta;
	197	+ return OK;
195	198	}
196	199
197		-sp<MetaData> FFmpegExtractor::getMetaData() {
	200	+status_t FFmpegExtractor::getMetaData(MetaDataBase &meta) {
198	201	ALOGV("FFmpegExtractor::getMetaData");
199	202
200	203	if (mInitCheck != OK) {
201		- return NULL;
	204	+ return UNKNOWN_ERROR;
202	205	}
203	206
204	207	if (!mParsedMetadata) {

		@@ -206,7 +209,8 @@ sp<MetaData> FFmpegExtractor::getMetaData() {
206	209	mParsedMetadata = true;
207	210	}
208	211
209		- return mMeta;
	212	+ meta = mMeta;
	213	+ return OK;
210	214	}
211	215
212	216	uint32_t FFmpegExtractor::flags() const {

		@@ -360,10 +364,10 @@ bool FFmpegExtractor::is_codec_supported(enum AVCodecID codec_id)
360	364	return supported;
361	365	}
362	366
363		-sp<MetaData> FFmpegExtractor::setVideoFormat(AVStream *stream)
	367	+status_t FFmpegExtractor::setVideoFormat(AVStream *stream, MetaDataBase &meta)
364	368	{
365	369	AVCodecContext *avctx = NULL;
366		- sp<MetaData> meta = NULL;
	370	+ status_t ret = UNKNOWN_ERROR;
367	371
368	372	avctx = stream->codec;
369	373	CHECK_EQ((int)avctx->codec_type, (int)AVMEDIA_TYPE_VIDEO);

		@@ -371,70 +375,69 @@ sp<MetaData> FFmpegExtractor::setVideoFormat(AVStream *stream)
371	375	switch(avctx->codec_id) {
372	376	case AV_CODEC_ID_H264:
373	377	if (avctx->extradata[0] == 1) {
374		- meta = setAVCFormat(avctx);
	378	+ ret = setAVCFormat(avctx, meta);
375	379	} else {
376		- meta = setH264Format(avctx);
	380	+ ret = setH264Format(avctx, meta);
377	381	}
378	382	break;
379	383	case AV_CODEC_ID_MPEG4:
380		- meta = setMPEG4Format(avctx);
	384	+ ret = setMPEG4Format(avctx, meta);
381	385	break;
382	386	case AV_CODEC_ID_H263:
383	387	case AV_CODEC_ID_H263P:
384	388	case AV_CODEC_ID_H263I:
385		- meta = setH263Format(avctx);
	389	+ ret = setH263Format(avctx, meta);
386	390	break;
387	391	case AV_CODEC_ID_MPEG1VIDEO:
388	392	case AV_CODEC_ID_MPEG2VIDEO:
389		- meta = setMPEG2VIDEOFormat(avctx);
	393	+ ret = setMPEG2VIDEOFormat(avctx, meta);
390	394	break;
391	395	case AV_CODEC_ID_VC1:
392		- meta = setVC1Format(avctx);
	396	+ ret = setVC1Format(avctx, meta);
393	397	break;
394	398	case AV_CODEC_ID_WMV1:
395		- meta = setWMV1Format(avctx);
	399	+ ret = setWMV1Format(avctx, meta);
396	400	break;
397	401	case AV_CODEC_ID_WMV2:
398		- meta = setWMV2Format(avctx);
	402	+ ret = setWMV2Format(avctx, meta);
399	403	break;
400	404	case AV_CODEC_ID_WMV3:
401		- meta = setWMV3Format(avctx);
	405	+ ret = setWMV3Format(avctx, meta);
402	406	break;
403	407	case AV_CODEC_ID_RV20:
404		- meta = setRV20Format(avctx);
	408	+ ret = setRV20Format(avctx, meta);
405	409	break;
406	410	case AV_CODEC_ID_RV30:
407		- meta = setRV30Format(avctx);
	411	+ ret = setRV30Format(avctx, meta);
408	412	break;
409	413	case AV_CODEC_ID_RV40:
410		- meta = setRV40Format(avctx);
	414	+ ret = setRV40Format(avctx, meta);
411	415	break;
412	416	case AV_CODEC_ID_FLV1:
413		- meta = setFLV1Format(avctx);
	417	+ ret = setFLV1Format(avctx, meta);
414	418	break;
415	419	case AV_CODEC_ID_HEVC:
416		- meta = setHEVCFormat(avctx);
	420	+ ret = setHEVCFormat(avctx, meta);
417	421	break;
418	422	case AV_CODEC_ID_VP8:
419		- meta = setVP8Format(avctx);
	423	+ ret = setVP8Format(avctx, meta);
420	424	break;
421	425	case AV_CODEC_ID_VP9:
422		- meta = setVP9Format(avctx);
	426	+ ret = setVP9Format(avctx, meta);
423	427	break;
424	428	default:
425	429	ALOGD("unsupported video codec (id: %d, name: %s), but give it a chance",
426	430	avctx->codec_id, avcodec_get_name(avctx->codec_id));
427		- meta = new MetaData;
428		- meta->setInt32(kKeyCodecId, avctx->codec_id);
429		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FFMPEG);
	431	+ meta.setInt32(kKeyCodecId, avctx->codec_id);
	432	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FFMPEG);
430	433	if (avctx->extradata_size > 0) {
431		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	434	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
432	435	}
433	436	//CHECK(!"Should not be here. Unsupported codec.");
434	437	break;
435	438	}
436	439
437		- if (meta != NULL) {
	440	+ if (ret == OK) {
438	441	// rotation
439	442	double theta = get_rotation(stream);
440	443	int rotationDegrees = 0;

		@@ -447,11 +450,11 @@ sp<MetaData> FFmpegExtractor::setVideoFormat(AVStream *stream)
447	450	rotationDegrees = 270;
448	451	}
449	452	if (rotationDegrees != 0) {
450		- meta->setInt32(kKeyRotation, rotationDegrees);
	453	+ meta.setInt32(kKeyRotation, rotationDegrees);
451	454	}
452	455	}
453	456
454		- if (meta != NULL) {
	457	+ if (ret == OK) {
455	458	float aspect_ratio;
456	459	int width, height;
457	460

		@@ -471,90 +474,89 @@ sp<MetaData> FFmpegExtractor::setVideoFormat(AVStream *stream)
471	474	ALOGI("width: %d, height: %d, bit_rate: % " PRId64 " aspect ratio: %f",
472	475	avctx->width, avctx->height, avctx->bit_rate, aspect_ratio);
473	476
474		- meta->setInt32(kKeyWidth, avctx->width);
475		- meta->setInt32(kKeyHeight, avctx->height);
	477	+ meta.setInt32(kKeyWidth, avctx->width);
	478	+ meta.setInt32(kKeyHeight, avctx->height);
476	479	if ((width > 0) && (height > 0) &&
477	480	((avctx->width != width \|\| avctx->height != height))) {
478		- meta->setInt32(kKeySARWidth, width);
479		- meta->setInt32(kKeySARHeight, height);
	481	+ meta.setInt32(kKeySARWidth, width);
	482	+ meta.setInt32(kKeySARHeight, height);
480	483	ALOGI("SAR width: %d, SAR height: %d", width, height);
481	484	}
482	485	if (avctx->bit_rate > 0) {
483		- meta->setInt32(kKeyBitRate, avctx->bit_rate);
	486	+ meta.setInt32(kKeyBitRate, avctx->bit_rate);
484	487	}
485		- meta->setCString('ffmt', findMatchingContainer(mFormatCtx->iformat->name));
	488	+ meta.setCString('ffmt', findMatchingContainer(mFormatCtx->iformat->name));
486	489	setDurationMetaData(stream, meta);
487	490	}
488	491
489		- return meta;
	492	+ return OK;
490	493	}
491	494
492		-sp<MetaData> FFmpegExtractor::setAudioFormat(AVStream *stream)
	495	+status_t FFmpegExtractor::setAudioFormat(AVStream *stream, MetaDataBase &meta)
493	496	{
494	497	AVCodecContext *avctx = NULL;
495		- sp<MetaData> meta = NULL;
	498	+ status_t ret = UNKNOWN_ERROR;
496	499
497	500	avctx = stream->codec;
498	501	CHECK_EQ((int)avctx->codec_type, (int)AVMEDIA_TYPE_AUDIO);
499	502
500	503	switch(avctx->codec_id) {
501	504	case AV_CODEC_ID_MP2:
502		- meta = setMP2Format(avctx);
	505	+ ret = setMP2Format(avctx, meta);
503	506	break;
504	507	case AV_CODEC_ID_MP3:
505		- meta = setMP3Format(avctx);
	508	+ ret = setMP3Format(avctx, meta);
506	509	break;
507	510	case AV_CODEC_ID_VORBIS:
508		- meta = setVORBISFormat(avctx);
	511	+ ret = setVORBISFormat(avctx, meta);
509	512	break;
510	513	case AV_CODEC_ID_AC3:
511		- meta = setAC3Format(avctx);
	514	+ ret = setAC3Format(avctx, meta);
512	515	break;
513	516	case AV_CODEC_ID_AAC:
514		- meta = setAACFormat(avctx);
	517	+ ret = setAACFormat(avctx, meta);
515	518	break;
516	519	case AV_CODEC_ID_WMAV1:
517		- meta = setWMAV1Format(avctx);
	520	+ ret = setWMAV1Format(avctx, meta);
518	521	break;
519	522	case AV_CODEC_ID_WMAV2:
520		- meta = setWMAV2Format(avctx);
	523	+ ret = setWMAV2Format(avctx, meta);
521	524	break;
522	525	case AV_CODEC_ID_WMAPRO:
523		- meta = setWMAProFormat(avctx);
	526	+ ret = setWMAProFormat(avctx, meta);
524	527	break;
525	528	case AV_CODEC_ID_WMALOSSLESS:
526		- meta = setWMALossLessFormat(avctx);
	529	+ ret = setWMALossLessFormat(avctx, meta);
527	530	break;
528	531	case AV_CODEC_ID_COOK:
529		- meta = setRAFormat(avctx);
	532	+ ret = setRAFormat(avctx, meta);
530	533	break;
531	534	case AV_CODEC_ID_APE:
532		- meta = setAPEFormat(avctx);
	535	+ ret = setAPEFormat(avctx, meta);
533	536	break;
534	537	case AV_CODEC_ID_DTS:
535		- meta = setDTSFormat(avctx);
	538	+ ret = setDTSFormat(avctx, meta);
536	539	break;
537	540	case AV_CODEC_ID_FLAC:
538		- meta = setFLACFormat(avctx);
	541	+ ret = setFLACFormat(avctx, meta);
539	542	break;
540	543	case AV_CODEC_ID_ALAC:
541		- meta = setALACFormat(avctx);
	544	+ ret = setALACFormat(avctx, meta);
542	545	break;
543	546	default:
544	547	ALOGD("unsupported audio codec (id: %d, name: %s), but give it a chance",
545	548	avctx->codec_id, avcodec_get_name(avctx->codec_id));
546		- meta = new MetaData;
547		- meta->setInt32(kKeyCodecId, avctx->codec_id);
548		- meta->setInt32(kKeyCodedSampleBits, avctx->bits_per_coded_sample);
549		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FFMPEG);
	549	+ meta.setInt32(kKeyCodecId, avctx->codec_id);
	550	+ meta.setInt32(kKeyCodedSampleBits, avctx->bits_per_coded_sample);
	551	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FFMPEG);
550	552	if (avctx->extradata_size > 0) {
551		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	553	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
552	554	}
553	555	//CHECK(!"Should not be here. Unsupported codec.");
554	556	break;
555	557	}
556	558
557		- if (meta != NULL) {
	559	+ if (ret == OK) {
558	560	ALOGD("bit_rate: %" PRId64 ", sample_rate: %d, channels: %d, "
559	561	"bits_per_coded_sample: %d, block_align: %d "
560	562	"bits_per_raw_sample: %d, sample_format: %d",

		@@ -562,24 +564,24 @@ sp<MetaData> FFmpegExtractor::setAudioFormat(AVStream *stream)
562	564	avctx->bits_per_coded_sample, avctx->block_align,
563	565	avctx->bits_per_raw_sample, avctx->sample_fmt);
564	566
565		- meta->setInt32(kKeyChannelCount, avctx->channels);
566		- meta->setInt32(kKeyBitRate, avctx->bit_rate);
	567	+ meta.setInt32(kKeyChannelCount, avctx->channels);
	568	+ meta.setInt32(kKeyBitRate, avctx->bit_rate);
567	569	int32_t bits = avctx->bits_per_raw_sample > 0 ?
568	570	avctx->bits_per_raw_sample :
569	571	av_get_bytes_per_sample(avctx->sample_fmt) * 8;
570		- meta->setInt32(kKeyBitsPerRawSample, bits);
571		- meta->setInt32(kKeySampleRate, avctx->sample_rate);
572		- meta->setInt32(kKeyBlockAlign, avctx->block_align);
573		- meta->setInt32(kKeySampleFormat, avctx->sample_fmt);
574		- //meta->setInt32(kKeyPcmEncoding, sampleFormatToEncoding(avctx->sample_fmt));
575		- meta->setCString('ffmt', findMatchingContainer(mFormatCtx->iformat->name));
	572	+ meta.setInt32(kKeyBitsPerRawSample, bits);
	573	+ meta.setInt32(kKeySampleRate, avctx->sample_rate);
	574	+ meta.setInt32(kKeyBlockAlign, avctx->block_align);
	575	+ meta.setInt32(kKeySampleFormat, avctx->sample_fmt);
	576	+ //meta.setInt32(kKeyPcmEncoding, sampleFormatToEncoding(avctx->sample_fmt));
	577	+ meta.setCString('ffmt', findMatchingContainer(mFormatCtx->iformat->name));
576	578	setDurationMetaData(stream, meta);
577	579	}
578	580
579		- return meta;
	581	+ return OK;
580	582	}
581	583
582		-void FFmpegExtractor::setDurationMetaData(AVStream *stream, sp<MetaData> &meta)
	584	+void FFmpegExtractor::setDurationMetaData(AVStream *stream, MetaDataBase &meta)
583	585	{
584	586	AVCodecContext *avctx = stream->codec;
585	587

		@@ -592,10 +594,10 @@ void FFmpegExtractor::setDurationMetaData(AVStream *stream, sp<MetaData> &meta)
592	594	} else {
593	595	ALOGV("%s startTime:N/A", s);
594	596	}
595		- meta->setInt64(kKeyDuration, duration);
	597	+ meta.setInt64(kKeyDuration, duration);
596	598	} else {
597	599	// default when no stream duration
598		- meta->setInt64(kKeyDuration, mFormatCtx->duration);
	600	+ meta.setInt64(kKeyDuration, mFormatCtx->duration);
599	601	}
600	602	}
601	603

		@@ -603,11 +605,7 @@ int FFmpegExtractor::stream_component_open(int stream_index)
603	605	{
604	606	TrackInfo *trackInfo = NULL;
605	607	AVCodecContext *avctx = NULL;
606		- sp<MetaData> meta = NULL;
607	608	bool supported = false;
608		- uint32_t type = 0;
609		- const void *data = NULL;
610		- size_t size = 0;
611	609	int ret = 0;
612	610
613	611	ALOGI("stream_index: %d", stream_index);

		@@ -627,7 +625,6 @@ int FFmpegExtractor::stream_component_open(int stream_index)
627	625	}
628	626	ALOGI("support the codec(%s) disposition(%x)", avcodec_get_name(avctx->codec_id), mFormatCtx->streams[stream_index]->disposition);
629	627
630		- unsigned streamType;
631	628	for (size_t i = 0; i < mTracks.size(); ++i) {
632	629	if (stream_index == mTracks.editItemAt(i).mIndex) {
633	630	ALOGE("this track already exists");

		@@ -641,6 +638,8 @@ int FFmpegExtractor::stream_component_open(int stream_index)
641	638	av_get_codec_tag_string(tagbuf, sizeof(tagbuf), avctx->codec_tag);
642	639	ALOGV("Tag %s/0x%08x with codec(%s)\n", tagbuf, avctx->codec_tag, avcodec_get_name(avctx->codec_id));
643	640
	641	+ MetaDataBase meta;
	642	+
644	643	switch (avctx->codec_type) {
645	644	case AVMEDIA_TYPE_VIDEO:
646	645	if (mVideoStreamIdx == -1)

		@@ -667,8 +666,7 @@ int FFmpegExtractor::stream_component_open(int stream_index)
667	666	ALOGV("video stream no extradata, but we can ignore it.");
668	667	}
669	668	#endif
670		- meta = setVideoFormat(mVideoStream);
671		- if (meta == NULL) {
	669	+ if (setVideoFormat(mVideoStream, meta) != OK) {
672	670	ALOGE("setVideoFormat failed");
673	671	return -1;
674	672	}

		@@ -709,8 +707,7 @@ int FFmpegExtractor::stream_component_open(int stream_index)
709	707	ALOGV("audio stream no extradata, but we can ignore it.");
710	708	}
711	709	#endif
712		- meta = setAudioFormat(mAudioStream);
713		- if (meta == NULL) {
	710	+ if (setAudioFormat(mAudioStream, meta) != OK) {
714	711	ALOGE("setAudioFormat failed");
715	712	return -1;
716	713	}

		@@ -876,7 +873,7 @@ void FFmpegExtractor::fetchStuffsFromSniffedMeta(const sp<AMessage> &meta)
876	873	//mime
877	874	CHECK(meta->findString("extended-extractor-mime", &mime));
878	875	CHECK(mime.c_str() != NULL);
879		- mMeta->setCString(kKeyMIMEType, mime.c_str());
	876	+ mMeta.setCString(kKeyMIMEType, mime.c_str());
880	877	}
881	878
882	879	void FFmpegExtractor::setFFmpegDefaultOpts()

		@@ -922,9 +919,7 @@ int FFmpegExtractor::initStreams()
922	919	{
923	920	int err = 0;
924	921	int i = 0;
925		- int eof = 0;
926	922	int ret = 0, audio_ret = -1, video_ret = -1;
927		- int pkt_in_play_range = 0;
928	923	AVDictionaryEntry *t = NULL;
929	924	AVDictionary **opts = NULL;
930	925	int orig_nb_streams = 0;

		@@ -935,7 +930,6 @@ int FFmpegExtractor::initStreams()
935	930	wanted_stream[AVMEDIA_TYPE_AUDIO] = -1;
936	931	wanted_stream[AVMEDIA_TYPE_VIDEO] = -1;
937	932	AVDictionary format_opts = NULL, codec_opts = NULL;
938		- const char *mime = NULL;
939	933
940	934	setFFmpegDefaultOpts();
941	935

		@@ -1120,10 +1114,9 @@ void FFmpegExtractor::ReaderWrapper(void me) {
1120	1114	}
1121	1115
1122	1116	void FFmpegExtractor::readerEntry() {
1123		- int err, i, ret;
	1117	+ int ret;
1124	1118	AVPacket pkt1, *pkt = &pkt1;
1125	1119	int eof = 0;
1126		- int pkt_in_play_range = 0;
1127	1120
1128	1121	mLock.lock();
1129	1122

		@@ -1323,7 +1316,7 @@ fail:
1323	1316	////////////////////////////////////////////////////////////////////////////////
1324	1317
1325	1318	FFmpegSource::FFmpegSource(
1326		- const sp<FFmpegExtractor> &extractor, size_t index)
	1319	+ FFmpegExtractor *extractor, size_t index)
1327	1320	: mExtractor(extractor),
1328	1321	mTrackIndex(index),
1329	1322	mIsAVC(false),

		@@ -1333,7 +1326,7 @@ FFmpegSource::FFmpegSource(
1333	1326	mQueue(mExtractor->mTracks.itemAt(index).mQueue),
1334	1327	mLastPTS(AV_NOPTS_VALUE),
1335	1328	mTargetTime(AV_NOPTS_VALUE) {
1336		- sp<MetaData> meta = mExtractor->mTracks.itemAt(index).mMeta;
	1329	+ const MetaDataBase& meta = mExtractor->mTracks.itemAt(index).mMeta;
1337	1330
1338	1331	{
1339	1332	AVCodecContext *avctx = mStream->codec;

		@@ -1347,7 +1340,7 @@ FFmpegSource::FFmpegSource(
1347	1340	uint32_t type;
1348	1341	const void *data;
1349	1342	size_t size;
1350		- CHECK(meta->findData(kKeyAVCC, &type, &data, &size));
	1343	+ CHECK(meta.findData(kKeyAVCC, &type, &data, &size));
1351	1344
1352	1345	const uint8_t ptr = (const uint8_t )data;
1353	1346

		@@ -1373,7 +1366,7 @@ FFmpegSource::FFmpegSource(
1373	1366	uint32_t type;
1374	1367	const void *data;
1375	1368	size_t size;
1376		- CHECK(meta->findData(kKeyHVCC, &type, &data, &size));
	1369	+ CHECK(meta.findData(kKeyHVCC, &type, &data, &size));
1377	1370
1378	1371	const uint8_t ptr = (const uint8_t )data;
1379	1372

		@@ -1400,7 +1393,7 @@ FFmpegSource::~FFmpegSource() {
1400	1393	mExtractor = NULL;
1401	1394	}
1402	1395
1403		-status_t FFmpegSource::start(MetaData * /* params */) {
	1396	+status_t FFmpegSource::start(MetaDataBase * /* params */) {
1404	1397	ALOGV("FFmpegSource::start %s",
1405	1398	av_get_media_type_string(mMediaType));
1406	1399	return OK;

		@@ -1412,12 +1405,13 @@ status_t FFmpegSource::stop() {
1412	1405	return OK;
1413	1406	}
1414	1407
1415		-sp<MetaData> FFmpegSource::getFormat() {
1416		- return mExtractor->mTracks.itemAt(mTrackIndex).mMeta;;
	1408	+status_t FFmpegSource::getFormat(MetaDataBase &meta) {
	1409	+ meta = mExtractor->mTracks.itemAt(mTrackIndex).mMeta;
	1410	+ return OK;
1417	1411	}
1418	1412
1419	1413	status_t FFmpegSource::read(
1420		- MediaBuffer *buffer, const ReadOptions options) {
	1414	+ MediaBufferBase *buffer, const ReadOptions options) {
1421	1415	*buffer = NULL;
1422	1416
1423	1417	AVPacket pkt;

		@@ -1496,7 +1490,7 @@ retry:
1496	1490	}
1497	1491
1498	1492	MediaBuffer *mediaBuffer = new MediaBuffer(pkt.size + AV_INPUT_BUFFER_PADDING_SIZE);
1499		- mediaBuffer->meta_data()->clear();
	1493	+ mediaBuffer->meta_data().clear();
1500	1494	mediaBuffer->set_range(0, pkt.size);
1501	1495
1502	1496	//copy data

		@@ -1567,14 +1561,14 @@ retry:
1567	1561	av_get_media_type_string(mMediaType), pkt.size, key);
1568	1562	#endif
1569	1563
1570		- mediaBuffer->meta_data()->setInt64(kKeyTime, timeUs);
1571		- mediaBuffer->meta_data()->setInt32(kKeyIsSyncFrame, key);
	1564	+ mediaBuffer->meta_data().setInt64(kKeyTime, timeUs);
	1565	+ mediaBuffer->meta_data().setInt32(kKeyIsSyncFrame, key);
1572	1566
1573	1567	// deal with seek-to-exact-frame, we might be off a bit and Stagefright will assert on us
1574	1568	if (seekTimeUs != AV_NOPTS_VALUE && timeUs < seekTimeUs &&
1575	1569	mode == MediaSource::ReadOptions::SEEK_CLOSEST) {
1576	1570	mTargetTime = seekTimeUs;
1577		- mediaBuffer->meta_data()->setInt64(kKeyTargetTime, seekTimeUs);
	1571	+ mediaBuffer->meta_data().setInt64(kKeyTargetTime, seekTimeUs);
1578	1572	}
1579	1573
1580	1574	if (mTargetTime != AV_NOPTS_VALUE) {

		@@ -1582,7 +1576,7 @@ retry:
1582	1576	mTargetTime = AV_NOPTS_VALUE;
1583	1577	} else if (nextPTS != AV_NOPTS_VALUE && nextPTS > mTargetTime) {
1584	1578	ALOGV("adjust target frame time to %" PRId64, timeUs);
1585		- mediaBuffer->meta_data()->setInt64(kKeyTime, mTargetTime);
	1579	+ mediaBuffer->meta_data().setInt64(kKeyTime, mTargetTime);
1586	1580	mTargetTime = AV_NOPTS_VALUE;
1587	1581	}
1588	1582	}

		@@ -1658,7 +1652,6 @@ static enum AVCodecID getCodecId(AVFormatContext *ic, AVMediaType codec_type)
1658	1652
1659	1653	static bool hasAudioCodecOnly(AVFormatContext *ic)
1660	1654	{
1661		- enum AVCodecID codec_id = AV_CODEC_ID_NONE;
1662	1655	bool haveVideo = false;
1663	1656	bool haveAudio = false;
1664	1657

		@@ -2098,16 +2091,16 @@ fail:
2098	2091	return container;
2099	2092	}
2100	2093
2101		-static const char *BetterSniffFFMPEG(const sp<DataSource> &source,
2102		- float *confidence, sp<AMessage> meta)
	2094	+static const char BetterSniffFFMPEG(DataSourceBase source,
	2095	+ float confidence, AMessage meta)
2103	2096	{
2104	2097	const char *ret = NULL;
2105	2098	char url[PATH_MAX] = {0};
2106	2099
2107		- ALOGI("android-source:%p", source.get());
	2100	+ ALOGI("android-source:%p", source);
2108	2101
2109	2102	// pass the addr of smart pointer("source")
2110		- snprintf(url, sizeof(url), "android-source:%p", source.get());
	2103	+ snprintf(url, sizeof(url), "android-source:%p", source);
2111	2104
2112	2105	ret = SniffFFMPEGCommon(url, confidence,
2113	2106	(source->flags() & DataSource::kIsCachingDataSource));

		@@ -2118,24 +2111,24 @@ static const char *BetterSniffFFMPEG(const sp<DataSource> &source,
2118	2111	return ret;
2119	2112	}
2120	2113
2121		-static const char *LegacySniffFFMPEG(const sp<DataSource> &source,
2122		- float *confidence, sp<AMessage> meta)
	2114	+static const char LegacySniffFFMPEG(DataSourceBase source,
	2115	+ float confidence, AMessage meta)
2123	2116	{
2124	2117	const char *ret = NULL;
	2118	+ char uri[PATH_MAX] = {0};
2125	2119	char url[PATH_MAX] = {0};
2126	2120
2127		- String8 uri = source->getUri();
2128		- if (!uri.string()) {
	2121	+ if (!source->getUri(uri, sizeof(uri))) {
2129	2122	return NULL;
2130	2123	}
2131	2124
2132	2125	if (source->flags() & DataSource::kIsCachingDataSource)
2133	2126	return NULL;
2134	2127
2135		- ALOGV("source url:%s", uri.string());
	2128	+ ALOGV("source url:%s", uri);
2136	2129
2137	2130	// pass the addr of smart pointer("source") + file name
2138		- snprintf(url, sizeof(url), "android-source:%p\|file:%s", source.get(), uri.string());
	2131	+ snprintf(url, sizeof(url), "android-source:%p\|file:%s", source, uri);
2139	2132
2140	2133	ret = SniffFFMPEGCommon(url, confidence, false);
2141	2134	if (ret) {

		@@ -2145,34 +2138,39 @@ static const char *LegacySniffFFMPEG(const sp<DataSource> &source,
2145	2138	return ret;
2146	2139	}
2147	2140
2148		-extern "C" {
	2141	+static void FreeMeta(void *meta) {
	2142	+ if (meta != nullptr) {
	2143	+ static_cast<AMessage *>(meta)->decStrong(nullptr);
	2144	+ }
	2145	+}
2149	2146
2150		-bool SniffFFMPEG(
2151		- const sp<DataSource> &source, String8 mimeType, float confidence,
2152		- sp<AMessage> *meta) {
	2147	+static MediaExtractor::CreatorFunc
	2148	+SniffFFMPEG(
	2149	+ DataSourceBase source, float confidence, void **meta,
	2150	+ MediaExtractor::FreeMetaFunc *freeMeta) {
2153	2151
2154	2152	float newConfidence = 0.08f;
2155	2153
2156		- ALOGV("SniffFFMPEG (initial confidence: %f, mime: %s)", *confidence,
2157		- mimeType == NULL ? "unknown" : *mimeType);
	2154	+ ALOGV("SniffFFMPEG (initial confidence: %f)", *confidence);
2158	2155
2159	2156	// This is a heavyweight sniffer, don't invoke it if Stagefright knows
2160	2157	// what it is doing already.
2161		- if (mimeType != NULL && confidence != NULL) {
2162		- if (*mimeType == "application/ogg") {
2163		- return false;
2164		- }
	2158	+ if (confidence != NULL) {
2165	2159	if (*confidence > 0.8f) {
2166		- return false;
	2160	+ return NULL;
2167	2161	}
2168	2162	}
2169	2163
2170		- *meta = new AMessage;
	2164	+ AMessage *msg = new AMessage;
	2165	+
	2166	+ *meta = msg;
	2167	+ *freeMeta = FreeMeta;
	2168	+ msg->incStrong(nullptr);
2171	2169
2172		- const char container = BetterSniffFFMPEG(source, &newConfidence, meta);
	2170	+ const char *container = BetterSniffFFMPEG(source, &newConfidence, msg);
2173	2171	if (!container) {
2174	2172	ALOGW("sniff through BetterSniffFFMPEG failed, try LegacySniffFFMPEG");
2175		- container = LegacySniffFFMPEG(source, &newConfidence, *meta);
	2173	+ container = LegacySniffFFMPEG(source, &newConfidence, msg);
2176	2174	if (container) {
2177	2175	ALOGV("sniff through LegacySniffFFMPEG success");
2178	2176	}

		@@ -2182,19 +2180,18 @@ bool SniffFFMPEG(
2182	2180
2183	2181	if (container == NULL) {
2184	2182	ALOGD("SniffFFMPEG failed to sniff this source");
2185		- (*meta)->clear();
	2183	+ msg->decStrong(nullptr);
2186	2184	*meta = NULL;
2187		- return false;
	2185	+ *freeMeta = NULL;
	2186	+ return NULL;
2188	2187	}
2189	2188
2190	2189	ALOGD("ffmpeg detected media content as '%s' with confidence %.2f",
2191	2190	container, newConfidence);
2192	2191
2193		- mimeType->setTo(container);
2194		-
2195		- (*meta)->setString("extended-extractor", "extended-extractor");
2196		- (*meta)->setString("extended-extractor-subtype", "ffmpegextractor");
2197		- (*meta)->setString("extended-extractor-mime", container);
	2192	+ msg->setString("extended-extractor", "extended-extractor");
	2193	+ msg->setString("extended-extractor-subtype", "ffmpegextractor");
	2194	+ msg->setString("extended-extractor-mime", container);
2198	2195
2199	2196	//debug only
2200	2197	char value[PROPERTY_VALUE_MAX];

		@@ -2205,60 +2202,74 @@ bool SniffFFMPEG(
2205	2202	}
2206	2203
2207	2204	if (newConfidence > *confidence) {
2208		- (*meta)->setString("extended-extractor-use", "ffmpegextractor");
	2205	+ msg->setString("extended-extractor-use", "ffmpegextractor");
2209	2206	*confidence = newConfidence;
2210	2207	}
2211	2208
2212		- return true;
	2209	+ return CreateFFMPEGExtractor;
2213	2210	}
2214	2211
2215		-MediaExtractor CreateFFMPEGExtractor(const sp<DataSource> &source, const char mime, const sp<AMessage> &meta) {
	2212	+static MediaExtractor CreateFFMPEGExtractor(DataSourceBase source, void *meta) {
2216	2213	MediaExtractor *ret = NULL;
2217		- AString notuse;
2218		- if (meta.get() && meta->findString("extended-extractor", &notuse) && (
2219		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEG) \|\|
2220		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC) \|\|
2221		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_VORBIS) \|\|
2222		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_ALAC) \|\|
2223		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FLAC) \|\|
2224		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AC3) \|\|
2225		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_APE) \|\|
2226		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_DTS) \|\|
2227		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II) \|\|
2228		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RA) \|\|
2229		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_WMA) \|\|
2230		- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FFMPEG) \|\|
2231		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG4) \|\|
2232		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MOV) \|\|
2233		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MATROSKA) \|\|
2234		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_TS) \|\|
2235		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2PS) \|\|
2236		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_AVI) \|\|
2237		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_ASF) \|\|
2238		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WEBM) \|\|
2239		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WMV) \|\|
2240		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPG) \|\|
2241		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FLV) \|\|
2242		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_DIVX) \|\|
2243		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_RM) \|\|
2244		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WAV) \|\|
2245		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FLAC) \|\|
2246		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_APE) \|\|
2247		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_DTS) \|\|
2248		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MP2) \|\|
2249		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_RA) \|\|
2250		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_OGG) \|\|
2251		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_VC1) \|\|
2252		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_HEVC) \|\|
2253		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WMA) \|\|
2254		- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FFMPEG))) {
2255		- ret = new FFmpegExtractor(source, meta);
2256		- }
2257		-
2258		- ALOGD("%ssupported mime: %s", (ret ? "" : "un"), mime);
	2214	+ sp<AMessage> msg = static_cast<AMessage *>(meta);
	2215	+ AString mime;
	2216	+ if (msg.get() && msg->findString("extended-extractor-mime", &mime) && (
	2217	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_MPEG) \|\|
	2218	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_AAC) \|\|
	2219	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_VORBIS) \|\|
	2220	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_ALAC) \|\|
	2221	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_FLAC) \|\|
	2222	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_AC3) \|\|
	2223	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_APE) \|\|
	2224	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_DTS) \|\|
	2225	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II) \|\|
	2226	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_RA) \|\|
	2227	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_WMA) \|\|
	2228	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_FFMPEG) \|\|
	2229	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MPEG4) \|\|
	2230	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MOV) \|\|
	2231	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MATROSKA) \|\|
	2232	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_TS) \|\|
	2233	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MPEG2PS) \|\|
	2234	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_AVI) \|\|
	2235	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_ASF) \|\|
	2236	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_WEBM) \|\|
	2237	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_WMV) \|\|
	2238	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MPG) \|\|
	2239	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_FLV) \|\|
	2240	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_DIVX) \|\|
	2241	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_RM) \|\|
	2242	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_WAV) \|\|
	2243	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_FLAC) \|\|
	2244	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_APE) \|\|
	2245	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_DTS) \|\|
	2246	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MP2) \|\|
	2247	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_RA) \|\|
	2248	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_OGG) \|\|
	2249	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_VC1) \|\|
	2250	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_HEVC) \|\|
	2251	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_WMA) \|\|
	2252	+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_FFMPEG))) {
	2253	+ ret = new FFmpegExtractor(source, msg);
	2254	+ }
	2255	+
	2256	+ ALOGD("%ssupported mime: %s", (ret ? "" : "un"), mime.c_str());
2259	2257	return ret;
2260	2258	}
2261	2259
	2260	+extern "C" {
	2261	+
	2262	+__attribute__ ((visibility ("default")))
	2263	+MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
	2264	+ return {
	2265	+ MediaExtractor::EXTRACTORDEF_VERSION,
	2266	+ UUID("280e1e71-d08b-4d8c-ba03-d775497fc4bc"),
	2267	+ 1, // version
	2268	+ "FFMPEG Extractor",
	2269	+ SniffFFMPEG
	2270	+ };
	2271	+}
	2272	+
2262	2273	}
2263	2274
2264	2275	}; // namespace android

--- a/extractor/FFmpegExtractor.h

+++ b/extractor/FFmpegExtractor.h

		@@ -18,11 +18,11 @@
18	18
19	19	#define SUPER_EXTRACTOR_H_
20	20
	21	+#include <media/MediaExtractor.h>
	22	+#include <media/MediaSource.h>
21	23	#include <media/stagefright/foundation/ABase.h>
22		-#include <media/stagefright/MediaExtractor.h>
23	24	#include <utils/threads.h>
24	25	#include <utils/KeyedVector.h>
25		-#include <media/stagefright/MediaSource.h>
26	26
27	27	#include "utils/ffmpeg_utils.h"
28	28

		@@ -34,13 +34,13 @@ class String8;
34	34	struct FFmpegSource;
35	35
36	36	struct FFmpegExtractor : public MediaExtractor {
37		- FFmpegExtractor(const sp<DataSource> &source, const sp<AMessage> &meta);
	37	+ FFmpegExtractor(DataSourceBase *source, const sp<AMessage> &meta);
38	38
39	39	virtual size_t countTracks();
40		- virtual sp<IMediaSource> getTrack(size_t index);
41		- virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
	40	+ virtual MediaTrack* getTrack(size_t index);
	41	+ virtual status_t getTrackMetaData(MetaDataBase &meta, size_t index, uint32_t flags);
42	42
43		- virtual sp<MetaData> getMetaData();
	43	+ virtual status_t getMetaData(MetaDataBase &meta);
44	44
45	45	virtual uint32_t flags() const;
46	46

		@@ -52,7 +52,7 @@ private:
52	52
53	53	struct TrackInfo {
54	54	int mIndex; //stream index
55		- sp<MetaData> mMeta;
	55	+ MetaDataBase mMeta;
56	56	AVStream *mStream;
57	57	PacketQueue *mQueue;
58	58	};

		@@ -63,8 +63,8 @@ private:
63	63	mutable Mutex mExtractorMutex;
64	64	Condition mCondition;
65	65
66		- sp<DataSource> mDataSource;
67		- sp<MetaData> mMeta;
	66	+ DataSourceBase *mDataSource;
	67	+ MetaDataBase mMeta;
68	68	status_t mInitCheck;
69	69
70	70	char mFilename[PATH_MAX];

		@@ -112,9 +112,9 @@ private:
112	112	void setFFmpegDefaultOpts();
113	113	void printTime(int64_t time);
114	114	bool is_codec_supported(enum AVCodecID codec_id);
115		- sp<MetaData> setVideoFormat(AVStream *stream);
116		- sp<MetaData> setAudioFormat(AVStream *stream);
117		- void setDurationMetaData(AVStream *stream, sp<MetaData> &meta);
	115	+ status_t setVideoFormat(AVStream *stream, MetaDataBase &meta);
	116	+ status_t setAudioFormat(AVStream *stream, MetaDataBase &meta);
	117	+ void setDurationMetaData(AVStream *stream, MetaDataBase &meta);
118	118	int stream_component_open(int stream_index);
119	119	void stream_component_close(int stream_index);
120	120	void reachedEOS(enum AVMediaType media_type);

		@@ -134,6 +134,7 @@ private:
134	134	DISALLOW_EVIL_CONSTRUCTORS(FFmpegExtractor);
135	135	};
136	136
	137	+/*
137	138	extern "C" {
138	139
139	140	static const char findMatchingContainer(const char name);

		@@ -146,6 +147,7 @@ MediaExtractor* CreateFFMPEGExtractor(const sp<DataSource> &source,
146	147	const char *mime, const sp<AMessage> &meta);
147	148
148	149	}
	150	+*/
149	151
150	152	} // namespace android
151	153

--- a/omx/Android.mk

+++ b/omx/Android.mk

		@@ -14,6 +14,7 @@ LOCAL_C_INCLUDES += \
14	14	LOCAL_SHARED_LIBRARIES += \
15	15	libdl \
16	16	libffmpeg_utils \
	17	+ android.hidl.memory@1.0 \
17	18	$(if $(filter true,$(BOARD_USE_LIBAV)),libavresample,libswresample) \
18	19	liblog \
19	20	libnativewindow \

--- a/omx/FFmpegOMXPlugin.cpp

+++ b/omx/FFmpegOMXPlugin.cpp

		@@ -85,8 +85,6 @@ OMX_ERRORTYPE FFmpegOMXPlugin::destroyComponentInstance(
85	85
86	86	me->prepareForDestruction();
87	87
88		- void *libHandle = me->libHandle();
89		-
90	88	CHECK_EQ(me->getStrongCount(), 1);
91	89	me->decStrong(this);
92	90	me = NULL;

--- a/omx/SoftFFmpegVideo.cpp

+++ b/omx/SoftFFmpegVideo.cpp

		@@ -515,7 +515,7 @@ void SoftFFmpegVideo::initPacket(AVPacket *pkt,
515	515	}
516	516
517	517	int32_t SoftFFmpegVideo::decodeVideo() {
518		- int len = 0, err = 0;
	518	+ int err = 0;
519	519	int gotPic = false;
520	520	int32_t ret = ERR_OK;
521	521	List<BufferInfo *> &inQueue = getPortQueue(kInputPortIndex);

		@@ -591,8 +591,10 @@ int32_t SoftFFmpegVideo::drainOneOutputBuffer() {
591	591
592	592	uint32_t bufferWidth = outputBufferWidth();
593	593	uint32_t bufferHeight = outputBufferHeight();
	594	+#if DEBUG_FRM
594	595	uint32_t frameWidth = mFrame->width;
595	596	uint32_t frameHeight = mFrame->height;
	597	+#endif
596	598
597	599	data[0] = dst;
598	600	data[1] = dst + bufferWidth * bufferHeight;

		@@ -601,8 +603,10 @@ int32_t SoftFFmpegVideo::drainOneOutputBuffer() {
601	603	linesize[1] = bufferWidth / 2;
602	604	linesize[2] = bufferWidth / 2;
603	605
	606	+#if DEBUG_FRM
604	607	ALOGD("drainOneOutputBuffer: frame_width=%d frame_height=%d buffer_width=%d buffer_height=%d ctx_width=%d ctx_height=%d mIsAdaptive=%d",
605	608	frameWidth, frameHeight, bufferWidth, bufferHeight, mCtx->width, mCtx->height, mIsAdaptive);
	609	+#endif
606	610
607	611	int sws_flags = SWS_BICUBIC;
608	612	mImgConvertCtx = sws_getCachedContext(mImgConvertCtx,

--- a/utils/Android.mk

+++ b/utils/Android.mk

		@@ -10,7 +10,10 @@ LOCAL_SRC_FILES := \
10	10
11	11	LOCAL_SHARED_LIBRARIES += \
12	12	liblog \
13		- libmedia
	13	+ libmediaextractor \
	14	+ libstagefright
	15	+
	16	+LOCAL_STATIC_LIBRARIES += libstagefright_metadatautils
14	17
15	18	LOCAL_MODULE := libffmpeg_utils
16	19

--- a/utils/codec_utils.cpp

+++ b/utils/codec_utils.cpp

		@@ -28,10 +28,11 @@ extern "C" {
28	28	#include <utils/Errors.h>
29	29	#include <media/stagefright/foundation/ABitReader.h>
30	30	#include <media/stagefright/foundation/ADebug.h>
	31	+#include <media/stagefright/foundation/avc_utils.h>
31	32	#include <media/stagefright/MediaDefs.h>
32	33	#include <media/stagefright/MediaErrors.h>
33	34	#include <media/stagefright/MetaData.h>
34		-#include "include/avc_utils.h"
	35	+#include <media/stagefright/MetaDataUtils.h>
35	36
36	37	#include "codec_utils.h"
37	38

		@@ -83,7 +84,7 @@ static sp<ABuffer> MakeMPEGVideoESDS(const sp<ABuffer> &csd) {
83	84	//http://msdn.microsoft.com/en-us/library/dd757808(v=vs.85).aspx
84	85
85	86	// H.264 bitstream without start codes.
86		-sp<MetaData> setAVCFormat(AVCodecContext *avctx)
	87	+status_t setAVCFormat(AVCodecContext *avctx, MetaDataBase &meta)
87	88	{
88	89	ALOGV("AVC");
89	90

		@@ -99,26 +100,26 @@ sp<MetaData> setAVCFormat(AVCodecContext *avctx)
99	100	avctx->height = height;
100	101	}
101	102
102		- sp<MetaData> meta = new MetaData;
103		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
104		- meta->setData(kKeyAVCC, kTypeAVCC, avctx->extradata, avctx->extradata_size);
	103	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
	104	+ meta.setData(kKeyAVCC, kTypeAVCC, avctx->extradata, avctx->extradata_size);
105	105
106		- return meta;
	106	+ return OK;
107	107	}
108	108
109	109	// H.264 bitstream with start codes.
110		-sp<MetaData> setH264Format(AVCodecContext *avctx)
	110	+status_t setH264Format(AVCodecContext *avctx, MetaDataBase &meta)
111	111	{
112	112	ALOGV("H264");
113	113
114	114	CHECK_NE((int)avctx->extradata[0], 1); //configurationVersion
115	115
116		- sp<ABuffer> buffer = new ABuffer(avctx->extradata_size);
117		- memcpy(buffer->data(), avctx->extradata, avctx->extradata_size);
118		- return MakeAVCCodecSpecificData(buffer);
	116	+ if (!MakeAVCCodecSpecificData(meta, avctx->extradata, avctx->extradata_size))
	117	+ return UNKNOWN_ERROR;
	118	+
	119	+ return OK;
119	120	}
120	121
121		-sp<MetaData> setMPEG4Format(AVCodecContext *avctx)
	122	+status_t setMPEG4Format(AVCodecContext *avctx, MetaDataBase &meta)
122	123	{
123	124	ALOGV("MPEG4");
124	125

		@@ -126,30 +127,28 @@ sp<MetaData> setMPEG4Format(AVCodecContext *avctx)
126	127	memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
127	128	sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
128	129
129		- sp<MetaData> meta = new MetaData;
130		- meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
	130	+ meta.setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
131	131
132	132	int divxVersion = getDivXVersion(avctx);
133	133	if (divxVersion >= 0) {
134		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_DIVX);
135		- meta->setInt32(kKeyDivXVersion, divxVersion);
	134	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_DIVX);
	135	+ meta.setInt32(kKeyDivXVersion, divxVersion);
136	136	} else {
137		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
	137	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
138	138	}
139		- return meta;
	139	+ return OK;
140	140	}
141	141
142		-sp<MetaData> setH263Format(AVCodecContext *avctx __unused)
	142	+status_t setH263Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
143	143	{
144	144	ALOGV("H263");
145	145
146		- sp<MetaData> meta = new MetaData;
147		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
	146	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
148	147
149		- return meta;
	148	+ return OK;
150	149	}
151	150
152		-sp<MetaData> setMPEG2VIDEOFormat(AVCodecContext *avctx)
	151	+status_t setMPEG2VIDEOFormat(AVCodecContext *avctx, MetaDataBase &meta)
153	152	{
154	153	ALOGV("MPEG%uVIDEO", avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 2 : 1);
155	154

		@@ -157,160 +156,146 @@ sp<MetaData> setMPEG2VIDEOFormat(AVCodecContext *avctx)
157	156	memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
158	157	sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
159	158
160		- sp<MetaData> meta = new MetaData;
161		- meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
162		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
	159	+ meta.setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
	160	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
163	161
164		- return meta;
	162	+ return OK;
165	163	}
166	164
167		-sp<MetaData> setVC1Format(AVCodecContext *avctx)
	165	+status_t setVC1Format(AVCodecContext *avctx, MetaDataBase &meta)
168	166	{
169	167	ALOGV("VC1");
170	168
171		- sp<MetaData> meta = new MetaData;
172		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
173		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	169	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
	170	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
174	171
175		- return meta;
	172	+ return OK;
176	173	}
177	174
178		-sp<MetaData> setWMV1Format(AVCodecContext *avctx __unused)
	175	+status_t setWMV1Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
179	176	{
180	177	ALOGV("WMV1");
181	178
182		- sp<MetaData> meta = new MetaData;
183		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
184		- meta->setInt32(kKeyWMVVersion, kTypeWMVVer_7);
	179	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
	180	+ meta.setInt32(kKeyWMVVersion, kTypeWMVVer_7);
185	181
186		- return meta;
	182	+ return OK;
187	183	}
188	184
189		-sp<MetaData> setWMV2Format(AVCodecContext *avctx)
	185	+status_t setWMV2Format(AVCodecContext *avctx, MetaDataBase &meta)
190	186	{
191	187	ALOGV("WMV2");
192	188
193		- sp<MetaData> meta = new MetaData;
194		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
195		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
196		- meta->setInt32(kKeyWMVVersion, kTypeWMVVer_8);
	189	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
	190	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	191	+ meta.setInt32(kKeyWMVVersion, kTypeWMVVer_8);
197	192
198		- return meta;
	193	+ return OK;
199	194	}
200	195
201		-sp<MetaData> setWMV3Format(AVCodecContext *avctx)
	196	+status_t setWMV3Format(AVCodecContext *avctx, MetaDataBase &meta)
202	197	{
203	198	ALOGV("WMV3");
204	199
205		- sp<MetaData> meta = new MetaData;
206		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
207		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
208		- meta->setInt32(kKeyWMVVersion, kTypeWMVVer_9);
	200	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
	201	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	202	+ meta.setInt32(kKeyWMVVersion, kTypeWMVVer_9);
209	203
210		- return meta;
	204	+ return OK;
211	205	}
212	206
213		-sp<MetaData> setRV20Format(AVCodecContext *avctx)
	207	+status_t setRV20Format(AVCodecContext *avctx, MetaDataBase &meta)
214	208	{
215	209	ALOGV("RV20");
216	210
217		- sp<MetaData> meta = new MetaData;
218		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
219		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
220		- meta->setInt32(kKeyRVVersion, kTypeRVVer_G2); //http://en.wikipedia.org/wiki/RealVide
	211	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
	212	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	213	+ meta.setInt32(kKeyRVVersion, kTypeRVVer_G2); //http://en.wikipedia.org/wiki/RealVide
221	214
222		- return meta;
	215	+ return OK;
223	216	}
224	217
225		-sp<MetaData> setRV30Format(AVCodecContext *avctx)
	218	+status_t setRV30Format(AVCodecContext *avctx, MetaDataBase &meta)
226	219	{
227	220	ALOGV("RV30");
228	221
229		- sp<MetaData> meta = new MetaData;
230		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
231		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
232		- meta->setInt32(kKeyRVVersion, kTypeRVVer_8); //http://en.wikipedia.org/wiki/RealVide
	222	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
	223	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	224	+ meta.setInt32(kKeyRVVersion, kTypeRVVer_8); //http://en.wikipedia.org/wiki/RealVide
233	225
234		- return meta;
	226	+ return OK;
235	227	}
236	228
237		-sp<MetaData> setRV40Format(AVCodecContext *avctx)
	229	+status_t setRV40Format(AVCodecContext *avctx, MetaDataBase &meta)
238	230	{
239	231	ALOGV("RV40");
240	232
241		- sp<MetaData> meta = new MetaData;
242		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
243		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
244		- meta->setInt32(kKeyRVVersion, kTypeRVVer_9); //http://en.wikipedia.org/wiki/RealVide
	233	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
	234	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	235	+ meta.setInt32(kKeyRVVersion, kTypeRVVer_9); //http://en.wikipedia.org/wiki/RealVide
245	236
246		- return meta;
	237	+ return OK;
247	238	}
248	239
249		-sp<MetaData> setFLV1Format(AVCodecContext *avctx)
	240	+status_t setFLV1Format(AVCodecContext *avctx, MetaDataBase &meta)
250	241	{
251	242	ALOGV("FLV1(Sorenson H263)");
252	243
253		- sp<MetaData> meta = new MetaData;
254		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
255		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	244	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
	245	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
256	246
257		- return meta;
	247	+ return OK;
258	248	}
259	249
260		-sp<MetaData> setHEVCFormat(AVCodecContext *avctx)
	250	+status_t setHEVCFormat(AVCodecContext *avctx, MetaDataBase &meta)
261	251	{
262	252	ALOGV("HEVC");
263	253
264		- sp<MetaData> meta = new MetaData;
265		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
266		- meta->setData(kKeyHVCC, kTypeHVCC, avctx->extradata, avctx->extradata_size);
	254	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
	255	+ meta.setData(kKeyHVCC, kTypeHVCC, avctx->extradata, avctx->extradata_size);
267	256
268		- return meta;
	257	+ return OK;
269	258	}
270	259
271		-sp<MetaData> setVP8Format(AVCodecContext *avctx __unused)
	260	+status_t setVP8Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
272	261	{
273	262	ALOGV("VP8");
274	263
275		- sp<MetaData> meta = new MetaData;
276		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP8);
	264	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP8);
277	265
278		- return meta;
	266	+ return OK;
279	267	}
280	268
281		-sp<MetaData> setVP9Format(AVCodecContext *avctx __unused)
	269	+status_t setVP9Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
282	270	{
283	271	ALOGV("VP9");
284	272
285		- sp<MetaData> meta = new MetaData;
286		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP9);
	273	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP9);
287	274
288		- return meta;
	275	+ return OK;
289	276	}
290	277
291	278	//audio
292	279
293		-sp<MetaData> setMP2Format(AVCodecContext *avctx __unused)
	280	+status_t setMP2Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
294	281	{
295	282	ALOGV("MP2");
296	283
297		- sp<MetaData> meta = new MetaData;
298		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
	284	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
299	285
300		- return meta;
	286	+ return OK;
301	287	}
302	288
303		-sp<MetaData> setMP3Format(AVCodecContext *avctx __unused)
	289	+status_t setMP3Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
304	290	{
305	291	ALOGV("MP3");
306	292
307		- sp<MetaData> meta = new MetaData;
308		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
	293	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
309	294
310		- return meta;
	295	+ return OK;
311	296	}
312	297
313		-sp<MetaData> setVORBISFormat(AVCodecContext *avctx)
	298	+status_t setVORBISFormat(AVCodecContext *avctx, MetaDataBase &meta)
314	299	{
315	300	ALOGV("VORBIS");
316	301

		@@ -320,143 +305,132 @@ sp<MetaData> setVORBISFormat(AVCodecContext *avctx)
320	305	avctx->extradata_size, 30,
321	306	header_start, header_len) < 0) {
322	307	ALOGE("vorbis extradata corrupt.");
323		- return NULL;
	308	+ return UNKNOWN_ERROR;
324	309	}
325	310
326		- sp<MetaData> meta = new MetaData;
327		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
	311	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
328	312	//identification header
329		- meta->setData(kKeyVorbisInfo, 0, header_start[0], header_len[0]);
	313	+ meta.setData(kKeyVorbisInfo, 0, header_start[0], header_len[0]);
330	314	//setup header
331		- meta->setData(kKeyVorbisBooks, 0, header_start[2], header_len[2]);
	315	+ meta.setData(kKeyVorbisBooks, 0, header_start[2], header_len[2]);
332	316
333		- return meta;
	317	+ return OK;
334	318	}
335	319
336		-sp<MetaData> setAC3Format(AVCodecContext *avctx __unused)
	320	+status_t setAC3Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
337	321	{
338	322	ALOGV("AC3");
339	323
340		- sp<MetaData> meta = new MetaData;
341		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
	324	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
342	325
343		- return meta;
	326	+ return OK;
344	327	}
345	328
346		-sp<MetaData> setAACFormat(AVCodecContext *avctx)
	329	+status_t setAACFormat(AVCodecContext *avctx, MetaDataBase &meta)
347	330	{
348	331	ALOGV("AAC");
349	332
350		- sp<MetaData> meta = new MetaData;
351		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
352		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
353		- meta->setInt32(kKeyAACAOT, avctx->profile + 1);
354		- return meta;
	333	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
	334	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	335	+ meta.setInt32(kKeyAACAOT, avctx->profile + 1);
	336	+
	337	+ return OK;
355	338	}
356	339
357		-sp<MetaData> setWMAV1Format(AVCodecContext *avctx)
	340	+status_t setWMAV1Format(AVCodecContext *avctx, MetaDataBase &meta)
358	341	{
359	342	ALOGV("WMAV1");
360	343
361		- sp<MetaData> meta = new MetaData;
362		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
363		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
364		- meta->setInt32(kKeyWMAVersion, kTypeWMA); //FIXME version?
	344	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
	345	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	346	+ meta.setInt32(kKeyWMAVersion, kTypeWMA); //FIXME version?
365	347
366		- return meta;
	348	+ return OK;
367	349	}
368	350
369		-sp<MetaData> setWMAV2Format(AVCodecContext *avctx)
	351	+status_t setWMAV2Format(AVCodecContext *avctx, MetaDataBase &meta)
370	352	{
371	353	ALOGV("WMAV2");
372	354
373		- sp<MetaData> meta = new MetaData;
374		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
375		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
376		- meta->setInt32(kKeyWMAVersion, kTypeWMA);
	355	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
	356	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	357	+ meta.setInt32(kKeyWMAVersion, kTypeWMA);
377	358
378		- return meta;
	359	+ return OK;
379	360	}
380	361
381		-sp<MetaData> setWMAProFormat(AVCodecContext *avctx)
	362	+status_t setWMAProFormat(AVCodecContext *avctx, MetaDataBase &meta)
382	363	{
383	364	ALOGV("WMAPro");
384	365
385		- sp<MetaData> meta = new MetaData;
386		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
387		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
388		- meta->setInt32(kKeyWMAVersion, kTypeWMAPro);
	366	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
	367	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	368	+ meta.setInt32(kKeyWMAVersion, kTypeWMAPro);
389	369
390		- return meta;
	370	+ return OK;
391	371	}
392	372
393		-sp<MetaData> setWMALossLessFormat(AVCodecContext *avctx)
	373	+status_t setWMALossLessFormat(AVCodecContext *avctx, MetaDataBase &meta)
394	374	{
395	375	ALOGV("WMALOSSLESS");
396	376
397		- sp<MetaData> meta = new MetaData;
398		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
399		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
400		- meta->setInt32(kKeyWMAVersion, kTypeWMALossLess);
	377	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
	378	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	379	+ meta.setInt32(kKeyWMAVersion, kTypeWMALossLess);
401	380
402		- return meta;
	381	+ return OK;
403	382	}
404	383
405		-sp<MetaData> setRAFormat(AVCodecContext *avctx)
	384	+status_t setRAFormat(AVCodecContext *avctx, MetaDataBase &meta)
406	385	{
407	386	ALOGV("COOK");
408	387
409		- sp<MetaData> meta = new MetaData;
410		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
411		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	388	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
	389	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
412	390
413		- return meta;
	391	+ return OK;
414	392	}
415	393
416		-sp<MetaData> setALACFormat(AVCodecContext *avctx)
	394	+status_t setALACFormat(AVCodecContext *avctx, MetaDataBase &meta)
417	395	{
418	396	ALOGV("ALAC");
419	397
420		- sp<MetaData> meta = new MetaData;
421		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_ALAC);
422		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	398	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_ALAC);
	399	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
423	400
424		- return meta;
	401	+ return OK;
425	402	}
426	403
427		-sp<MetaData> setAPEFormat(AVCodecContext *avctx)
	404	+status_t setAPEFormat(AVCodecContext *avctx, MetaDataBase &meta)
428	405	{
429	406	ALOGV("APE");
430	407
431		- sp<MetaData> meta = new MetaData;
432		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
433		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	408	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
	409	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
434	410
435		- return meta;
	411	+ return OK;
436	412	}
437	413
438		-sp<MetaData> setDTSFormat(AVCodecContext *avctx)
	414	+status_t setDTSFormat(AVCodecContext *avctx, MetaDataBase &meta)
439	415	{
440	416	ALOGV("DTS");
441	417
442		- sp<MetaData> meta = new MetaData;
443		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
444		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	418	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
	419	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
445	420
446		- return meta;
	421	+ return OK;
447	422	}
448	423
449		-sp<MetaData> setFLACFormat(AVCodecContext *avctx)
	424	+status_t setFLACFormat(AVCodecContext *avctx, MetaDataBase &meta)
450	425	{
451	426	ALOGV("FLAC");
452	427
453		- sp<MetaData> meta = new MetaData;
454		- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
455		- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
	428	+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
	429	+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
456	430
457	431	if (avctx->extradata_size < 10) {
458	432	ALOGE("Invalid extradata in FLAC file! (size=%d)", avctx->extradata_size);
459		- return meta;
	433	+ return UNKNOWN_ERROR;
460	434	}
461	435
462	436	ABitReader br(avctx->extradata, avctx->extradata_size);

		@@ -465,12 +439,12 @@ sp<MetaData> setFLACFormat(AVCodecContext *avctx)
465	439	int32_t minFrameSize = br.getBits(24);
466	440	int32_t maxFrameSize = br.getBits(24);
467	441
468		- meta->setInt32('mibs', minBlockSize);
469		- meta->setInt32('mabs', maxBlockSize);
470		- meta->setInt32('mifs', minFrameSize);
471		- meta->setInt32('mafs', maxFrameSize);
	442	+ meta.setInt32('mibs', minBlockSize);
	443	+ meta.setInt32('mabs', maxBlockSize);
	444	+ meta.setInt32('mifs', minFrameSize);
	445	+ meta.setInt32('mafs', maxFrameSize);
472	446
473		- return meta;
	447	+ return OK;
474	448	}
475	449
476	450	//Convert H.264 NAL format to annex b

		@@ -528,8 +502,8 @@ int getDivXVersion(AVCodecContext *avctx)
528	502	return -1;
529	503	}
530	504
531		-status_t parseMetadataTags(AVFormatContext *ctx, const sp<MetaData> &meta) {
532		- if (meta == NULL \|\| ctx == NULL) {
	505	+status_t parseMetadataTags(AVFormatContext *ctx, MetaDataBase &meta) {
	506	+ if (ctx == NULL) {
533	507	return NO_INIT;
534	508	}
535	509

		@@ -565,7 +539,7 @@ status_t parseMetadataTags(AVFormatContext *ctx, const sp<MetaData> &meta) {
565	539	AVDictionaryEntry *entry = av_dict_get(dict, kMap[i].from, NULL, 0);
566	540	if (entry != NULL) {
567	541	ALOGV("found key %s with value %s", entry->key, entry->value);
568		- meta->setCString(kMap[i].to, entry->value);
	542	+ meta.setCString(kMap[i].to, entry->value);
569	543	}
570	544	}
571	545

		@@ -585,8 +559,8 @@ status_t parseMetadataTags(AVFormatContext *ctx, const sp<MetaData> &meta) {
585	559	}
586	560	if (mime != NULL) {
587	561	ALOGV("found albumart in stream %zu with type %s len %d", i, mime, pkt.size);
588		- meta->setData(kKeyAlbumArt, MetaData::TYPE_NONE, pkt.data, pkt.size);
589		- meta->setCString(kKeyAlbumArtMIME, mime);
	562	+ meta.setData(kKeyAlbumArt, MetaData::TYPE_NONE, pkt.data, pkt.size);
	563	+ meta.setCString(kKeyAlbumArtMIME, mime);
590	564	}
591	565	}
592	566	}

--- a/utils/codec_utils.h

+++ b/utils/codec_utils.h

		@@ -29,37 +29,37 @@
29	29	namespace android {
30	30
31	31	//video
32		-sp<MetaData> setAVCFormat(AVCodecContext *avctx);
33		-sp<MetaData> setH264Format(AVCodecContext *avctx);
34		-sp<MetaData> setMPEG4Format(AVCodecContext *avctx);
35		-sp<MetaData> setH263Format(AVCodecContext *avctx);
36		-sp<MetaData> setMPEG2VIDEOFormat(AVCodecContext *avctx);
37		-sp<MetaData> setVC1Format(AVCodecContext *avctx);
38		-sp<MetaData> setWMV1Format(AVCodecContext *avctx);
39		-sp<MetaData> setWMV2Format(AVCodecContext *avctx);
40		-sp<MetaData> setWMV3Format(AVCodecContext *avctx);
41		-sp<MetaData> setRV20Format(AVCodecContext *avctx);
42		-sp<MetaData> setRV30Format(AVCodecContext *avctx);
43		-sp<MetaData> setRV40Format(AVCodecContext *avctx);
44		-sp<MetaData> setFLV1Format(AVCodecContext *avctx);
45		-sp<MetaData> setHEVCFormat(AVCodecContext *avctx);
46		-sp<MetaData> setVP8Format(AVCodecContext *avctx);
47		-sp<MetaData> setVP9Format(AVCodecContext *avctx);
	32	+status_t setAVCFormat(AVCodecContext *avctx, MetaDataBase &meta);
	33	+status_t setH264Format(AVCodecContext *avctx, MetaDataBase &meta);
	34	+status_t setMPEG4Format(AVCodecContext *avctx, MetaDataBase &meta);
	35	+status_t setH263Format(AVCodecContext *avctx, MetaDataBase &meta);
	36	+status_t setMPEG2VIDEOFormat(AVCodecContext *avctx, MetaDataBase &meta);
	37	+status_t setVC1Format(AVCodecContext *avctx, MetaDataBase &meta);
	38	+status_t setWMV1Format(AVCodecContext *avctx, MetaDataBase &meta);
	39	+status_t setWMV2Format(AVCodecContext *avctx, MetaDataBase &meta);
	40	+status_t setWMV3Format(AVCodecContext *avctx, MetaDataBase &meta);
	41	+status_t setRV20Format(AVCodecContext *avctx, MetaDataBase &meta);
	42	+status_t setRV30Format(AVCodecContext *avctx, MetaDataBase &meta);
	43	+status_t setRV40Format(AVCodecContext *avctx, MetaDataBase &meta);
	44	+status_t setFLV1Format(AVCodecContext *avctx, MetaDataBase &meta);
	45	+status_t setHEVCFormat(AVCodecContext *avctx, MetaDataBase &meta);
	46	+status_t setVP8Format(AVCodecContext *avctx, MetaDataBase &meta);
	47	+status_t setVP9Format(AVCodecContext *avctx, MetaDataBase &meta);
48	48	//audio
49		-sp<MetaData> setMP2Format(AVCodecContext *avctx);
50		-sp<MetaData> setMP3Format(AVCodecContext *avctx);
51		-sp<MetaData> setVORBISFormat(AVCodecContext *avctx);
52		-sp<MetaData> setAC3Format(AVCodecContext *avctx);
53		-sp<MetaData> setAACFormat(AVCodecContext *avctx);
54		-sp<MetaData> setWMAV1Format(AVCodecContext *avctx);
55		-sp<MetaData> setWMAV2Format(AVCodecContext *avctx);
56		-sp<MetaData> setWMAProFormat(AVCodecContext *avctx);
57		-sp<MetaData> setWMALossLessFormat(AVCodecContext *avctx);
58		-sp<MetaData> setRAFormat(AVCodecContext *avctx);
59		-sp<MetaData> setAPEFormat(AVCodecContext *avctx);
60		-sp<MetaData> setDTSFormat(AVCodecContext *avctx);
61		-sp<MetaData> setFLACFormat(AVCodecContext *avctx);
62		-sp<MetaData> setALACFormat(AVCodecContext *avctx);
	49	+status_t setMP2Format(AVCodecContext *avctx, MetaDataBase &meta);
	50	+status_t setMP3Format(AVCodecContext *avctx, MetaDataBase &meta);
	51	+status_t setVORBISFormat(AVCodecContext *avctx, MetaDataBase &meta);
	52	+status_t setAC3Format(AVCodecContext *avctx, MetaDataBase &meta);
	53	+status_t setAACFormat(AVCodecContext *avctx, MetaDataBase &meta);
	54	+status_t setWMAV1Format(AVCodecContext *avctx, MetaDataBase &meta);
	55	+status_t setWMAV2Format(AVCodecContext *avctx, MetaDataBase &meta);
	56	+status_t setWMAProFormat(AVCodecContext *avctx, MetaDataBase &meta);
	57	+status_t setWMALossLessFormat(AVCodecContext *avctx, MetaDataBase &meta);
	58	+status_t setRAFormat(AVCodecContext *avctx, MetaDataBase &meta);
	59	+status_t setAPEFormat(AVCodecContext *avctx, MetaDataBase &meta);
	60	+status_t setDTSFormat(AVCodecContext *avctx, MetaDataBase &meta);
	61	+status_t setFLACFormat(AVCodecContext *avctx, MetaDataBase &meta);
	62	+status_t setALACFormat(AVCodecContext *avctx, MetaDataBase &meta);
63	63
64	64	//Convert H.264 NAL format to annex b
65	65	status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,

		@@ -67,7 +67,7 @@ status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,
67	67
68	68	int getDivXVersion(AVCodecContext *avctx);
69	69
70		-status_t parseMetadataTags(AVFormatContext *ctx, const sp<MetaData> &meta);
	70	+status_t parseMetadataTags(AVFormatContext *ctx, MetaDataBase &meta);
71	71
72	72	AudioEncoding sampleFormatToEncoding(AVSampleFormat fmt);
73	73	AVSampleFormat encodingToSampleFormat(AudioEncoding encoding);

--- a/utils/ffmpeg_source.cpp

+++ b/utils/ffmpeg_source.cpp

		@@ -20,7 +20,7 @@
20	20	#include <stdlib.h>
21	21	#include "ffmpeg_source.h"
22	22
23		-#include <media/stagefright/DataSource.h>
	23	+#include <media/DataSourceBase.h>
24	24
25	25	extern "C" {
26	26

		@@ -34,14 +34,14 @@ namespace android {
34	34	class FFSource
35	35	{
36	36	public:
37		- void set(DataSource *s) { mSource = s; }
	37	+ void set(DataSourceBase *s) { mSource = s; }
38	38	int init_check();
39	39	int read(unsigned char *buf, size_t size);
40	40	int64_t seek(int64_t pos);
41	41	off64_t getSize();
42	42
43	43	protected:
44		- sp<DataSource> mSource;
	44	+ DataSourceBase *mSource;
45	45	int64_t mOffset;
46	46	};
47	47

		@@ -93,9 +93,9 @@ off64_t FFSource::getSize()
93	93
94	94	static int android_open(URLContext h, const char url, int flags __unused)
95	95	{
96		- // the url in form of "android-source:<DataSource Ptr>",
97		- // the DataSource Pointer passed by the ffmpeg extractor
98		- DataSource *source = NULL;
	96	+ // the url in form of "android-source:<DataSourceBase Ptr>",
	97	+ // the DataSourceBase Pointer passed by the ffmpeg extractor
	98	+ DataSourceBase *source = NULL;
99	99	char url_check[PATH_MAX] = {0};
100	100
101	101	ALOGV("android source begin open");

		@@ -117,14 +117,14 @@ static int android_open(URLContext h, const char url, int flags __unused)
117	117
118	118	if (strcmp(url_check, url) != 0) {
119	119
120		- String8 uri = source->getUri();
121		- if (!uri.string()) {
	120	+ char uri[PATH_MAX] = {0};
	121	+ if (!source->getUri(uri, sizeof(uri))) {
122	122	ALOGE("ffmpeg open data source error! (source uri)");
123	123	return -1;
124	124	}
125	125
126	126	snprintf(url_check, sizeof(url_check), "android-source:%p\|file:%s",
127		- source, uri.string());
	127	+ source, uri);
128	128
129	129	if (strcmp(url_check, url) != 0) {
130	130	ALOGE("ffmpeg open data source error! (url check)");

--- a/utils/ffmpeg_utils.cpp

+++ b/utils/ffmpeg_utils.cpp

		@@ -44,10 +44,6 @@ extern "C" {
44	44	// log
45	45	static int flags;
46	46
47		-// dummy
48		-const char program_name[] = "dummy";
49		-const int program_birth_year = 2012;
50		-
51	47	// init ffmpeg
52	48	static pthread_mutex_t s_init_mutex = PTHREAD_MUTEX_INITIALIZER;
53	49	static int s_ref_count = 0;

		@@ -72,7 +68,6 @@ void nam_av_log_callback(void* ptr, int level, const char* fmt, va_list vl)
72	68	static int count;
73	69	static char prev[1024];
74	70	char line[1024];
75		- static int is_atty;
76	71
77	72	if (level > av_log_get_level())
78	73	return;

Show on old repository browser