Adobe Flash Player Version 20.0.0.228 Released

Provide Video Rotation Information to Action Script as Meta Data

According ISO/IEC 14996-12:2008 standard, videos must provide information matrices like Track Header Box and Movie Header Box. But the Flash runtime doesn’t process the matrix field values in Track Header Box and Movie Head Box correctly. This results in incorrect positioning or sizing of videos.

This problem is now resolved with Flash Player version 20 by providing video matrix information to ActionScript as a part of meta data object of the onMetaData event (which is a property of NetStream.Client). ActionScript developers can use these matrices to render the videos as needed.

This feature can be used to apply matrix information to a video object. See below for an example:

var video:Video = new Video();

addChild(video);

var nc:NetConnection = new NetConnection();

nc.connect(null);

var ns:NetStream = new NetStream(nc);

ns.client = {};

ns.client.onMetaData = ns_onMetaData;

ns.client.onCuePoint = ns_onCuePoint;

video.attachNetStream(ns);

ns.play(“Demo.mp4”);

function ns_onMetaData(info:Object):void

{

trace(“metaData”);

video.x = 0,

video.y = 0;

video.width = info.width;

video.height = info.height;

var matrix:Matrix = video.transform.matrix; // Read old transform matrix of Video object.

var oldSize:Point = new Point(video.width, video.height);

var newSize:Point = new Point(Math.abs(info.matrix.transformPoint(oldSize).x),

Math.abs(info.matrix.transformPoint(oldSize).y));

matrix.translate(-(oldSize.x / 2), -(oldSize.y / 2));

if (info.hasOwnProperty(“trackHeaderBoxMatrix”))

matrix.concat(info.trackHeaderBoxMatrix[0]); // Apply the matrix of the Track Header Box of Video Track provided by this feature to the video object.

// trackHeaderBoxMatrix is an array of MatrixObject because there can be one or more video tracks.

if (info.hasOwnProperty(“movieHeaderBoxMatrix”))

matrix.concat(info.movieHeaderBoxMatrix); // Apply the matrix of the Movie Header Box provided by this feature to video object.

matrix.translate((newSize.x / 2), (newSize.y / 2));

video.transform.matrix = matrix; // Set new matrix to transform matrix of Video object.

}

function ns_onCuePoint(item:Object):void

{

trace(“cuePoint”);

}

This feaure will be available only for NetStream using Progressive Download.  It will not be available for NetStream using RTMP or appendBytes
etc.  Matrix information provided by this feature can only be applied to an instance of Video class .  It can not be applied to StageVideo Class.

Matrices’ information will only be available for videos which in accordance with the ISO/IEC 14996-12:2008 standard.

PPAPI Vector Printing

As of Flash Player version 19, Vector Printing has only been available for NPAPI while PPAPI supported only bitmap printing.  Hence there was an
observable difference in printing quality between NPAPI and PPAPI (with NPAPI being better).  Now in Flash Player version 20, we have introduced vector printing for PPAPI on Windows, thus giving a better printing experience from PPAPI supported browsers and applications. Bitmap printing is still supported for content that requests it.  

Flash Player “Enable Hardware acceleration” setting for Edge and IE on Windows 8/10

The “Enable Hardware acceleration” option has been introduced to support the manual switching between software and hardware accelerated operations for the following features:

Video playback

Stage3D rendering.

The option is intended to allow users to force a software fallback to resolve display problems caused by faulty GPU drivers.

Instanced drawing

Stage3D APIs has provided developers a great way to render graphics efficiently using a devices’ GPU.  Developers can render beautiful graphics
using these APIs, but a particular scenario may occur, where a developer wants to render a particular graphical entity, multiple time.  For example, what should a developer do if they want to create a forest, having thousands of trees.  They might have a few models of trees and from these, they want to create a vast forest consisting of thousands of individual trees.  One way to do it is to dispatch as many draw calls as there are trees while changing relevant variables in between. For example, each tree is located in a different spot, each tree can be larger or smaller than the average, etc.  Doing this with dispatching separate draw calls can be very inefficient and time consuming.

The new Instanced drawing feature can help if this situation arises.  Using instanced drawing, a developer can use a particular
model of graphical object and render it more than one time in single frame. This will reduce draw calls and hence rendering and overall
performance will be much smoother.

For solving instanced drawing problem we have basically introduced two new APIs one additional (iid) register in AGAL.  A device should support Standard Extended Profile to have this feature.

Context3D::createVertexBufferForInstances( numElements:int, data32PerElement:int, instancesPerElement:int, bufferUsage:String = “staticDraw”, ):VertexBuffer3D;

Use the VertexBuffer3D object to upload a set of instance data to the rendering context.  The vertex buffer contains the data needed to render each instance in the scene geometry.  Vertex Buffers with instance data provide attributes that are common to all the vertices of an instance and serve as the input to the vertex shader program.

Context3D::drawTrianglesInstanced( indexBuffer:IndexBuffer3D, numInstances, firstIndex:int=0, numTriangles:int=-1 ):void;

AGALv3 is also updated .New AGAL Register: “iid” is added to read the current instance id in the shader.  So “mov vt0.x, iid” would be an
example AGAL instruction to read instanceID to vt0.x.

AGALv3 is available at :
 

https://github.com/adobe-flash/graphicscorelib/tree/master/src/com/adobe/utils/v3

Assumptions and Dependencies

1) This feature will only be supported on devices which supports Standard Extended Profile
2) Currently this feature is only available in Mobile devices

Adobe has released security updates for Adobe Flash Player.  These updates address critical vulnerabilities that could potentially allow an attacker to take control of the affected system.