Move SkMovie into frameworks/base (b5e74b90) · Commits · e / os / android_frameworks_base

core/jni/Android.mk

+7 −0

Original line number	Diff line number	Diff line
		@@ -119,12 +119,15 @@ LOCAL_SRC_FILES:= \
		android/graphics/DrawFilter.cpp \
		android/graphics/FontFamily.cpp \
		android/graphics/CreateJavaOutputStreamAdaptor.cpp \
		android/graphics/GIFMovie.cpp \
		android/graphics/Graphics.cpp \
		android/graphics/HarfBuzzNGFaceSkia.cpp \
		android/graphics/Interpolator.cpp \
		android/graphics/MaskFilter.cpp \
		android/graphics/Matrix.cpp \
		android/graphics/Movie.cpp \
		android/graphics/MovieImpl.cpp \
		android/graphics/Movie_FactoryDefault.cpp \
		android/graphics/NinePatch.cpp \
		android/graphics/NinePatchPeeker.cpp \
		android/graphics/Paint.cpp \
		@@ -200,6 +203,7 @@ LOCAL_C_INCLUDES += \
		$(TOP)/system/core/include \
		$(TOP)/system/media/camera/include \
		$(TOP)/system/netd/include \
		external/giflib \
		external/pdfium/core/include/fpdfapi \
		external/pdfium/fpdfsdk/include \
		external/pdfium/public \
		@@ -219,6 +223,9 @@ LOCAL_C_INCLUDES += \
		external/freetype/include
		# TODO: clean up Minikin so it doesn't need the freetype include

		LOCAL_STATIC_LIBRARIES := \
		libgif \

		LOCAL_SHARED_LIBRARIES := \
		libmemtrack \
		libandroidfw \

core/jni/android/graphics/GIFMovie.cpp

0 → 100644

