Merge changes from topic "ViLTE-IMP" am: 557ec27958 (ca0a9a91) · Commits · e / os / android_frameworks_av

media/libstagefright/rtsp/AHEVCAssembler.cpp

0 → 100644

+426 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#define LOG_NDEBUG 0
		#define LOG_TAG "AHEVCAssembler"
		#include <utils/Log.h>

		#include "AHEVCAssembler.h"

		#include "ARTPSource.h"

		#include <media/stagefright/foundation/ABuffer.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/foundation/AMessage.h>
		#include <media/stagefright/foundation/hexdump.h>

		#include <stdint.h>

		#define H265_NALU_MASK 0x3F
		#define H265_NALU_VPS 0x20
		#define H265_NALU_SPS 0x21
		#define H265_NALU_PPS 0x22
		#define H265_NALU_AP 0x30
		#define H265_NALU_FU 0x31
		#define H265_NALU_PACI 0x32


		namespace android {

		// static
		AHEVCAssembler::AHEVCAssembler(const sp<AMessage> &notify)
		: mNotifyMsg(notify),
		mAccessUnitRTPTime(0),
		mNextExpectedSeqNoValid(false),
		mNextExpectedSeqNo(0),
		mAccessUnitDamaged(false) {

		ALOGV("Constructor");
		}

		AHEVCAssembler::~AHEVCAssembler() {
		}

		ARTPAssembler::AssemblyStatus AHEVCAssembler::addNALUnit(
		const sp<ARTPSource> &source) {
		List<sp<ABuffer> > *queue = source->queue();

		if (queue->empty()) {
		return NOT_ENOUGH_DATA;
		}

		sp<ABuffer> buffer = *queue->begin();
		int32_t rtpTime;
		CHECK(buffer->meta()->findInt32("rtp-time", &rtpTime));
		int64_t startTime = source->mFirstSysTime / 1000;
		int64_t nowTime = ALooper::GetNowUs() / 1000;
		int64_t playedTime = nowTime - startTime;
		int32_t playedTimeRtp = source->mFirstRtpTime +
		(((uint32_t)playedTime) * (source->mClockRate / 1000));
		int32_t expiredTimeInJb = rtpTime + (source->mClockRate / 5);
		bool isExpired = expiredTimeInJb <= (playedTimeRtp);
		ALOGV("start=%lld, now=%lld, played=%lld", (long long)startTime,
		(long long)nowTime, (long long)playedTime);
		ALOGV("rtp-time(JB)=%d, played-rtp-time(JB)=%d, expired-rtp-time(JB)=%d isExpired=%d",
		rtpTime, playedTimeRtp, expiredTimeInJb, isExpired);

		if (!isExpired) {
		ALOGV("buffering in jitter buffer.");
		return NOT_ENOUGH_DATA;
		}

		if (mNextExpectedSeqNoValid) {
		List<sp<ABuffer> >::iterator it = queue->begin();
		while (it != queue->end()) {
		if ((uint32_t)(*it)->int32Data() >= mNextExpectedSeqNo) {
		break;
		}

		it = queue->erase(it);
		}

		if (queue->empty()) {
		return NOT_ENOUGH_DATA;
		}
		}

		if (!mNextExpectedSeqNoValid) {
		mNextExpectedSeqNoValid = true;
		mNextExpectedSeqNo = (uint32_t)buffer->int32Data();
		} else if ((uint32_t)buffer->int32Data() != mNextExpectedSeqNo) {
		ALOGV("Not the sequence number I expected");

		return WRONG_SEQUENCE_NUMBER;
		}

		const uint8_t *data = buffer->data();
		size_t size = buffer->size();

		if (size < 1 \|\| (data[0] & 0x80)) {
		// Corrupt.

		ALOGV("Ignoring corrupt buffer.");
		queue->erase(queue->begin());

		++mNextExpectedSeqNo;
		return MALFORMED_PACKET;
		}

		unsigned nalType = (data[0] >> 1) & H265_NALU_MASK;
		if (nalType > 0 && nalType < H265_NALU_AP) {
		addSingleNALUnit(buffer);
		queue->erase(queue->begin());
		++mNextExpectedSeqNo;
		return OK;
		} else if (nalType == H265_NALU_FU) {
		// FU-A
		return addFragmentedNALUnit(queue);
		} else if (nalType == H265_NALU_AP) {
		// STAP-A
		bool success = addSingleTimeAggregationPacket(buffer);
		queue->erase(queue->begin());
		++mNextExpectedSeqNo;

		return success ? OK : MALFORMED_PACKET;
		} else if (nalType == 0) {
		ALOGV("Ignoring undefined nal type.");

		queue->erase(queue->begin());
		++mNextExpectedSeqNo;

		return OK;
		} else {
		ALOGV("Ignoring unsupported buffer (nalType=%d)", nalType);

		queue->erase(queue->begin());
		++mNextExpectedSeqNo;

		return MALFORMED_PACKET;
		}
		}

		void AHEVCAssembler::addSingleNALUnit(const sp<ABuffer> &buffer) {
		ALOGV("addSingleNALUnit of size %zu", buffer->size());
		#if !LOG_NDEBUG
		hexdump(buffer->data(), buffer->size());
		#endif

		uint32_t rtpTime;
		CHECK(buffer->meta()->findInt32("rtp-time", (int32_t *)&rtpTime));

		if (!mNALUnits.empty() && rtpTime != mAccessUnitRTPTime) {
		submitAccessUnit();
		}
		mAccessUnitRTPTime = rtpTime;

		mNALUnits.push_back(buffer);
		}

		bool AHEVCAssembler::addSingleTimeAggregationPacket(const sp<ABuffer> &buffer) {
		const uint8_t *data = buffer->data();
		size_t size = buffer->size();

		if (size < 3) {
		ALOGV("Discarding too small STAP-A packet.");
		return false;
		}

		++data;
		--size;
		while (size >= 2) {
		size_t nalSize = (data[0] << 8) \| data[1];

		if (size < nalSize + 2) {
		ALOGV("Discarding malformed STAP-A packet.");
		return false;
		}

		sp<ABuffer> unit = new ABuffer(nalSize);
		memcpy(unit->data(), &data[2], nalSize);

		CopyTimes(unit, buffer);

		addSingleNALUnit(unit);

		data += 2 + nalSize;
		size -= 2 + nalSize;
		}

		if (size != 0) {
		ALOGV("Unexpected padding at end of STAP-A packet.");
		}

		return true;
		}

		ARTPAssembler::AssemblyStatus AHEVCAssembler::addFragmentedNALUnit(
		List<sp<ABuffer> > *queue) {
		CHECK(!queue->empty());

		sp<ABuffer> buffer = *queue->begin();
		const uint8_t *data = buffer->data();
		size_t size = buffer->size();

		CHECK(size > 0);
		/* H265 payload header is 16 bit
		0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
		\|F\| Type \| Layer ID \| TID \|
		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
		*/
		unsigned indicator = (data[0] >> 1);

		CHECK((indicator & H265_NALU_MASK) == H265_NALU_FU);

		if (size < 2) {
		ALOGV("Ignoring malformed FU buffer (size = %zu)", size);

		queue->erase(queue->begin());
		++mNextExpectedSeqNo;
		return MALFORMED_PACKET;
		}

		if (!(data[2] & 0x80)) {
		// Start bit not set on the first buffer.

		ALOGV("Start bit not set on first buffer");

		queue->erase(queue->begin());
		++mNextExpectedSeqNo;
		return MALFORMED_PACKET;
		}

		/* FU INDICATOR HDR
		0 1 2 3 4 5 6 7
		+-+-+-+-+-+-+-+-+
		\|S\|E\| Type \|
		+-+-+-+-+-+-+-+-+
		*/
		uint32_t nalType = data[2] & H265_NALU_MASK;
		uint32_t tid = data[1] & 0x7;
		ALOGV("nalType =%u, tid =%u", nalType, tid);

		uint32_t expectedSeqNo = (uint32_t)buffer->int32Data() + 1;
		size_t totalSize = size - 3;
		size_t totalCount = 1;
		bool complete = false;

		if (data[2] & 0x40) {
		// Huh? End bit also set on the first buffer.

		ALOGV("Grrr. This isn't fragmented at all.");

		complete = true;
		} else {
		List<sp<ABuffer> >::iterator it = ++queue->begin();
		while (it != queue->end()) {
		ALOGV("sequence length %zu", totalCount);

		const sp<ABuffer> &buffer = *it;

		const uint8_t *data = buffer->data();
		size_t size = buffer->size();

		if ((uint32_t)buffer->int32Data() != expectedSeqNo) {
		ALOGV("sequence not complete, expected seqNo %d, got %d",
		expectedSeqNo, (uint32_t)buffer->int32Data());

		return WRONG_SEQUENCE_NUMBER;
		}

		if (size < 3
		\|\| ((data[0] >> 1) & H265_NALU_MASK) != indicator
		\|\| (data[2] & H265_NALU_MASK) != nalType
		\|\| (data[2] & 0x80)) {
		ALOGV("Ignoring malformed FU buffer.");

		// Delete the whole start of the FU.

		it = queue->begin();
		for (size_t i = 0; i <= totalCount; ++i) {
		it = queue->erase(it);
		}

		mNextExpectedSeqNo = expectedSeqNo + 1;

		return MALFORMED_PACKET;
		}

		totalSize += size - 3;
		++totalCount;

		expectedSeqNo = expectedSeqNo + 1;

		if (data[2] & 0x40) {
		// This is the last fragment.
		complete = true;
		break;
		}

		++it;
		}
		}

		if (!complete) {
		return NOT_ENOUGH_DATA;
		}

		mNextExpectedSeqNo = expectedSeqNo;

		// We found all the fragments that make up the complete NAL unit.

		// Leave room for the header. So far totalSize did not include the
		// header byte.
		totalSize += 2;

		sp<ABuffer> unit = new ABuffer(totalSize);
		CopyTimes(unit, *queue->begin());

		unit->data()[0] = (nalType << 1);
		unit->data()[1] = tid;

		size_t offset = 2;
		List<sp<ABuffer> >::iterator it = queue->begin();
		for (size_t i = 0; i < totalCount; ++i) {
		const sp<ABuffer> &buffer = *it;

		ALOGV("piece #%zu/%zu", i + 1, totalCount);
		#if !LOG_NDEBUG
		hexdump(buffer->data(), buffer->size());
		#endif

		memcpy(unit->data() + offset, buffer->data() + 3, buffer->size() - 3);
		offset += buffer->size() - 3;

		it = queue->erase(it);
		}

		unit->setRange(0, totalSize);

		addSingleNALUnit(unit);

		ALOGV("successfully assembled a NAL unit from fragments.");

		return OK;
		}

		void AHEVCAssembler::submitAccessUnit() {
		CHECK(!mNALUnits.empty());

		ALOGV("Access unit complete (%zu nal units)", mNALUnits.size());

		size_t totalSize = 0;
		for (List<sp<ABuffer> >::iterator it = mNALUnits.begin();
		it != mNALUnits.end(); ++it) {
		totalSize += 4 + (*it)->size();
		}

		sp<ABuffer> accessUnit = new ABuffer(totalSize);
		size_t offset = 0;
		for (List<sp<ABuffer> >::iterator it = mNALUnits.begin();
		it != mNALUnits.end(); ++it) {
		memcpy(accessUnit->data() + offset, "\x00\x00\x00\x01", 4);
		offset += 4;

		sp<ABuffer> nal = *it;
		memcpy(accessUnit->data() + offset, nal->data(), nal->size());
		offset += nal->size();
		}

		CopyTimes(accessUnit, *mNALUnits.begin());

		#if 0
		printf(mAccessUnitDamaged ? "X" : ".");
		fflush(stdout);
		#endif

		if (mAccessUnitDamaged) {
		accessUnit->meta()->setInt32("damaged", true);
		}

		mNALUnits.clear();
		mAccessUnitDamaged = false;

		sp<AMessage> msg = mNotifyMsg->dup();
		msg->setBuffer("access-unit", accessUnit);
		msg->post();
		}

		ARTPAssembler::AssemblyStatus AHEVCAssembler::assembleMore(
		const sp<ARTPSource> &source) {
		AssemblyStatus status = addNALUnit(source);
		if (status == MALFORMED_PACKET) {
		mAccessUnitDamaged = true;
		}
		return status;
		}

		void AHEVCAssembler::packetLost() {
		CHECK(mNextExpectedSeqNoValid);
		ALOGV("packetLost (expected %d)", mNextExpectedSeqNo);

		++mNextExpectedSeqNo;

		mAccessUnitDamaged = true;
		}

		void AHEVCAssembler::onByeReceived() {
		sp<AMessage> msg = mNotifyMsg->dup();
		msg->setInt32("eos", true);
		msg->post();
		}

		} // namespace android