+451 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2006 The Android Open Source Project
		*
		* Use of this source code is governed by a BSD-style license that can be
		* found in the LICENSE file.
		*/


		#include "Movie.h"
		#include "SkColor.h"
		#include "SkColorPriv.h"
		#include "SkStream.h"
		#include "SkTemplates.h"
		#include "SkUtils.h"

		#include "gif_lib.h"

		#if GIFLIB_MAJOR < 5 \|\| (GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 0)
		#define DGifCloseFile(a, b) DGifCloseFile(a)
		#endif

		class GIFMovie : public Movie {
		public:
		GIFMovie(SkStream* stream);
		virtual ~GIFMovie();

		protected:
		virtual bool onGetInfo(Info*);
		virtual bool onSetTime(SkMSec);
		virtual bool onGetBitmap(SkBitmap*);

		private:
		GifFileType* fGIF;
		int fCurrIndex;
		int fLastDrawIndex;
		SkBitmap fBackup;
		SkColor fPaintingColor;
		};

		static int Decode(GifFileType* fileType, GifByteType* out, int size) {
		SkStream* stream = (SkStream*) fileType->UserData;
		return (int) stream->read(out, size);
		}

		GIFMovie::GIFMovie(SkStream* stream)
		{
		#if GIFLIB_MAJOR < 5
		fGIF = DGifOpen( stream, Decode );
		#else
		fGIF = DGifOpen( stream, Decode, nullptr );
		#endif
		if (nullptr == fGIF)
		return;

		if (DGifSlurp(fGIF) != GIF_OK)
		{
		DGifCloseFile(fGIF, nullptr);
		fGIF = nullptr;
		}
		fCurrIndex = -1;
		fLastDrawIndex = -1;
		fPaintingColor = SkPackARGB32(0, 0, 0, 0);
		}

		GIFMovie::~GIFMovie()
		{
		if (fGIF)
		DGifCloseFile(fGIF, nullptr);
		}

		static SkMSec savedimage_duration(const SavedImage* image)
		{
		for (int j = 0; j < image->ExtensionBlockCount; j++)
		{
		if (image->ExtensionBlocks[j].Function == GRAPHICS_EXT_FUNC_CODE)
		{
		SkASSERT(image->ExtensionBlocks[j].ByteCount >= 4);
		const uint8_t* b = (const uint8_t*)image->ExtensionBlocks[j].Bytes;
		return ((b[2] << 8) \| b[1]) * 10;
		}
		}
		return 0;
		}

		bool GIFMovie::onGetInfo(Info* info)
		{
		if (nullptr == fGIF)
		return false;

		SkMSec dur = 0;
		for (int i = 0; i < fGIF->ImageCount; i++)
		dur += savedimage_duration(&fGIF->SavedImages[i]);

		info->fDuration = dur;
		info->fWidth = fGIF->SWidth;
		info->fHeight = fGIF->SHeight;
		info->fIsOpaque = false; // how to compute?
		return true;
		}

		bool GIFMovie::onSetTime(SkMSec time)
		{
		if (nullptr == fGIF)
		return false;

		SkMSec dur = 0;
		for (int i = 0; i < fGIF->ImageCount; i++)
		{
		dur += savedimage_duration(&fGIF->SavedImages[i]);
		if (dur >= time)
		{
		fCurrIndex = i;
		return fLastDrawIndex != fCurrIndex;
		}
		}
		fCurrIndex = fGIF->ImageCount - 1;
		return true;
		}

		static void copyLine(uint32_t* dst, const unsigned char* src, const ColorMapObject* cmap,
		int transparent, int width)
		{
		for (; width > 0; width--, src++, dst++) {
		if (*src != transparent) {
		const GifColorType& col = cmap->Colors[*src];
		*dst = SkPackARGB32(0xFF, col.Red, col.Green, col.Blue);
		}
		}
		}

		#if GIFLIB_MAJOR < 5
		static void copyInterlaceGroup(SkBitmap* bm, const unsigned char*& src,
		const ColorMapObject* cmap, int transparent, int copyWidth,
		int copyHeight, const GifImageDesc& imageDesc, int rowStep,
		int startRow)
		{
		int row;
		// every 'rowStep'th row, starting with row 'startRow'
		for (row = startRow; row < copyHeight; row += rowStep) {
		uint32_t* dst = bm->getAddr32(imageDesc.Left, imageDesc.Top + row);
		copyLine(dst, src, cmap, transparent, copyWidth);
		src += imageDesc.Width;
		}

		// pad for rest height
		src += imageDesc.Width * ((imageDesc.Height - row + rowStep - 1) / rowStep);
		}

		static void blitInterlace(SkBitmap* bm, const SavedImage* frame, const ColorMapObject* cmap,
		int transparent)
		{
		int width = bm->width();
		int height = bm->height();
		GifWord copyWidth = frame->ImageDesc.Width;
		if (frame->ImageDesc.Left + copyWidth > width) {
		copyWidth = width - frame->ImageDesc.Left;
		}

		GifWord copyHeight = frame->ImageDesc.Height;
		if (frame->ImageDesc.Top + copyHeight > height) {
		copyHeight = height - frame->ImageDesc.Top;
		}

		// deinterlace
		const unsigned char* src = (unsigned char*)frame->RasterBits;

		// group 1 - every 8th row, starting with row 0
		copyInterlaceGroup(bm, src, cmap, transparent, copyWidth, copyHeight, frame->ImageDesc, 8, 0);

		// group 2 - every 8th row, starting with row 4
		copyInterlaceGroup(bm, src, cmap, transparent, copyWidth, copyHeight, frame->ImageDesc, 8, 4);

		// group 3 - every 4th row, starting with row 2
		copyInterlaceGroup(bm, src, cmap, transparent, copyWidth, copyHeight, frame->ImageDesc, 4, 2);

		copyInterlaceGroup(bm, src, cmap, transparent, copyWidth, copyHeight, frame->ImageDesc, 2, 1);
		}
		#endif

		static void blitNormal(SkBitmap* bm, const SavedImage* frame, const ColorMapObject* cmap,
		int transparent)
		{
		int width = bm->width();
		int height = bm->height();
		const unsigned char* src = (unsigned char*)frame->RasterBits;
		uint32_t* dst = bm->getAddr32(frame->ImageDesc.Left, frame->ImageDesc.Top);
		GifWord copyWidth = frame->ImageDesc.Width;
		if (frame->ImageDesc.Left + copyWidth > width) {
		copyWidth = width - frame->ImageDesc.Left;
		}

		GifWord copyHeight = frame->ImageDesc.Height;
		if (frame->ImageDesc.Top + copyHeight > height) {
		copyHeight = height - frame->ImageDesc.Top;
		}

		for (; copyHeight > 0; copyHeight--) {
		copyLine(dst, src, cmap, transparent, copyWidth);
		src += frame->ImageDesc.Width;
		dst += width;
		}
		}

		static void fillRect(SkBitmap* bm, GifWord left, GifWord top, GifWord width, GifWord height,
		uint32_t col)
		{
		int bmWidth = bm->width();
		int bmHeight = bm->height();
		uint32_t* dst = bm->getAddr32(left, top);
		GifWord copyWidth = width;
		if (left + copyWidth > bmWidth) {
		copyWidth = bmWidth - left;
		}

		GifWord copyHeight = height;
		if (top + copyHeight > bmHeight) {
		copyHeight = bmHeight - top;
		}

		for (; copyHeight > 0; copyHeight--) {
		sk_memset32(dst, col, copyWidth);
		dst += bmWidth;
		}
		}

		static void drawFrame(SkBitmap* bm, const SavedImage* frame, const ColorMapObject* cmap)
		{
		int transparent = -1;

		for (int i = 0; i < frame->ExtensionBlockCount; ++i) {
		ExtensionBlock* eb = frame->ExtensionBlocks + i;
		if (eb->Function == GRAPHICS_EXT_FUNC_CODE &&
		eb->ByteCount == 4) {
		bool has_transparency = ((eb->Bytes[0] & 1) == 1);
		if (has_transparency) {
		transparent = (unsigned char)eb->Bytes[3];
		}
		}
		}

		if (frame->ImageDesc.ColorMap != nullptr) {
		// use local color table
		cmap = frame->ImageDesc.ColorMap;
		}

		if (cmap == nullptr \|\| cmap->ColorCount != (1 << cmap->BitsPerPixel)) {
		SkDEBUGFAIL("bad colortable setup");
		return;
		}

		#if GIFLIB_MAJOR < 5
		// before GIFLIB 5, de-interlacing wasn't done by library at load time
		if (frame->ImageDesc.Interlace) {
		blitInterlace(bm, frame, cmap, transparent);
		return;
		}
		#endif

		blitNormal(bm, frame, cmap, transparent);
		}

		static bool checkIfWillBeCleared(const SavedImage* frame)
		{
		for (int i = 0; i < frame->ExtensionBlockCount; ++i) {
		ExtensionBlock* eb = frame->ExtensionBlocks + i;
		if (eb->Function == GRAPHICS_EXT_FUNC_CODE &&
		eb->ByteCount == 4) {
		// check disposal method
		int disposal = ((eb->Bytes[0] >> 2) & 7);
		if (disposal == 2 \|\| disposal == 3) {
		return true;
		}
		}
		}
		return false;
		}

		static void getTransparencyAndDisposalMethod(const SavedImage* frame, bool* trans, int* disposal)
		{
		*trans = false;
		*disposal = 0;
		for (int i = 0; i < frame->ExtensionBlockCount; ++i) {
		ExtensionBlock* eb = frame->ExtensionBlocks + i;
		if (eb->Function == GRAPHICS_EXT_FUNC_CODE &&
		eb->ByteCount == 4) {
		*trans = ((eb->Bytes[0] & 1) == 1);
		*disposal = ((eb->Bytes[0] >> 2) & 7);
		}
		}
		}

		// return true if area of 'target' is completely covers area of 'covered'
		static bool checkIfCover(const SavedImage* target, const SavedImage* covered)
		{
		if (target->ImageDesc.Left <= covered->ImageDesc.Left
		&& covered->ImageDesc.Left + covered->ImageDesc.Width <=
		target->ImageDesc.Left + target->ImageDesc.Width
		&& target->ImageDesc.Top <= covered->ImageDesc.Top
		&& covered->ImageDesc.Top + covered->ImageDesc.Height <=
		target->ImageDesc.Top + target->ImageDesc.Height) {
		return true;
		}
		return false;
		}

		static void disposeFrameIfNeeded(SkBitmap* bm, const SavedImage* cur, const SavedImage* next,
		SkBitmap* backup, SkColor color)
		{
		// We can skip disposal process if next frame is not transparent
		// and completely covers current area
		bool curTrans;
		int curDisposal;
		getTransparencyAndDisposalMethod(cur, &curTrans, &curDisposal);
		bool nextTrans;
		int nextDisposal;
		getTransparencyAndDisposalMethod(next, &nextTrans, &nextDisposal);
		if ((curDisposal == 2 \|\| curDisposal == 3)
		&& (nextTrans \|\| !checkIfCover(next, cur))) {
		switch (curDisposal) {
		// restore to background color
		// -> 'background' means background under this image.
		case 2:
		fillRect(bm, cur->ImageDesc.Left, cur->ImageDesc.Top,
		cur->ImageDesc.Width, cur->ImageDesc.Height,
		color);
		break;

		// restore to previous
		case 3:
		bm->swap(*backup);
		break;
		}
		}

		// Save current image if next frame's disposal method == 3
		if (nextDisposal == 3) {
		const uint32_t* src = bm->getAddr32(0, 0);
		uint32_t* dst = backup->getAddr32(0, 0);
		int cnt = bm->width() * bm->height();
		memcpy(dst, src, cnt*sizeof(uint32_t));
		}
		}

		bool GIFMovie::onGetBitmap(SkBitmap* bm)
		{
		const GifFileType* gif = fGIF;
		if (nullptr == gif)
		return false;

		if (gif->ImageCount < 1) {
		return false;
		}

		const int width = gif->SWidth;
		const int height = gif->SHeight;
		if (width <= 0 \|\| height <= 0) {
		return false;
		}

		// no need to draw
		if (fLastDrawIndex >= 0 && fLastDrawIndex == fCurrIndex) {
		return true;
		}

		int startIndex = fLastDrawIndex + 1;
		if (fLastDrawIndex < 0 \|\| !bm->readyToDraw()) {
		// first time

		startIndex = 0;

		// create bitmap
		if (!bm->tryAllocN32Pixels(width, height)) {
		return false;
		}
		// create bitmap for backup
		if (!fBackup.tryAllocN32Pixels(width, height)) {
		return false;
		}
		} else if (startIndex > fCurrIndex) {
		// rewind to 1st frame for repeat
		startIndex = 0;
		}

		int lastIndex = fCurrIndex;
		if (lastIndex < 0) {
		// first time
		lastIndex = 0;
		} else if (lastIndex > fGIF->ImageCount - 1) {
		// this block must not be reached.
		lastIndex = fGIF->ImageCount - 1;
		}

		SkColor bgColor = SkPackARGB32(0, 0, 0, 0);
		if (gif->SColorMap != nullptr) {
		const GifColorType& col = gif->SColorMap->Colors[fGIF->SBackGroundColor];
		bgColor = SkColorSetARGB(0xFF, col.Red, col.Green, col.Blue);
		}

		// draw each frames - not intelligent way
		for (int i = startIndex; i <= lastIndex; i++) {
		const SavedImage* cur = &fGIF->SavedImages[i];
		if (i == 0) {
		bool trans;
		int disposal;
		getTransparencyAndDisposalMethod(cur, &trans, &disposal);
		if (!trans && gif->SColorMap != nullptr) {
		fPaintingColor = bgColor;
		} else {
		fPaintingColor = SkColorSetARGB(0, 0, 0, 0);
		}

		bm->eraseColor(fPaintingColor);
		fBackup.eraseColor(fPaintingColor);
		} else {
		// Dispose previous frame before move to next frame.
		const SavedImage* prev = &fGIF->SavedImages[i-1];
		disposeFrameIfNeeded(bm, prev, cur, &fBackup, fPaintingColor);
		}

		// Draw frame
		// We can skip this process if this index is not last and disposal
		// method == 2 or method == 3
		if (i == lastIndex \|\| !checkIfWillBeCleared(cur)) {
		drawFrame(bm, cur, gif->SColorMap);
		}
		}

		// save index
		fLastDrawIndex = lastIndex;
		return true;
		}

		///////////////////////////////////////////////////////////////////////////////

		#include "SkTRegistry.h"

		Movie* Factory(SkStreamRewindable* stream) {
		char buf[GIF_STAMP_LEN];
		if (stream->read(buf, GIF_STAMP_LEN) == GIF_STAMP_LEN) {
		if (memcmp(GIF_STAMP, buf, GIF_STAMP_LEN) == 0 \|\|
		memcmp(GIF87_STAMP, buf, GIF_STAMP_LEN) == 0 \|\|
		memcmp(GIF89_STAMP, buf, GIF_STAMP_LEN) == 0) {
		// must rewind here, since our construct wants to re-read the data
		stream->rewind();
		return new GIFMovie(stream);
		}
		}
		return nullptr;
		}

		static SkTRegistry<Movie()(SkStreamRewindable*)> gReg(Factory);