media/libstagefright/rtsp/AHEVCAssembler.h

0 → 100644

+62 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef A_HEVC_ASSEMBLER_H_

		#define A_HEVC_ASSEMBLER_H_

		#include "ARTPAssembler.h"

		#include <utils/List.h>
		#include <utils/RefBase.h>

		namespace android {

		struct ABuffer;
		struct AMessage;

		struct AHEVCAssembler : public ARTPAssembler {
		AHEVCAssembler(const sp<AMessage> &notify);

		protected:
		virtual ~AHEVCAssembler();

		virtual AssemblyStatus assembleMore(const sp<ARTPSource> &source);
		virtual void onByeReceived();
		virtual void packetLost();

		private:
		sp<AMessage> mNotifyMsg;

		uint32_t mAccessUnitRTPTime;
		bool mNextExpectedSeqNoValid;
		uint32_t mNextExpectedSeqNo;
		bool mAccessUnitDamaged;
		List<sp<ABuffer> > mNALUnits;

		AssemblyStatus addNALUnit(const sp<ARTPSource> &source);
		void addSingleNALUnit(const sp<ABuffer> &buffer);
		AssemblyStatus addFragmentedNALUnit(List<sp<ABuffer> > *queue);
		bool addSingleTimeAggregationPacket(const sp<ABuffer> &buffer);

		void submitAccessUnit();

		DISALLOW_EVIL_CONSTRUCTORS(AHEVCAssembler);
		};

		} // namespace android

		#endif // A_HEVC_ASSEMBLER_H_

media/libstagefright/rtsp/APacketSource.cpp

+11 −0

Original line number	Diff line number	Diff line
		@@ -452,6 +452,17 @@ APacketSource::APacketSource(
		return;
		}

		mFormat->setInt32(kKeyWidth, width);
		mFormat->setInt32(kKeyHeight, height);
		} else if (!strncmp(desc.c_str(), "H265/", 5)) {
		mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);

		int32_t width, height;
		if (!sessionDesc->getDimensions(index, PT, &width, &height)) {
		width = -1;
		height = -1;
		}

		mFormat->setInt32(kKeyWidth, width);
		mFormat->setInt32(kKeyHeight, height);
		} else if (!strncmp(desc.c_str(), "H263-2000/", 10)

media/libstagefright/rtsp/ARTPSource.cpp

+4 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@

		#include "AAMRAssembler.h"
		#include "AAVCAssembler.h"
		#include "AHEVCAssembler.h"
		#include "AH263Assembler.h"
		#include "AMPEG2TSAssembler.h"
		#include "AMPEG4AudioAssembler.h"
		@@ -65,6 +66,9 @@ ARTPSource::ARTPSource(
		if (!strncmp(desc.c_str(), "H264/", 5)) {
		mAssembler = new AAVCAssembler(notify);
		mIssueFIRRequests = true;
		} else if (!strncmp(desc.c_str(), "H265/", 5)) {
		mAssembler = new AHEVCAssembler(notify);
		mIssueFIRRequests = true;
		} else if (!strncmp(desc.c_str(), "MP4A-LATM/", 10)) {
		mAssembler = new AMPEG4AudioAssembler(notify, params);
		} else if (!strncmp(desc.c_str(), "H263-1998/", 10)

media/libstagefright/rtsp/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@ cc_defaults {
		srcs: [
		"AAMRAssembler.cpp",
		"AAVCAssembler.cpp",
		"AHEVCAssembler.cpp",
		"AH263Assembler.cpp",
		"AMPEG2TSAssembler.cpp",
		"AMPEG4AudioAssembler.cpp",