core/jni/android/graphics/Movie.cpp

+9 −9

Original line number	Diff line number	Diff line
		@@ -2,7 +2,7 @@
		#include "GraphicsJNI.h"
		#include "ScopedLocalRef.h"
		#include "SkFrontBufferedStream.h"
		#include "SkMovie.h"
		#include "Movie.h"
		#include "SkStream.h"
		#include "SkUtils.h"
		#include "Utils.h"
		@@ -19,7 +19,7 @@ static jclass gMovie_class;
		static jmethodID gMovie_constructorMethodID;
		static jfieldID gMovie_nativeInstanceID;

		jobject create_jmovie(JNIEnv* env, SkMovie* moov) {
		jobject create_jmovie(JNIEnv* env, Movie* moov) {
		if (NULL == moov) {
		return NULL;
		}
		@@ -27,11 +27,11 @@ jobject create_jmovie(JNIEnv* env, SkMovie* moov) {
		static_cast<jlong>(reinterpret_cast<uintptr_t>(moov)));
		}

		static SkMovie* J2Movie(JNIEnv* env, jobject movie) {
		static Movie* J2Movie(JNIEnv* env, jobject movie) {
		SkASSERT(env);
		SkASSERT(movie);
		SkASSERT(env->IsInstanceOf(movie, gMovie_class));
		SkMovie* m = (SkMovie*)env->GetLongField(movie, gMovie_nativeInstanceID);
		Movie* m = (Movie*)env->GetLongField(movie, gMovie_nativeInstanceID);
		SkASSERT(m);
		return m;
		}
		@@ -74,7 +74,7 @@ static void movie_draw(JNIEnv* env, jobject movie, jlong canvasHandle,
		// therefore may be NULL.
		SkASSERT(c != NULL);

		SkMovie* m = J2Movie(env, movie);
		Movie* m = J2Movie(env, movie);
		const SkBitmap& b = m->bitmap();
		sk_sp<android::Bitmap> wrapper = android::Bitmap::createFrom(b.info(), *b.pixelRef());
		c->drawBitmap(*wrapper, fx, fy, p);
		@@ -84,7 +84,7 @@ static jobject movie_decodeAsset(JNIEnv* env, jobject clazz, jlong native_asset)
		android::Asset* asset = reinterpret_cast<android::Asset*>(native_asset);
		if (asset == NULL) return NULL;
		android::AssetStreamAdaptor stream(asset);
		SkMovie* moov = SkMovie::DecodeStream(&stream);
		Movie* moov = Movie::DecodeStream(&stream);
		return create_jmovie(env, moov);
		}

		@@ -107,7 +107,7 @@ static jobject movie_decodeStream(JNIEnv* env, jobject clazz, jobject istream) {
		std::unique_ptr<SkStreamRewindable> bufferedStream(SkFrontBufferedStream::Create(strm, 6));
		SkASSERT(bufferedStream.get() != NULL);

		SkMovie* moov = SkMovie::DecodeStream(bufferedStream.get());
		Movie* moov = Movie::DecodeStream(bufferedStream.get());
		return create_jmovie(env, moov);
		}

		@@ -124,12 +124,12 @@ static jobject movie_decodeByteArray(JNIEnv* env, jobject clazz,
		}

		AutoJavaByteArray ar(env, byteArray);
		SkMovie* moov = SkMovie::DecodeMemory(ar.ptr() + offset, length);
		Movie* moov = Movie::DecodeMemory(ar.ptr() + offset, length);
		return create_jmovie(env, moov);
		}

		static void movie_destructor(JNIEnv* env, jobject, jlong movieHandle) {
		SkMovie* movie = (SkMovie*) movieHandle;
		Movie* movie = (Movie*) movieHandle;
		delete movie;
		}

core/jni/android/graphics/Movie.h

0 → 100644

+78 −0

Original line number	Diff line number	Diff line

		/*
		* Copyright 2008 The Android Open Source Project
		*
		* Use of this source code is governed by a BSD-style license that can be
		* found in the LICENSE file.
		*/


		#ifndef Movie_DEFINED
		#define Movie_DEFINED

		#include "SkRefCnt.h"
		#include "SkCanvas.h"

		class SkStreamRewindable;

		class Movie : public SkRefCnt {
		public:
		/** Try to create a movie from the stream. If the stream format is not
		supported, return NULL.
		*/
		static Movie* DecodeStream(SkStreamRewindable*);
		/** Try to create a movie from the specified file path. If the file is not
		found, or the format is not supported, return NULL. If a movie is
		returned, the stream may be retained by the movie (via ref()) until
		the movie is finished with it (by calling unref()).
		*/
		static Movie* DecodeFile(const char path[]);
		/** Try to create a movie from the specified memory.
		If the format is not supported, return NULL. If a movie is returned,
		the data will have been read or copied, and so the caller may free
		it.
		*/
		static Movie* DecodeMemory(const void* data, size_t length);

		SkMSec duration();
		int width();
		int height();
		int isOpaque();

		/** Specify the time code (between 0...duration) to sample a bitmap
		from the movie. Returns true if this time code generated a different
		bitmap/frame from the previous state (i.e. true means you need to
		redraw).
		*/
		bool setTime(SkMSec);

		// return the right bitmap for the current time code
		const SkBitmap& bitmap();

		protected:
		struct Info {
		SkMSec fDuration;
		int fWidth;
		int fHeight;
		bool fIsOpaque;
		};

		virtual bool onGetInfo(Info*) = 0;
		virtual bool onSetTime(SkMSec) = 0;
		virtual bool onGetBitmap(SkBitmap*) = 0;

		// visible for subclasses
		Movie();

		private:
		Info fInfo;
		SkMSec fCurrTime;
		SkBitmap fBitmap;
		bool fNeedBitmap;

		void ensureInfo();

		typedef SkRefCnt INHERITED;
		};

		#endif

core/jni/android/graphics/MovieImpl.cpp

0 → 100644

+94 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2011 Google Inc.
		*
		* Use of this source code is governed by a BSD-style license that can be
		* found in the LICENSE file.
		*/
		#include "Movie.h"
		#include "SkCanvas.h"
		#include "SkPaint.h"

		// We should never see this in normal operation since our time values are
		// 0-based. So we use it as a sentinal.
		#define UNINITIALIZED_MSEC ((SkMSec)-1)

		Movie::Movie()
		{
		fInfo.fDuration = UNINITIALIZED_MSEC; // uninitialized
		fCurrTime = UNINITIALIZED_MSEC; // uninitialized
		fNeedBitmap = true;
		}

		void Movie::ensureInfo()
		{
		if (fInfo.fDuration == UNINITIALIZED_MSEC && !this->onGetInfo(&fInfo))
		memset(&fInfo, 0, sizeof(fInfo)); // failure
		}

		SkMSec Movie::duration()
		{
		this->ensureInfo();
		return fInfo.fDuration;
		}

		int Movie::width()
		{
		this->ensureInfo();
		return fInfo.fWidth;
		}

		int Movie::height()
		{
		this->ensureInfo();
		return fInfo.fHeight;
		}

		int Movie::isOpaque()
		{
		this->ensureInfo();
		return fInfo.fIsOpaque;
		}

		bool Movie::setTime(SkMSec time)
		{
		SkMSec dur = this->duration();
		if (time > dur)
		time = dur;

		bool changed = false;
		if (time != fCurrTime)
		{
		fCurrTime = time;
		changed = this->onSetTime(time);
		fNeedBitmap \|= changed;
		}
		return changed;
		}

		const SkBitmap& Movie::bitmap()
		{
		if (fCurrTime == UNINITIALIZED_MSEC) // uninitialized
		this->setTime(0);

		if (fNeedBitmap)
		{
		if (!this->onGetBitmap(&fBitmap)) // failure
		fBitmap.reset();
		fNeedBitmap = false;
		}
		return fBitmap;
		}

		////////////////////////////////////////////////////////////////////

		#include "SkStream.h"

		Movie* Movie::DecodeMemory(const void* data, size_t length) {
		SkMemoryStream stream(data, length, false);
		return Movie::DecodeStream(&stream);
		}

		Movie* Movie::DecodeFile(const char path[]) {
		std::unique_ptr<SkStreamRewindable> stream = SkStream::MakeFromFile(path);
		return stream ? Movie::DecodeStream(stream.get()) : nullptr;
		}