加快apk的构建速度,如何管编译时间打130秒降到17秒

参照的花色和文章

Instant
Run

Tinker

安卓App热补丁动态修复技术介绍

Android应用程序资源的编译和包装过程分析

关键字:
加快apk编译速度
加速app编译速度
增速android编译速度
加速android studio 编译速度
android 加快编译速度
android studio编译慢
android studio编译速度优化
android studio gradle 编译慢

VP8 的开源实现

  • libvpx

libvpx
是 VP8 的唯一开源实现,由 On2 Technologies 开销,Google
收购后以那个开放源码,License 非常宽松可以任意使用。

补丁打包时之流水线
  • 1、检查缓存的得力
  • @see
    fastdex.build.variant.FastdexVariant
    的prepareEnv方法求证
  • 2、扫描所有变更之java文件并编译成class
  • @see
    fastdex.build.task.FastdexCustomJavacTask
  • 3、合并有变更之class并生成jar包
  • 4、生成补丁dex
  • 5、把所有的dex按照一定规律在transformClassesWithMultidexlistFor${variantName}任务的出口目录
    fastdex-runtime.dex => classes.dex
    patch.dex => classes2.dex
    dex_cache.classes.dex => classes3.dex
    dex_cache.classes2.dex => classes4.dex
    dex_cache.classesN.dex => classes(N + 2).dex

=============

关于直播的技术文章未丢掉,成体系的无多。我们拿故七篇文章,更系统化地介绍这大热的视频直播各环的关键技术,帮助视频直播创业者们再度全面、深入地询问视频直播技术,更好地技术选型。

哪些拿到transformClassesWithDexForDebug任务尽前后的生命周期

参考了Tinker类型的代码,找到下面的兑现

public class ImmutableDexTransform extends Transform {
    Project project
    DexTransform dexTransform
    def variant

    ......

    @Override
    void transform(TransformInvocation transformInvocation) throws TransformException, IOException, InterruptedException {
        def outputProvider = transformInvocation.getOutputProvider()
        //dex的输出目录
        File outputDir = outputProvider.getContentLocation("main", dexTransform.getOutputTypes(), dexTransform.getScopes(), Format.DIRECTORY);
        if (outputDir.exists()) {
            outputDir.delete()
        }
        println("===执行transform前清空dex输出目录: ${project.projectDir.toPath().relativize(outputDir.toPath())}")
        dexTransform.transform(transformInvocation)
        if (outputDir.exists()) {
            println("===执行transform后dex输出目录不是空的: ${project.projectDir.toPath().relativize(outputDir.toPath())}")
            outputDir.listFiles().each {
                println("===执行transform后: ${it.name}")
            }
        }
    }
}

project.getGradle().getTaskGraph().addTaskExecutionGraphListener(new TaskExecutionGraphListener() {
    @Override
    public void graphPopulated(TaskExecutionGraph taskGraph) {
        for (Task task : taskGraph.getAllTasks()) {
            if (task instanceof TransformTask && task.name.toLowerCase().contains(variant.name.toLowerCase())) {

                if (((TransformTask) task).getTransform() instanceof DexTransform && !(((TransformTask) task).getTransform() instanceof ImmutableDexTransform)) {
                    project.logger.warn("find dex transform. transform class: " + task.transform.getClass() + " . task name: " + task.name)

                    DexTransform dexTransform = task.transform
                    ImmutableDexTransform hookDexTransform = new ImmutableDexTransform(project,
                            variant, dexTransform)
                    project.logger.info("variant name: " + variant.name)

                    Field field = TransformTask.class.getDeclaredField("transform")
                    field.setAccessible(true)
                    field.set(task, hookDexTransform)
                    project.logger.warn("transform class after hook: " + task.transform.getClass())
                    break;
                }
            }
        }
    }
});

管方的代码放进app/build.gradle执行./gradlew assembleDebug

:app:transformClassesWithMultidexlistForDebug
ProGuard, version 5.2.1
Reading program jar [/Users/tong/Projects/fastdex/app/build/intermediates/transforms/jarMerging/debug/jars/1/1f/combined.jar]
Reading library jar [/Users/tong/Applications/android-sdk-macosx/build-tools/23.0.1/lib/shrinkedAndroid.jar]
Preparing output jar [/Users/tong/Projects/fastdex/app/build/intermediates/multi-dex/debug/componentClasses.jar]
  Copying resources from program jar [/Users/tong/Projects/fastdex/app/build/intermediates/transforms/jarMerging/debug/jars/1/1f/combined.jar]
:app:transformClassesWithDexForDebug
===执行transform前清空dex输出目录: build/intermediates/transforms/dex/debug/folders/1000/1f/main
......
===执行transform后dex输出目录不是空的: build/intermediates/transforms/dex/debug/folders/1000/1f/main
===执行transform后: classes.dex

起地方的日志输出证明这hook点是中之,在全量打包时实施transform前可以本着java源码做快照,执行完毕事后管dex缓存下来;在补丁打包实行transform之前相比快照移除没有变的class,执行完毕后合并缓存的dex放上dex输出目录

==============================

(四)推流和传导

怎么样做快照与对待快照并将到转的class列表

推行下的代码可以博有的档次源码目录

project.android.sourceSets.main.java.srcDirs.each { srcDir->
    println("==srcDir: ${srcDir}")
}

sample工程尚未配备sourceSets,因此输出的凡app/src/main/java

吃源码目录做快照,直接通过文件复制的法门,把具有的srcDir目录下之java文件复制到快照目录下(这里发出只坑,不要采用project.copy
{}它会如文件之lastModified值发生变化,直接采用流copy并且要用源文件的lastModified覆盖目标文件的lastModified)

透过java文件的尺寸和上次修改时间有限只元素对比可以查出同一个文本是否发生变化,通过快照目录没有有文件要当前目录有某个文件可以识破增加了文本,通过快照目录有有文件但是当前目录没有得以查出删除文件(为了效率可以不处理删除,仅造成缓存里发生好几用非交的类似设曾经)
推个例证来说要项目源码的路径为/Users/tong/fastdex/app/src/main/java,做快照时把这个目录复制到/Users/tong/fastdex/app/build/fastdex/snapshoot下,当前快照里的文件树为

└── com
    └── dx168
        └── fastdex
            └── sample
                ├── CustomView.java
                ├── MainActivity.java
                └── SampleApplication.java

若手上源码路径的内容发生变化,当前的文书树为

└── com
    └── dx168
        └── fastdex
            └── sample
                ├── CustomView.java
                ├── MainActivity.java(内容已经被修改)
                ├── New.java
                └── SampleApplication.java

由此文件遍历对比可以得到此变化之相对路径列表

  • com/dx168/fastdex/sample/MainActivity.java
  • com/dx168/fastdex/sample/New.java

由此者列表进而可以查出变化之class有

  • com/dx168/fastdex/sample/MainActivity.class
  • com/dx168/fastdex/sample/New.class

但是java文件编译的早晚要来内部类还见面生外的片class输出,比如拿R文件举行生编译,它的编译输出如下

➜  sample git:(master) ls
R.java
➜  sample git:(master) javac R.java 
➜  sample git:(master) ls
R$attr.class      R$dimen.class     R$id.class        R$layout.class    R$string.class    R$styleable.class R.java
R$color.class     R$drawable.class  R$integer.class   R$mipmap.class    R$style.class     R.class
➜  sample git:(master) 

除此以外要采取了butterknife,还见面生成binder类,比如编译MainActivity.java时颇成了
com/dx168/fastdex/sample/MainActivity$$ViewBinder.class

组成地方几乎触及可以抱有变化class的配合模式

  • com/dx168/fastdex/sample/MainActivity.class
  • com/dx168/fastdex/sample/MainActivity$*.class
  • com/dx168/fastdex/sample/New.class
  • com/dx168/fastdex/sample/New$*.class

来矣面的配合模式就是好于补丁打包实行transform前把app/build/intermediates/transforms/jarMerging/debug/jars/1/1f/combined.jar中没变动之class全部移除掉

project.copy {
    from project.zipTree(combinedJar)
        for (String pattern : patterns) {
            include pattern
        }
    }
    into tmpDir
}
project.ant.zip(baseDir: tmpDir, destFile: patchJar)

然后便好使patchJar作为输入jar生成补丁dex

流动:
这种映射方案一经打开了模糊就对许不达标了,需要分析混淆后发生的mapping文件才能够化解,不过我们为绝非必要当拉开混淆的buildType下举行开发出调试,所以临时可以无开是事情

==============================
生矣补丁dex,就得选取一样栽热修复方案将补丁dex加载进来,这里方案来少数栽,为了简单直接选择android.support.multidex.MultiDex以dex插桩的不二法门来加载,只待拿dex按照google标准(classes.dex、classes2.dex、classesN.dex)排列好就是推行了,这里发出三三两两个技术点

是因为patch.dex和缓存下来dex里面来再的切近,当加载引用了又类的类时会促成pre-verify的缪,具体求参见QQ空间组织写的安卓App热补丁动态修复技术介绍
,这首文章详细分析了致pre-verify谬误的因由,文章里叫的化解方案是往有援被修复类的类似中插入一段落代码,并且于插入的这段代码所在的切近的dex必须是一个独立的dex,这个dex我们先准备好,叫做fastdex-runtime.dex,它的代码结构是

└── com
    └── dx168
        └── fastdex
            └── runtime
                ├── FastdexApplication.java
                ├── antilazyload
                │   └── AntilazyLoad.java
                └── multidex
                    ├── MultiDex.java
                    ├── MultiDexApplication.java
                    ├── MultiDexExtractor.java
                    └── ZipUtil.java

AntilazyLoad.java就是以流时为引用的接近
MultiDex.java是用来加载classes2.dex –
classesN.dex底保险,为了防项目没有依赖MultiDex,所以将MultiDex的代码copy到了咱们的package下
FastdexApplication.java的作用后在游说

组成我们的品种用以全量打包前将app/build/intermediates/transforms/jarMerging/debug/jars/1/1f/combined.jar中拥有的色代码的class全部动态插入代码(第三方库由于匪以咱们的修复范围外为此为了效率忽略掉),具体的做法是望所有的构造方法中添加对com.dx168.fastdex.runtime.antilazyload.AntilazyLoad的依,如下面的代码所示

//source class:
public class MainActivity {
}

==>

//dest class:
import com.dx168.fastdex.runtime.antilazyload.AntilazyLoad;
public class MainActivity {
    public MainActivity() {
        System.out.println(Antilazyload.str);
    }
}

动态往class文件被插入代码用的凡asm,我拿做测试的时候找到的部分有关材料与代码都放至了github上面接触自己查看,代码比较多只贴出有,具体要查看ClassInject.groovy

 private static class MyClassVisitor extends ClassVisitor {
    public MyClassVisitor(ClassVisitor classVisitor) {
        super(Opcodes.ASM5, classVisitor);
    }

    @Override
    public MethodVisitor visitMethod(int access,
                                     String name,
                                     String desc,
                                     String signature,
                                     String[] exceptions) {
        //判断是否是构造方法
        if ("<init>".equals(name)) {
            MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
            MethodVisitor newMethod = new AsmMethodVisit(mv);
            return newMethod;
        } else {
            return super.visitMethod(access, name, desc, signature, exceptions);
        }
    }
}

static class AsmMethodVisit extends MethodVisitor {
    public AsmMethodVisit(MethodVisitor mv) {
        super(Opcodes.ASM5, mv);
    }

    @Override
    public void visitInsn(int opcode) {
        if (opcode == Opcodes.RETURN) {
            //访问java/lang/System的静态常量out
            mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            //访问AntilazyLoad的静态变量
            mv.visitFieldInsn(GETSTATIC, "com/dx168/fastdex/runtime/antilazyload/AntilazyLoad", "str", "Ljava/lang/String;");
            //调用out的println打印AntilazyLoad.str的值
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        }
        super.visitInsn(opcode);
    }
}

===============
处理终结pre-verify问题,接下去并且冒出坑了,当补丁dex从好后如缓存的dex有少数只(classes.dex
classes2.dex),那么合并dex后底逐条就是
fastdex-runtime.dex 、patch.dex、classes.dex 、classes2.dex
(patch.dex必须在缓存的dex之前才会给修复)

fastdex-runtime.dex  => classes.dex
patch.dex            => classes2.dex
classes.dex          => classes3.dex
classes2.dex         => classes4.dex

在讲解transformClassesWithMultidexlistForDebug职责时有说过程序入口Application的问题,假如patch.dex中不分包入口Application,apk启动之时光势必会报类找不交之荒谬,那么怎么化解之题目为

    1. 率先只方案:
      transformClassesWithMultidexlistForDebug职责中输出的maindexlist.txt中拥有的class都踏足patch.dex的变
    1. 亚种植方案:
      本着品种的入口Application做代办,并将这代理类放在第一独dex里面,项目之dex按照顺序放在后面

先是种方案方案由要为maindexlist.txt中大量的类似与了补丁的变型,与前尽量减少class文件与dex生成的思维是互相冲突之,效率相对于次独方案于没有,另外一个缘故是无能为力确保项目之Application中采用了MultiDex;

仲栽方案并未上述问题,但是若项目代码中有使getApplication()做强转就会有题目(参考issue#2),instant
run也会发生同一的问题,它的做法是hook系统的api运行期把Application还原回来,所以强转就未见面起题目了,请参考MonkeyPatcher.java(需要翻墙才能够打开,如果看无了便参照FastdexApplication.java的monkeyPatchApplication方法)

归结最终挑选了第二种植方案以下是fastdex-runtime.dex中代理Application的代码

public class FastdexApplication extends Application {
    public static final String LOG_TAG = "Fastdex";
    private Application realApplication;

    //从manifest文件的meta_data中获取真正的项目Application类
    private String getOriginApplicationName(Context context) {
        ApplicationInfo appInfo = null;
        try {
            appInfo = context.getPackageManager().getApplicationInfo(getPackageName(), PackageManager.GET_META_DATA);
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        String msg = appInfo.metaData.getString("FASTDEX_ORIGIN_APPLICATION_CLASSNAME");
        return msg;
    }

    private void createRealApplication(Context context) {
        String applicationClass = getOriginApplicationName(context);
        if (applicationClass != null) {
            Log.d(LOG_TAG, new StringBuilder().append("About to create real application of class name = ").append(applicationClass).toString());

            try {
                Class realClass = Class.forName(applicationClass);
                Constructor constructor = realClass.getConstructor(new Class[0]);
                this.realApplication = ((Application) constructor.newInstance(new Object[0]));
                Log.v(LOG_TAG, new StringBuilder().append("Created real app instance successfully :").append(this.realApplication).toString());
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        } else {
            this.realApplication = new Application();
        }
    }

    protected void attachBaseContext(Context context) {
        super.attachBaseContext(context);
        MultiDex.install(context);
        createRealApplication(context);

        if (this.realApplication != null)
            try {
                Method attachBaseContext = ContextWrapper.class
                        .getDeclaredMethod("attachBaseContext", new Class[]{Context.class});

                attachBaseContext.setAccessible(true);
                attachBaseContext.invoke(this.realApplication, new Object[]{context});
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
    }

    public void onCreate() {
        super.onCreate();

        if (this.realApplication != null) {
            this.realApplication.onCreate();
        }
    }
    ......
}

因前的任务说明生成manifest文件的天职是processDebugManifest,我们只需要在是任务执行完毕后做处理,创建一个实现类似为FastdexManifestTask的职责,核心代码如下

def ns = new Namespace("http://schemas.android.com/apk/res/android", "android")
def xml = new XmlParser().parse(new InputStreamReader(new FileInputStream(manifestPath), "utf-8"))
def application = xml.application[0]
if (application) {
    QName nameAttr = new QName("http://schemas.android.com/apk/res/android", 'name', 'android');
    def applicationName = application.attribute(nameAttr)
    if (applicationName == null || applicationName.isEmpty()) {
        applicationName = "android.app.Application"
    }
    //替换application的android.name节点
    application.attributes().put(nameAttr, "com.dx168.fastdex.runtime.FastdexApplication")
    def metaDataTags = application['meta-data']
    // remove any old FASTDEX_ORIGIN_APPLICATION_CLASSNAME elements
    def originApplicationName = metaDataTags.findAll {
        it.attributes()[ns.name].equals(FASTDEX_ORIGIN_APPLICATION_CLASSNAME)
    }.each {
        it.parent().remove(it)
    }
    // Add the new FASTDEX_ORIGIN_APPLICATION_CLASSNAME element
    //把原来的Application写入到meta-data中
    application.appendNode('meta-data', [(ns.name): FASTDEX_ORIGIN_APPLICATION_CLASSNAME, (ns.value): applicationName])
    // Write the manifest file
    def printer = new XmlNodePrinter(new PrintWriter(manifestPath, "utf-8"))
    printer.preserveWhitespace = true
    printer.print(xml)
}
File manifestFile = new File(manifestPath)
if (manifestFile.exists()) {
    File buildDir = FastdexUtils.getBuildDir(project,variantName)
    FileUtils.copyFileUsingStream(manifestFile, new File(buildDir,MANIFEST_XML))
    project.logger.error("fastdex gen AndroidManifest.xml in ${MANIFEST_XML}")
}

采用下的代码把这任务加进去并保管在processDebugManifest职责尽了后行

project.afterEvaluate {
    android.applicationVariants.all { variant ->
        def variantOutput = variant.outputs.first()
        def variantName = variant.name.capitalize()

        //替换项目的Application为com.dx168.fastdex.runtime.FastdexApplication
        FastdexManifestTask manifestTask = project.tasks.create("fastdexProcess${variantName}Manifest", FastdexManifestTask)
        manifestTask.manifestPath = variantOutput.processManifest.manifestOutputFile
        manifestTask.variantName = variantName
        manifestTask.mustRunAfter variantOutput.processManifest

        variantOutput.processResources.dependsOn manifestTask
    }
}

处理终结后manifest文件application节点android.name属性的价就改成了com.dx168.fastdex.runtime.FastdexApplication,并且把原种的Application的讳写副到meta-data中,用来运行期给FastdexApplication去读取

<meta-data android:name="FASTDEX_ORIGIN_APPLICATION_CLASSNAME" android:value="com.dx168.fastdex.sample.SampleApplication"/>

==============================

简介

H.264/AVC
项目意向创建同栽视频正式。与旧专业比,它会当重新低带宽下提供优质视频(换言之,只有
MPEG-2,H.263 或 MPEG-4 第 2
有些之一半带富或更少),也未多极其多设计复杂度使得无法落实或实现资金过大。另一样目的是提供足够的八面玲珑以当各种以、网络及系统被行使,包括大、低带宽,高、低视频分辨率,广播,DVD
存储,RTP/IP 网络,以及 ITU-T 多媒体公用电话系统。

H.264/AVC
包含了相同文山会海新的性状,使得她于打以前的编解码器不但能够又实用的拓展编码,还会于各种网络环境下的施用中应用。这样的技巧基础为
H.264 成为包括 YouTube
在内的在线视频公司利用它当作重大的编解码器,但是采取它们并无是一模一样码特别自在的事体,理论及说用
H.264 需要上交不菲的专利费用。

全量打包时的流水线:
  • 1、合并有的class文件特别成一个jar包
  • 2、扫描所有的花色代码并且以构造方法里补充加对fastdex.runtime.antilazyload.AntilazyLoad类的赖
    如此做的目的是以解决class verify的题目,
    详情请圈
    安卓App热补丁动态修复技术介绍
  • 3、对项目代码做快照,为了以后补丁打包时对比那些java文件发出了变化
  • 4、对眼前种之之所以依赖做快照,为了以后补丁打包时对比依赖是否发了扭转,如果转得免去缓存
  • 5、调用真正的transform生成dex
  • 6、缓存生成的dex,并且将fastdex-runtime.dex插入到dex列表中,假如生成了少数只dex,classes.dex
    classes2.dex 需要做一下操作
    fastdex-runtime.dex => classes.dex
    classes.dex => classes2.dex
    classes2.dex => classes3.dex
    接下来运行期在入口Application(fastdex.runtime.FastdexApplication)使用MultiDex把具备的dex加载进来
  • @see
    fastdex.build.transform.FastdexDexTransform
  • 7、保存资源映射表,为了保持id的价值一致,详情看
  • @see
    fastdex.build.task.FastdexResourceIdTask

FFmpeg 视频转换成为 gif

发一个特地实用之求,在网上发现了一个专门有意思之视频想将她换成为一个动态表情,作为一个
IT
从业者,我先是单想到的未是下充斥一个转码器,也无是错开探寻一个在线转换网站,直接使用手边的家伙
FFmpeg,瞬间就算形成了转码:

ffmpeg -ss 10 -t 10  -i tutu.mp4  -s 80x60  tutu.gif
## -ss 指从 10s 开始转码,-t 指转换 10s 的视频 -s

打包流程

简介

VP9 的开销从 2011 年第三季开始,目标是以跟画质下,比 VP8 编码减少
50%的文件大小,另一个目标虽是若以编码效率达跨 HEVC 编码。

2012 年 12 月 13 日,Chromium 浏览器在了 VP9 编码的支撑。Chrome
浏览器虽然是当 2013 年 2 月 21 日初始支持 VP9 编码的视频播放。

Google 宣布会在 2013 年 6 月 17 日完成 VP9 编码的制定干活,届时Chrome
浏览器将会管 VP9 编码默认引导。2014 年 3 月 18 日,Mozilla 以 Firefox
浏览器中在了 VP9 的支撑。

2015 年 4 月 3 日,谷歌宣布了 libvpx1.4.0 增加了针对性 10 位和 12
位的比特深度支持、4:2:2 与 4:4:4 色度抽样,并 VP9 多为重编/解码。

品种地址:
https://github.com/typ0520/fastdex

H.264

庄之类型代码比较多,每次调试改动java文件后若将走近2分钟才能够走起,实在叫不了。在网上搜寻了同一不行堆配置参数为绝非那个肯定的效用,
尝试使用instant
run效果呢不过如此,然后以尝试使用freeline编译速度还好但不安静,每次失败后全量编译很耗费时间,既然没有好的方案就和好尝尝做。

HEVC 和 H.264 在不同分辨率下的比

跟 H.264/MPEG-4 相比,HEVC 的平分比特率减低值为:

分辨率 480P 720P 1080P 4K UHD
HEVC 52% 56% 62% 64%

可见码率下降了 60% 以上。

  • HEVC (H.265) 对 VP9 和 H.264 在码率节省上发生比充分之优势,在同 PSNR
    下独家节省了 48.3% 和 75.8%。
  • H.264 在编码时间上有英雄优势,对比 VP9 和 HEVC(H.265) ,HEVC 是 VP9
    的6倍增,VP9 凡是 H.264 的濒临 40 加倍

正文就授权微信公众号:鸿洋(hongyangAndroid)原创首发

专利许可

2013 年三月,Google 与 MPEG LA 及 11 只专利持有者达成协议,让Google 获取
VP8 以及其前的 VPx 等编码所可能侵犯的专利授权,同时 Google
也足以无偿再次授权相关专利为 VP8 的用户,此协议而适用于下一致代 VPx
编码。至此 MPEG LA 放弃成立 VP8 专利集中授权联盟,VP8
的用户以可确定义务使用此编码而毫无担心或的专利侵权授权金的题材。

开发了以上功能后举行下的季不好打包做时间相比(其实就做一样不行并无是绝准确,做几十糟糕测试取时的平均值这样才最好本)
  • 1、删除build目录第一不成全量打包(不开启fastdex)

    BUILD SUCCESSFUL
    
      Total time: 1 mins 46.678 secs
      Task spend time:
        437ms  :app:prepareComAndroidSupportAppcompatV72340Library
         50ms  :app:prepareComAndroidSupportDesign2340Library
         66ms  :app:prepareComAndroidSupportSupportV42340Library
         75ms  :app:prepareComFacebookFrescoImagepipeline110Library
         56ms  :app:prepareOrgXutilsXutils3336Library
        870ms  :app:mergeDebugResources
         93ms  :app:processDebugManifest
        777ms  :app:processDebugResources
       1200ms  :app:compileDebugJavaWithJavac
       3643ms  :app:transformClassesWithJarMergingForDebug
       5520ms  :app:transformClassesWithMultidexlistForDebug
      61770ms  :app:transformClassesWithDexForDebug
         99ms  :app:transformNative_libsWithMergeJniLibsForDebug
        332ms  :app:transformResourcesWithMergeJavaResForDebug
       2083ms  :app:packageDebug
        202ms  :app:zipalignDebug
    
  • 2、删除build目录第一差全量打包(开启fastdex)

    BUILD SUCCESSFUL
    
      Total time: 1 mins 57.764 secs
      Task spend time:
        106ms  :app:prepareComAndroidSupportAnimatedVectorDrawable2340Library
        107ms  :runtime:transformClassesAndResourcesWithSyncLibJarsForDebug
        416ms  :app:prepareComAndroidSupportAppcompatV72340Library
         67ms  :app:prepareComAndroidSupportSupportV42340Library
         76ms  :app:prepareComFacebookFrescoImagepipeline110Library
         53ms  :app:prepareOrgXutilsXutils3336Library
        111ms  :app:processDebugManifest
        929ms  :app:mergeDebugResources
        697ms  :app:processDebugResources
       1227ms  :app:compileDebugJavaWithJavac
       3237ms  :app:transformClassesWithJarMergingForDebug
       6225ms  :app:transformClassesWithMultidexlistForDebug
      78990ms  :app:transformClassesWithDexForDebug
        122ms  :app:transformNative_libsWithMergeJniLibsForDebug
        379ms  :app:transformResourcesWithMergeJavaResForDebug
       2050ms  :app:packageDebug
         77ms  :app:zipalignDebug
    
  • 3、在被fastdex第一浅全量打包好后,关掉fastdex修改sample工程的MainActivity.java

    BUILD SUCCESSFUL
    
    Total time: 1 mins 05.394 secs
    Task spend time:
       52ms  :app:mergeDebugResources
     2583ms  :app:compileDebugJavaWithJavac
    60718ms  :app:transformClassesWithDexForDebug
      101ms  :app:transformNative_libsWithMergeJniLibsForDebug
      369ms  :app:transformResourcesWithMergeJavaResForDebug
     2057ms  :app:packageDebug
       75ms  :app:zipalignDebug
    
  • 4、在打开fastdex第一赖全量打包好后,仍然被fastdex修改sample工程的MainActivity.java

    BUILD SUCCESSFUL
    
      Total time: 16.5 secs
      Task spend time:
        142ms  :app:processDebugManifest
       1339ms  :app:compileDebugJavaWithJavac
       3291ms  :app:transformClassesWithJarMergingForDebug
       4865ms  :app:transformClassesWithMultidexlistForDebug
       1005ms  :app:transformClassesWithDexForDebug
       2112ms  :app:packageDebug
         76ms  :app:zipalignDebug
    
打包编号 总时间 transform时间
1 1 mins 46.678s 61770 ms
2 1 mins 57.764s 78990 ms
3 1 mins 05.394s 60718 ms
4 16.5s 1005 ms

通过1与2对待发现,开启fastdex进行第一糟糕全量的于包时的流年花比无上马起来多矣10秒左右,这个根本是流入代码和IO上之出

由此2暨3针对比发现,开启fastdex进行补丁打包时的时日花比未开启快了60秒左右,这虽是期待已久的构建速度啊\_

==============================
正好激动一会就尼玛报了一个破绽百出,当修改activity_main.xml时向里面长一个控件

<TextView
    android:id="@+id/tv2"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

由出去的保险启动的时刻即便径直crash掉了

Caused by: java.lang.IllegalStateException: 
Required view 'end_padder' with ID 2131493007 for field 'tv1' was not found.
If this view is optional add '@Nullable' (fields) or '@Optional' (methods) annotation.
     at butterknife.internal.Finder.findRequiredView(Finder.java:51)
     at com.dx168.fastdex.sample.CustomView$$ViewBinder.bind(CustomView$$ViewBinder.java:17)
     at com.dx168.fastdex.sample.CustomView$$ViewBinder.bind(CustomView$$ViewBinder.java:12)
     at butterknife.ButterKnife.bind(ButterKnife.java:187)
     at butterknife.ButterKnife.bind(ButterKnife.java:133) 
     at com.dx168.fastdex.sample.CustomView.<init>(CustomView.java:20) 
     ......
     at dalvik.system.NativeStart.main(Native Method) 

错误信息里之意思是吧CustomView的tv1字段,寻找id=2131493007的view时尚无找到,先倒编译报错的apk,�找到报错的地方CustomView$$ViewBinder.bind

public class CustomView$$ViewBinder<T extends CustomView>
        implements ViewBinder<T>
{
    public CustomView$$ViewBinder()
    {
        System.out.println(AntilazyLoad.str);
    }

    public Unbinder bind(Finder paramFinder, T paramT, Object paramObject)
    {
        InnerUnbinder localInnerUnbinder = createUnbinder(paramT);
        paramT.tv1 = ((TextView)paramFinder.castView((View)paramFinder
                .findRequiredView(paramObject, 2131493007, "field 'tv1'"), 2131493007, "field 'tv1'"));
        paramT.tv3 = ((TextView)paramFinder.castView((View)paramFinder
                .findRequiredView(paramObject, 2131493008, "field 'tv3'"), 2131493008, "field 'tv3'"));
        return localInnerUnbinder;
    }
    ......
}

CustomView$$ViewBinder这个看似是ButterKnife动态生成的,这个价值的自是CustomView的tv1字段点的笺注,CustomView.class反编译后如下

public class CustomView extends LinearLayout 
{
    @BindView(2131493007)
    TextView tv1;
    @BindView(2131493008)
    TextView tv3;

    public CustomView(Context paramContext, AttributeSet paramAttributeSet)
    {
        super(paramContext, paramAttributeSet);
        inflate(paramContext, 2130968632, this);
        ButterKnife.bind(this);
        this.tv3.setText(2131099697);
        MainActivity.aa();
        System.out.println(AntilazyLoad.str);
    }
}

相此是休是当意外,CustomView的源码明明是

public class CustomView extends LinearLayout {
    @BindView(R.id.tv1)  TextView tv1;
    @BindView(R.id.tv3)  TextView tv3;

    public CustomView(Context context, AttributeSet attrs) {
        super(context, attrs);
        inflate(context,R.layout.view_custom,this);
        ButterKnife.bind(this);

        tv3.setText(R.string.s3);
        MainActivity.aa();
    }
}

�在编译以后R.id.tv1怎么就改成数字2131493007了啊,原因是java编译器做了一个属性优化,如果发现来文件引用的是一个涵盖final描述吻合的常量,会一直开值copy

反倒编译最后一赖编译成功时的R.class结果如下(
app/build/intermediates/classes/debug/com/dx168/fastdex/sample/R.class)

public static final R {
    public static final class id {
        ......

        public static final int tv1 = 2131493008;
        public static final int tv2 = 2131492977;
        public static final int tv3 = 2131493009;

        ......

        public id() {
        }
    }
}

经分析,当全量打包时R.id.tv1 =
2131493007,由于R文件中之id都是final的,所以引用R.id.tv1的地方都给轮换为它对应之值2131493007了;当当activity_layout.xml中上加名啊tv2的控件,然后进行补丁打包时R.id.tv1的值变成了2131493008,而缓存的dex对诺节点的值还是2131493007,所以在搜寻id为2131493007针对诺的控件时盖找不交要是挂掉

自身之率先个想法是设以实施了processDebugResources职责后,把R文件里id类的享有字段的final描述吻合去丢就好将值copy这个编译优化绕过去
=>

public static final R {
    public static final class id {
        ......

        public static int tv1 = 2131493008;
        public static int tv2 = 2131492977;
        public static int tv3 = 2131493009;

        ......

        public id() {
        }
    }
}

扫除以后在实施compileDebugJavaWithJavac不时编译出错了

2.png

阴差阳错的案由是注解只能引用带final描述称的常量,除此之外switch语句的case也务必引用常量,具体要查看oracle对常量表达式的说明

若以这个方案,对id的援就不可知使常量表达式,像ButterKnife这样的view依赖注入的框架都未可知因此了,限制性太老是想法就是放弃了

再有一个思路就是修改aapt的源码�,使多次包时名字同样id的价值保持一致,这个一定能缓解但工作量太非常了即没有这样做,之后以了一个亏本中之办法,就是每次把品种被之所有类(除去第三方库)都踏足dex的变更,虽然缓解了此题目只是效率一下子暴跌好多,需要近40秒才能够跑起还是老缓慢

==============================
本条问题困扰了老,直到tinker开源后读它们的源码TinkerResourceIdTask.groovy常常,发现它们啊碰到了一样的题目,并生矣一个缓解方案,我们的现象以及tinker场景在此题目及是一致模型一样的,直接照抄代码就化解了这个问题,重要之业务说其三整,感谢tinker、感谢tinker、感谢tinker!!

tinker的缓解方案是,打补丁时因用户配置的resourceMapping文件(每次构建成功后输出的app/build/intermediates/symbols/debug/R.txt),生成public.xml和ids.xml然后放进app/build/intermediates/res/merged/debug/values目录里,aapt在处理的当儿会冲文件里之布置规则去变通,具体这块的规律请圈老罗的文章Android应用程序资源的编译和包装过程分析(在里搜索public.xml)这其中有详实的证明

以及齐并成我们的景象,第一潮全量打包成功以后将app/build/intermediates/symbols/debug/R.txt缓存下来,补丁打包在推行processResources任务面前,根据缓存的号子表R.txt去生成public.xml和ids.xml然后加大进app/build/intermediates/res/merged/debug/values目录里,这样同样名字的id前后的点滴次等构建值就是可知保持一致了,代码如下FastdexResourceIdTask.groovy

public class FastdexResourceIdTask extends DefaultTask {
    static final String RESOURCE_PUBLIC_XML = "public.xml"
    static final String RESOURCE_IDX_XML = "idx.xml"

    String resDir
    String variantName

    @TaskAction
    def applyResourceId() {
        File buildDir = FastdexUtils.getBuildDir(project,variantName)
        String resourceMappingFile = new File(buildDir,Constant.R_TXT)
        // Parse the public.xml and ids.xml
        if (!FileUtils.isLegalFile(resourceMappingFile)) {
            project.logger.error("==fastdex apply resource mapping file ${resourceMappingFile} is illegal, just ignore")
            return
        }
        File idsXmlFile = new File(buildDir,RESOURCE_IDX_XML)
        File publicXmlFile = new File(buildDir,RESOURCE_PUBLIC_XML)
        if (FileUtils.isLegalFile(idsXmlFile) && FileUtils.isLegalFile(publicXmlFile)) {
            project.logger.error("==fastdex public xml file and ids xml file already exist, just ignore")
            return
        }
        String idsXml = resDir + "/values/ids.xml";
        String publicXml = resDir + "/values/public.xml";
        FileUtils.deleteFile(idsXml);
        FileUtils.deleteFile(publicXml);
        List<String> resourceDirectoryList = new ArrayList<String>()
        resourceDirectoryList.add(resDir)

        project.logger.error("==fastdex we build ${project.getName()} apk with apply resource mapping file ${resourceMappingFile}")
        Map<RDotTxtEntry.RType, Set<RDotTxtEntry>> rTypeResourceMap = PatchUtil.readRTxt(resourceMappingFile)

        AaptResourceCollector aaptResourceCollector = AaptUtil.collectResource(resourceDirectoryList, rTypeResourceMap)
        PatchUtil.generatePublicResourceXml(aaptResourceCollector, idsXml, publicXml)
        File publicFile = new File(publicXml)

        if (publicFile.exists()) {
            FileUtils.copyFileUsingStream(publicFile, publicXmlFile)
            project.logger.error("==fastdex gen resource public.xml in ${RESOURCE_PUBLIC_XML}")
        }
        File idxFile = new File(idsXml)
        if (idxFile.exists()) {
            FileUtils.copyFileUsingStream(idxFile, idsXmlFile)
            project.logger.error("==fastdex gen resource idx.xml in ${RESOURCE_IDX_XML}")
        }
    }
}

project.afterEvaluate {
    android.applicationVariants.all { variant ->
        def variantOutput = variant.outputs.first()
        def variantName = variant.name.capitalize()

        //保持补丁打包时R文件中相同的节点和第一次打包时的值保持一致
        FastdexResourceIdTask applyResourceTask = project.tasks.create("fastdexProcess${variantName}ResourceId", com.dx168.fastdex.build.task.FastdexResourceIdTask)
        applyResourceTask.resDir = variantOutput.processResources.resDir
        applyResourceTask.variantName = variantName
        variantOutput.processResources.dependsOn applyResourceTask
    }
}

倘项目蒙之资源特别多,第一软补丁打包生成public.xml和ids.xml时会占据部分时光,最好做一样糟缓存,以后的补丁打包直接用缓存的public.xml和ids.xml**

==============================
缓解了端的原理性问题后,接下去继续召开优化,上面有说到*
transformClassesWithMultidexlistForDebug*任务之用意,由于使用了隔离Application的做法,所有的种代码都不在classes.dex中,这个用来分析那些项目遭到之好像需要在classes.dex的职责就是没意思了,直接禁掉它

project.afterEvaluate {
    android.applicationVariants.all { variant ->
        def variantName = variant.name.capitalize()

        def multidexlistTask = null
        try {
            multidexlistTask = project.tasks.getByName("transformClassesWithMultidexlistFor${variantName}")
        } catch (Throwable e) {
            //没有开启multiDexEnabled的情况下,会报这个任务找不到的异常
        }
        if (multidexlistTask != null) {
            multidexlistTask.enabled = false
        }
    }
}

禁掉以后,执行./gradle assembleDebug,在构建过程中悬挂掉了

:app:transformClassesWithMultidexlistForDebug SKIPPED
:app:transformClassesWithDexForDebug
Running dex in-process requires build tools 23.0.2.
For faster builds update this project to use the latest build tools.
UNEXPECTED TOP-LEVEL ERROR:
java.io.FileNotFoundException: /Users/tong/Projects/fastdex/app/build/intermediates/multi-dex/debug/maindexlist.txt (No such file or directory)
      at java.io.FileInputStream.open0(Native Method)
      at java.io.FileInputStream.open(FileInputStream.java:195)
      at java.io.FileInputStream.<init>(FileInputStream.java:138)
      at java.io.FileInputStream.<init>(FileInputStream.java:93)
      at java.io.FileReader.<init>(FileReader.java:58)
      at com.android.dx.command.dexer.Main.readPathsFromFile(Main.java:436)
      at com.android.dx.command.dexer.Main.runMultiDex(Main.java:361)
      at com.android.dx.command.dexer.Main.run(Main.java:275)
      at com.android.dx.command.dexer.Main.main(Main.java:245)
      at com.android.dx.command.Main.main(Main.java:106)
:app:transformClassesWithDexForDebug FAILED

FAILURE: Build failed with an exception.
......
BUILD FAILED

从今地方的日志的首先尽发现transformClassesWithMultidexlistForDebug职责真正禁止掉了,后面就一个SKIPPED的输出,但是实施transformClassesWithDexForDebug任务时报app/build/intermediates/multi-dex/debug/maindexlist.txt
(No such file or directory)
,原因是transformClassesWithDexForDebug职责会检讨这个文件是否有,既然这样即使在实行transformClassesWithDexForDebug任务面前创办一个缺损文件,看是不是还会见报错,代码如下

public class FastdexCreateMaindexlistFileTask extends DefaultTask {
    def applicationVariant

    @TaskAction
    void createFile() {
        if (applicationVariant != null) {
            File maindexlistFile = applicationVariant.getVariantData().getScope().getMainDexListFile()
            File parentFile = maindexlistFile.getParentFile()
            if (!parentFile.exists()) {
                parentFile.mkdirs()
            }

            if (!maindexlistFile.exists() || maindexlistFile.isDirectory()) {
                maindexlistFile.createNewFile()
            }
        }
    }
}

project.afterEvaluate {
    android.applicationVariants.all { variant ->
        def variantName = variant.name.capitalize()

        def multidexlistTask = null
        try {
            multidexlistTask = project.tasks.getByName("transformClassesWithMultidexlistFor${variantName}")
        } catch (Throwable e) {
            //没有开启multiDexEnabled的情况下,会报这个任务找不到的异常
        }
        if (multidexlistTask != null) {
            FastdexCreateMaindexlistFileTask createFileTask = project.tasks.create("fastdexCreate${variantName}MaindexlistFileTask", FastdexCreateMaindexlistFileTask)
            createFileTask.applicationVariant = variant

            multidexlistTask.dependsOn createFileTask
            multidexlistTask.enabled = false
        }
    }
}

重新执行./gradle assembleDebug

:app:transformClassesWithJarMergingForDebug UP-TO-DATE
:app:collectDebugMultiDexComponents UP-TO-DATE
:app:fastdexCreateDebugMaindexlistFileTask
:app:transformClassesWithMultidexlistForDebug SKIPPED
:app:transformClassesWithDexForDebug UP-TO-DATE
:app:mergeDebugJniLibFolders UP-TO-DATE
:app:transformNative_libsWithMergeJniLibsForDebug UP-TO-DATE
:app:processDebugJavaRes UP-TO-DATE
:app:transformResourcesWithMergeJavaResForDebug UP-TO-DATE
:app:validateConfigSigning
:app:packageDebug UP-TO-DATE
:app:zipalignDebug UP-TO-DATE
:app:assembleDebug UP-TO-DATE

BUILD SUCCESSFUL

Total time: 16.201 secs

这次构建成功验证创建空文件的这种方式中

=========

咱店之路于利用的历程遭到,发现补丁打包时虽然仅改变了一个java类,但构建时实施compileDebugJavaWithJavac任务要花费了13秒

BUILD SUCCESSFUL

Total time: 28.222 secs
Task spend time:
    554ms  :app:processDebugManifest
    127ms  :app:mergeDebugResources
   3266ms  :app:processDebugResources
  13621ms  :app:compileDebugJavaWithJavac
   3654ms  :app:transformClassesWithJarMergingForDebug
   1354ms  :app:transformClassesWithDexForDebug
    315ms  :app:transformNative_libsWithMergeJniLibsForDebug
    220ms  :app:transformResourcesWithMergeJavaResForDebug
   2684ms  :app:packageDebug

透过分析由我们运用了butterknife和tinker,这半独里头都因此到了javax.annotation.processing.AbstractProcessor这个接口做代码动态变化,所以种遭到的java文件要多,挨个扫描所有的java文件同时做操作会招大气之辰浪费,其实她们每次转的代码几乎都是一致的,因此若补丁打包时会管这个任务变成团结的实现,仅编译和快照对比变化的java文件,并将结果输出及app/build/intermediates/classes/debug,覆盖原来的class,能大大提高效率,部分代码如下,详情看FastdexCustomJavacTask.groovy

public class FastdexCustomJavacTask extends DefaultTask {
    ......

    @TaskAction
    void compile() {
        ......
        File androidJar = new File("${project.android.getSdkDirectory()}/platforms/${project.android.getCompileSdkVersion()}/android.jar")
        File classpathJar = FastdexUtils.getInjectedJarFile(project,variantName)
        project.logger.error("==fastdex androidJar: ${androidJar}")
        project.logger.error("==fastdex classpath: ${classpathJar}")
        project.ant.javac(
                srcdir: patchJavaFileDir,
                source: '1.7',
                target: '1.7',
                encoding: 'UTF-8',
                destdir: patchClassesFileDir,
                bootclasspath: androidJar,
                classpath: classpathJar
        )
        compileTask.enabled = false
        File classesDir = applicationVariant.getVariantData().getScope().getJavaOutputDir()
        Files.walkFileTree(patchClassesFileDir.toPath(),new SimpleFileVisitor<Path>(){
            @Override
            FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                Path relativePath = patchClassesFileDir.toPath().relativize(file)
                File destFile = new File(classesDir,relativePath.toString())
                FileUtils.copyFileUsingStream(file.toFile(),destFile)
                return FileVisitResult.CONTINUE
            }
        })
    }
}
project.afterEvaluate {
    android.applicationVariants.all { variant ->
        def variantName = variant.name.capitalize()
        Task compileTask = project.tasks.getByName("compile${variantName}JavaWithJavac")
        Task customJavacTask = project.tasks.create("fastdexCustomCompile${variantName}JavaWithJavac", com.dx168.fastdex.build.task.FastdexCustomJavacTask)
        customJavacTask.applicationVariant = variant
        customJavacTask.variantName = variantName
        customJavacTask.compileTask = compileTask
        compileTask.dependsOn customJavacTask
    }
}

执行./gradlew assembleDebug ,再来平等赖

BUILD SUCCESSFUL

Total time: 17.555 secs
Task spend time:
   1142ms  :app:fastdexCustomCompileDebugJavaWithJavac
     59ms  :app:generateDebugBuildConfig
    825ms  :app:processDebugManifest
    196ms  :app:mergeDebugResources
   3540ms  :app:processDebugResources
   3045ms  :app:transformClassesWithJarMergingForDebug
   1505ms  :app:transformClassesWithDexForDebug
    391ms  :app:transformNative_libsWithMergeJniLibsForDebug
    253ms  :app:transformResourcesWithMergeJavaResForDebug
   3413ms  :app:packageDebug

霎时间赶紧了10秒左右,good

=========
既是有缓存,就闹缓存过期的题目,假如我们上加了有第三方库的依赖性(依赖关系发生变化),并且于路代码中援了它们,如果不拔除缓存打出去的担保运行起来后肯定会包类找不至,所以需要处理是事情。
第一怎么用到靠关系呢?通过以下代码可以博一个因列表

project.afterEvaluate {
    project.configurations.all.findAll { !it.allDependencies.empty }.each { c ->
        if (c.name.toString().equals("compile")
                || c.name.toString().equals("apt")
                || c.name.toString().equals("_debugCompile".toString())) {
            c.allDependencies.each { dep ->
                String depStr =  "$dep.group:$dep.name:$dep.version"
                println("${depStr}")
            }
        }
    }
}

输入如下

com.dialonce:dialonce-android:2.3.1
com.facebook.fresco:fresco:1.1.0
com.google.guava:guava:18.0
......
com.android.support:design:23.4.0
com.bigkoo:alertview:1.0.2
com.bigkoo:pickerview:2.0.8

好于率先糟糕全量打包时,和浮动项目源码目录快照的跟一个时间点,获取一卖当前底仗列表并保存下去,当补丁打包时以赢得一卖当前底凭列表,与事先封存的犯对照,如果发生变化就拿缓存清除掉

此外最好好提供一个再接再厉消除缓存的职责

public class FastdexCleanTask extends DefaultTask {
    String variantName

    @TaskAction
    void clean() {
        if (variantName == null) {
            FastdexUtils.cleanAllCache()
        }
        else {
            FastdexUtils.cleanCache(project,variantName)
        }
    }
}

先行来一个革除所有缓存的任务

project.tasks.create("fastdexCleanAll", FastdexCleanTask)

下一场在因buildType、flavor创建对应之铲除任务

android.applicationVariants.all { variant ->
    def variantName = variant.name.capitalize()
    //创建清理指定variantName缓存的任务(用户触发)
    FastdexCleanTask cleanTask = project.tasks.create("fastdexCleanFor${variantName}", FastdexCleanTask)
    cleanTask.variantName = variantName
}

==============================

(一)采集

凡事项目之代码目前既开源了 https://github.com/typ0520/fastdex

苟您嗜本文就来吃我们star吧

=============
加紧apk的构建速度,如何拿编译时间打130秒降到17秒
加紧apk的构建速度,如何拿编译时间打130秒降到17秒(二)

(五)现代播放器原理

横流: 本文所有的代码、gradle任务名、任务输出路径、全部用到debug这个buildType作说明

优化构建速度首先要找到那些环节造成构建速度如此慢,把下部的代码放进app/build.gradle里把工夫花超过50ms的天职时间打印出来

 public class BuildTimeListener implements TaskExecutionListener, BuildListener {
    private Clock clock
    private times = []

    @Override
    void beforeExecute(Task task) {
        clock = new org.gradle.util.Clock()
    }

    @Override
    void afterExecute(Task task, TaskState taskState) {
        def ms = clock.timeInMs
        times.add([ms, task.path])

        //task.project.logger.warn "${task.path} spend ${ms}ms"
    }

    @Override
    void buildFinished(BuildResult result) {
        println "Task spend time:"
        for (time in times) {
            if (time[0] >= 50) {
                printf "%7sms  %s\n", time
            }
        }
    }

    ......
}

project.gradle.addListener(new BuildTimeListener())

执行./gradlew assembleDebug,经过漫长的守候取以下输出

Total time: 1 mins 39.566 secs
Task spend time:
     69ms  :app:prepareComAndroidSupportAnimatedVectorDrawable2340Library
    448ms  :app:prepareComAndroidSupportAppcompatV72340Library
     57ms  :app:prepareComAndroidSupportDesign2340Library
     55ms  :app:prepareComAndroidSupportSupportV42340Library
     84ms  :app:prepareComFacebookFrescoImagepipeline110Library
     69ms  :app:prepareComSquareupLeakcanaryLeakcanaryAndroid14Beta2Library
     60ms  :app:prepareOrgXutilsXutils3336Library
     68ms  :app:compileDebugRenderscript
    265ms  :app:processDebugManifest
   1517ms  :app:mergeDebugResources
    766ms  :app:processDebugResources
   2897ms  :app:compileDebugJavaWithJavac
   3117ms  :app:transformClassesWithJarMergingForDebug
   7899ms  :app:transformClassesWithMultidexlistForDebug
  65327ms  :app:transformClassesWithDexForDebug
    151ms  :app:transformNative_libsWithMergeJniLibsForDebug
    442ms  :app:transformResourcesWithMergeJavaResForDebug
   2616ms  :app:packageDebug
    123ms  :app:zipalignDebug

打者的输出可以发现总的构建时间也100秒左右(上面的出口不是按部就班真的的履行顺序输出的),transformClassesWithDexForDebug任务是极度缓慢的消耗了65秒,它就是咱们用重点优化的职责,首先说下构建过程中要任务之来意,方便了解后面的hook点

mergeDebugResources职责的企图是解压所有的aar包输出到app/build/intermediates/exploded-aar,并且把具有的资源文件合并到app/build/intermediates/res/merged/debug目录里

processDebugManifest职责是拿所有aar包里之AndroidManifest.xml中的节点,合并及品种之AndroidManifest.xml中,并冲app/build.gradle中即buildType的manifestPlaceholders配置内容替换manifest文件中的占据位符,最后输出及app/build/intermediates/manifests/full/debug/AndroidManifest.xml

processDebugResources的作用

  • 1、调用aapt生成项目以及所有aar依赖的R.java,输出到app/build/generated/source/r/debug目录
  • 2、生成资源索引文件app/build/intermediates/res/resources-debug.ap_
  • 3、把符号表输出到app/build/intermediates/symbols/debug/R.txt

compileDebugJavaWithJavac夫职责是用来拿java文件编译成class文件,输出的不二法门是app/build/intermediates/classes/debug
编译的输入目录有

  • 1、项目源码目录,默认路径是app/src/main/java,可以由此sourceSets的dsl配置,允许发生多单(打印project.android.sourceSets.main.java.srcDirs可以查看时备的源码路径,具体部署好参照android-doc
  • 2、app/build/generated/source/aidl
  • 3、app/build/generated/source/buildConfig
  • 4、app/build/generated/source/apt(继承javax.annotation.processing.AbstractProcessor做动态代码生成的局部仓房,输出在斯目录,具体可参见Butterknife

    Tinker)的代码

transformClassesWithJarMergingForDebug的意是将compileDebugJavaWithJavac职责之输出app/build/intermediates/classes/debug,和app/build/intermediates/exploded-aar中兼有的classes.jar和libs里之jar包作为输入,合并起来输出到app/build/intermediates/transforms/jarMerging/debug/jars/1/1f/combined.jar,我们于出中因第三方库的当儿偶然报duplicate
entry:xxx 的荒唐,就是为在集合之经过中于不同jar包里发现了同一路线的类似

transformClassesWithMultidexlistForDebug夫任务花费的时吗格外丰富即8秒,它发出有限单意

  • 1、扫描项目之AndroidManifest.xml文件和分析类里的负关系,计算出那些看似必须放在第一单dex里面,最后把分析的结果写到app/build/intermediates/multi-dex/debug/maindexlist.txt文件里
  • 2、生成混淆配置起输出到app/build/intermediates/multi-dex/debug/manifest_keep.txt文件里

品种里之代码入口是manifest中application节点的习性android.name配置的接轨自Application的接近,在android5.0先的本子系统就见面加载一个dex(classes.dex),classes2.dex
…….classesN.dex
一般是使android.support.multidex.MultiDex加载的,所以要是进口的Application类不在classes.dex里5.0之下肯定会挂掉,另外当入口Application依赖之好像非以classes.dex时初始化的下啊会见因类似找不交如果挂掉,还有如混淆的时节类名转移掉了为会盖对承诺不了如果挂掉,综上所述就是这任务的用意

transformClassesWithDexForDebug其一职责的意是将带有有class文件之jar包转换为dex,class文件进一步多换的越慢
输入的jar包路径是app/build/intermediates/transforms/jarMerging/debug/jars/1/1f/combined.jar
输出dex的目是build/intermediates/transforms/dex/debug/folders/1000/1f/main

***顾编写gradle插件时如果用采用方面这些途径不要硬编码的计写很,最好自Android
gradle api中失得路径,防止以后来变更

做方面的这些消息要要优化的凡transformClassesWithDexForDebug本条任务,我的思路是率先涂鸦全量打包实行完毕transformClassesWithDexForDebug任务后将变化的dex缓存下来,并且在实践此职责面前对现阶段具有的java源文件举行快照,以后补丁打包的时节经过时备的java文件信息及事先的快照做比,找有转变的java文件就获取那些class文件发生变化,然后把app/build/intermediates/transforms/jarMerging/debug/jars/1/1f/combined.jar中尚无变之class移除掉,仅拿变化class送去生成dex,然后选取同一种热修复方案将此dex当做补丁dex加载进来,有思路了后面就是攻占各个技术点

==============================

VP9

此地对包裹的流水线做下总结

基本原理

那么为何巨大的老视频可以编码成特别粗的视频也?这间的技巧是啊为?
核心思想就是去冗余信息:

  • 空间冗余:图像相邻像素之间有较强的相关性
  • 光阴冗余:视频序列的邻座图像里内容类同
  • 编码冗余:不同像素值出现的几率不同
  • 视觉冗余:人之视觉系统针对一些细节无灵动
  • 知识冗余:规律性的组织可由于先验知识以及背景知识得到

视频本质上称是同多元图片连续快速的播放,最简单易行的削减方式尽管是针对性每一样轴图片展开削减,例如比较古老的
MJPEG
编码就是这种编码方式,这种编码方式只生帧内编码,利用空间达到之取样预测来编码。形象之比喻就是拿每帧都作同布置图片,采用
JPEG
的编码格式对图片进行削减,这种编码只考虑了一样摆放图纸内之冗余信息压缩,如图
1,绿色的有就是眼下用编码的区域,灰色就是绝非编码的区域,绿色区域可以因现已编码的一对进行预测(绿色的左边,下边,左下等)。

图1

然帧和帧之间以时之相关性,后续开发有了一些较高档的编码器可以采取帧间编码,简单点说就算是通过搜索算法选定了帧上的一些区域,然后通过测算时帧和内外参考帧的往量差进行编码的相同种植样式,通过下面两个图
2
连续帧我们得观看,滑雪之校友是无止境位移的,但事实上是雪景在向后各项移,P
帧通过参考帧(I 或另 P
帧)就可拓展编码了,编码之后的高低很小,压缩比非常强。

图 2

兴许有同学对当时半摆设图片怎么来之感恩戴德兴趣,这里用了 FFmpeg
的蝇头行命令来促成,具体 FFmpeg 的更多内容请圈后续章节:

  • 首先行生成带有移动矢量的视频
  • 第二实践把各个一样轴都输出成图

ffmpeg  -flags2 +export_mvs -i tutu.mp4 -vf codecview=mv=pf+bf+bb tutudebug2.mp4

ffmpeg -i tutudebug2.mp4 'tutunormal-%03d.bmp'

而外空间冗余和时空冗余的回落,主要还有编码压缩和视觉减少,下面是一个编码器主要的流程图:

图 3

图 4

希冀 3、图 4 两独流程,图 3 是帧内编码,图 4
是帧间编码,从图及看出底首要区别就是是第一步不一致,其实就有限单流程也是了合在一起的,我们司空见惯说之
I 帧和 P 帧就是分别下了帧内编码和帧间编码。

注: 本文对gradle task举行的认证还建立以关门instant run的前提下

VP9 的开源实现

  • libvpx

libvpx
是 VP9 的绝无仅有开源实现,由 Google 开发保护,里面来一部分代码是 VP8 和 VP9
公用的,其余分别是 VP8 和 VP9 的编解码实现。

连续的优化计划

  • 1、提高稳定性与容错性,这个是极端要之
  • 2、目前补丁打包的时段,是把没有变之类从app/build/intermediates/transforms/jarMerging/debug/jars/1/1f/combined.jar中移除,如果能够hook掉transformClassesWithJarMergingForDebug这个任务,仅将发生变化的class参与combined.jar的别,能够在IO上望发生过多之时刻
  • 3、目前叫品种源码目录做快照,使用的是文本copy的章程,如果能惟不过拿用之音写在文件文件里,能够当IO上看发生有岁月
  • 4、目前还尚无针对性libs目录中发生变化做监控,后续要补充及随即同样片
  • 5、apk的装速度较缓慢(尤其是ART下由在装置时对以做AOT编译,所以造成安装快特别慢,具体求参考张邵文大神的稿子Android
    N混合编译和对热补丁影响解析),通过socket把代码补丁和资源补丁发送给app,做到无安装

==============================

简介

VP8 凡是一个开花的视频压缩格式,最早由 On2 Technologies 开,随后由于
Google 发布。同时 Google 也发布了 VP8 编码的实做库:libvpx,以 BSD
授权条款的不二法门发行,随后也增大了专利使用权。而以经过一些争议过后,最终
VP8 的授权确认为一个绽放源代码授权。

现阶段支撑 VP8 的网页浏览器有 Opera、Firefox 和 Chrome。

H.264 的开源实现

  • openh264
  • x264

openh264
是思科实现之开源 H.264 编码,虽然 H.264
需要上缴不菲的专利费用,但是专利费有一个秋上限,思科把 OpenH264
实现的春专利费交满后,OpenH264 事实上便得免费自由的下了。

x264
x264凡是一个行使GPL授权的视频编码自由软件。x264 的根本作用在进行
H.264/MPEG-4 AVC 的视频编码,而不是作为解码器(decoder)之故。

除此之外开销问题比较来拘禁:

  • openh264 CPU 的占有相对 x264不及多
  • openh264 只支持 baseline profile,x264 支持再次多 profile

FFmpeg 录屏

由此一个有些例子看一下庸在 Mac OS 下面用 FFmpeg 进行录屏:

输入:

ffmpeg -f avfoundation -list_devices true -i ""

输出:

[AVFoundation input device @ 0x7fbec0c10940] AVFoundation video devices:
[AVFoundation input device @ 0x7fbec0c10940] [0] FaceTime HD Camera
[AVFoundation input device @ 0x7fbec0c10940] [1] Capture screen 0
[AVFoundation input device @ 0x7fbec0c10940] [2] Capture screen 1
[AVFoundation input device @ 0x7fbec0c10940] AVFoundation audio devices:
[AVFoundation input device @ 0x7fbec0c10940] [0] Built-in Microphone

被起了眼前装备支撑之具备输入设备的列表和号码,我本地有零星片显示器,所以 1
和 2 都是本人屏幕,可以选择同一片进行录屏。

翻看时葡京网上娱乐场的 H.264 编解码器:

输入:

ffmpeg -codecs | grep 264

输出:

 DEV.LS h264                 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (decoders: h264 h264_vda ) (encoders: libx264 libx264rgb )

查看时之 VP8 编解码器:

输入:

ffmpeg -codecs | grep vp8

输出:

  DEV.L. vp8                  On2 VP8 (decoders: vp8 libvpx ) (encoders: libvpx )

得选择用 vp8 或者 h264 做编码器

ffmpeg -r 30 -f avfoundation -i 1 -vcodec vp8 -quality realtime screen2.webm
# -quality realtime 用来优化编码器,如果不加在我的 Air 上帧率只能达到 2

or

ffmpeg -r 30 -f avfoundation -i 1 -vcodec h264 screen.mp4

然后用 ffplay 播放就可以了

ffplay screen.mp4

or

ffplay screen2.webp

专利许可

HEVC Advance 要求有所包括苹果、YouTube、Netflix、Facebook、亚马逊等使用
H.265 技术之情节制造商上缴内容收入的
0.5%用作技术使用费,而所有流媒体市场每年上约 1000
亿美元之范畴,且频频增强被,征收
0.5%决是千篇一律画大的资费。而且她们还从未放了设备制造商,其中电视厂商用支出每台
1.5 美元、移动装备厂商每令 0.8
美元的专利费。他们还是从不放开了蓝光设备播放器、游戏机、录像机这样的厂商,这些厂商必须支付每令
1.1 美元之费。最无法让人承受之是,HEVC Advance
的专利使用权追溯至了厂商的「」”,意思是事先曾经售的出品依旧要追缴费用。

x265 是出于
MulticoreWare 开发,并开源。采用 GPL
协议,但是资助是路之几乎单商家做了联盟可以于非 GPL
协议下用此软件。

FFmpeg

讲话到视频编码相关内容即不得不提一个巨大之软件包 — FFmpeg。

FFmpeg
是一个自由软件,可以运行音频和视频又格式的录影、转换、流功能,包含了
libavcodec ——这是一个用来多独品类面临音频和视频的解码器库,以及
libavformat ——一个板与视频格式转换库。

FFmpeg 这个单词遭的 FF 指的是 Fast Forward。有些新手写信给 FFmpeg
的品类领导,询问 FF 是未是象征 Fast Free 或者 Fast Fourier
等意思,FFmpeg 的项目主任回信说:「Just for the record, the original
meaning of FF in FFmpeg is Fast Forward…」

以此项目初期是出于 Fabrice Bellard 发起的,而今天凡由 Michael Niedermayer
在进展维护。许多FFmpeg的开发者同时为是 MPlayer 项目之分子,FFmpeg 在
MPlayer 项目中是于设计为服务器版本进行开发。

FFmpeg 下充斥地址是 : FFmpeg
Download

  • 足浏览器输入下载,目前支撑 Linux ,Mac OS,Windows
    三单主流的阳台,也可团结编译到 Android 或者 iOS 平台。
  • 要是是 Mac OS ,可以经过 brew 安装
    brew install ffmpeg --with-libvpx --with-libvorbis --with-ffplay

俺们好为此 FFmpeg
来做什么样有因此生有趣的事情呢?通过一样雨后春笋小尝试来拉动大家清楚 FFmpeg
的神奇与强硬。

(六)延迟优化

(三)编码和包装

遵循系列文章大纲之类,想复习之前文章的直接点击上链接:

专利许可

VP9 凡是一个放格式、无权利金的视频编码格式。

(七)SDK 性能测试模型

封装

介绍完了视频编码后,再来介绍部分封装。沿用前的比喻,封装好掌握啊使哪种货车去运输,也就算是媒体的容器。

所谓容器,就是把编码器生成的多媒体内容(视频,音频,字幕,章节信息相当)混合封装于一块儿的正经。容器使得不同多媒体内容并播放变得非常粗略,而容器的任何一个图就是吗多媒体内容提供索引,也就是说要无容器在的言辞一样总统影片而不得不从同开始看到最后,不能够拖动进度条(当然这种气象下有播放器会话比较丰富的工夫即创办索引),而且只要您不团结失去手动另外载入音频就是不曾声音,下面介绍几栽常见的封装格式和优缺点:

  1. AVI 格式(后缀为 .AVI): 它的英文全称为 Audio Video Interleaved
    ,即音频视频交错格式。它为 1992 年被 Microsoft 公司生产。
    这种视频格式的长处是图像质量好。由于无损AVI可以保存 alpha
    通道,经常吃我们应用。缺点最多,体积过于庞大,而且更加糟糕之是减少正式未联合,最常见的景就是是赛版本
    Windows 媒体播放器播放不了动用早期编码编辑的AVI格式视频,而低版本
    Windows
    媒体播放器又播放不了使最新编码编辑的AVI格式视频,所以我们当开展局部AVI格式的视频播放时会并发由于视频编码问题如导致的视频不可知播放还是就会播放,但存在无克调节播放进度及播音时只是发生声音没有图像等有莫名其妙的题目。

  2. DV-AVI 格式(后缀为 .AVI): DV的英文全称是 Digital Video Format
    ,是由于索尼、松下、JVC 等多下厂商联合提出的一样栽家用数字视频格式。
    数字摄像机就是应用这种格式记录视频数据的。它可以经过计算机的 IEEE 1394
    端口传输视频数据及计算机,也可以以电脑被修好之底视频数据回录到多少摄像机中。这种视频格式的文件扩展名吧是
    avi。电视台以录像带记录模拟信号,通过 EDIUS 由IEEE
    1394端口采集卡从录像带中搜集出来的视频就是是这种格式。

  3. QuickTime File Format 格式(后缀为 .MOV):
    美国Apple公司支付的如出一辙种植视频格式,默认的播放器是苹果的QuickTime。
    怀有比高的压缩比率和比较完美的视频清晰度等特点,并可以保存alpha通道。

  4. MPEG 格式(文件后缀可以是 .MPG .MPEG .MPE .DAT .VOB .ASF .3GP
    .MP4等) : 它的英文全称为 Moving Picture Experts
    Group,即走图像专家组格式,该专家组建为1988年,专门负责啊 CD
    建立视频与拍子标准,而成员都是也视频、音频及系统领域的技能专家。
    MPEG 文件格式是动图像压缩算法的国际标准。MPEG
    格式目前发三单缩减正式,分别是 MPEG-1、MPEG-2、和MPEG-4
    。MPEG-1、MPEG-2 目前曾经应用比较少,着重介绍
    MPEG-4,其制定为1998年,MPEG-4
    是为了播放流式媒体之过人质量视频使特意计划的,以要用最少的多寡获得最佳的图像质量。目前
    MPEG-4 最有吸引力的地方在她能保留接近被DVD画质的小体积视频文件。

  5. WMV 格式(后缀为.WMV .ASF): 它的英文全称为Windows Media
    Video,也是微软生产的一样种下独立编码方式并且可以直接以网上实时看到视频节目之文件压缩格式。
    WMV格式的要优点包括:本地或网络回放,丰富的流间关系及扩展性等。WMV
    格式需要以网站及播报,需要安装 Windows Media Player( 简称 WMP
    ),很无便宜,现在早已几乎无网站使用了。

  6. Real Video 格式(后缀为 .RM .RMVB): Real Networks
    公司所制定的音频视频压缩正式称为Real Media。
    用户可采用 RealPlayer
    根据不同的网传输速率制定出不同之压缩比率,从而实现在低速率的大网直达拓展影像数据实时传送和广播。RMVB
    格式:这是平种由RM视频格式升级延伸出底初视频格式,当然性能达到发生异常老之升级换代。RMVB
    视频为是所有比较显眼的优势,一统大小为700MB左右底 DVD
    影片,如果用其转录成同样品质之 RMVB 格式,其个头最多吧便 400MB
    左右。大家兴许注意到了,以前以网络上下载电影和视频的时,经常接触到
    RMVB
    格式,但是就时代的上扬这种格式为越来越多之再理想的格式替代,著名的人们影视字幕组在2013年早已宣布不再限于
    RMVB 格式视频。

  7. Flash Video 格式(后缀为 .FLV):由 Adobe Flash
    延伸出的底等同栽流行网络视频封装格式。随着视频网站的丰富,这个格式就很普及。

  8. Matroska 格式(后缀为
    .MKV):是同栽新的多媒体封装格式,这个封装格式可将多种不同编码的视频及16长长的或上述不同格式的韵律和语言不同之字幕封装到一个
    Matroska Media
    档内。它吧是里面同样种植开放源代码的多媒体封装格式。Matroska
    同时还可以提供充分好之竞相作用,而且比 MPEG 的方便、强大。

  9. MPEG2-TS 格式 (后缀为 .ts)(Transport
    Stream“传输流”;又如MTS、TS)是一致栽传输和仓储包含音效、视频以及通信协议各种数码的正统格式,用于数字电视广播系统,如DVB、ATSC、IPTV等等。
    MPEG2-TS 定义为 MPEG-2
    第一局部,系统(即原来之ISO/IEC标准13818-1还是ITU-T Rec. H.222.0)。
    Media Player Classic、VLC
    多媒体播放器等软件可以直接播放MPEG-TS文件。

当前,我们以流媒体传输,尤其是直播中关键用的虽是 FLV 和 MPEG2-TS
格式,分别用于 RTMP/HTTP-FLV 和 HLS 协议。

产一致冀我们用系统讲授视频直播的推流和导,尽请期待~

编码器的精选

面前梳理了一晃编码器的法则和基本流程,编码器经历了数十年的前行,已经起开头之仅支持帧内编码演进到今天的
H.265 和 VP9
为表示的初一代编码器,就现阶段有广大的编码器进行辨析,带大家探讨一下编码器的世界。

视频编码的含义

  • 固有视频数据存储空间十分,一个 1080P 的 7 s 视频需要 817 MB
  • 初视频数据传占带富大,10 Mbps 的拉动富传输上述 7 s 视频需要 11
    分钟

假如透过 H.264 编码压缩后,视频大小只有 708 k ,10 Mbps 的带宽仅仅要
500 ms
,可以满足实时传输的需求,所以从视频采访传感器收集来之原始视频势必要通过视频编码。

H.265 的开源实现

  • libde265
  • x265

libde265
HEVC 由 struktur 公司为开源许可证 GNU LesserGeneral Public License
(LGPL)
提供,观众得以于缓慢的网速下欣赏到嵩品质之像。跟以前基于H.264标准的解码器相比,libde265
HEVC 解码器可以将你的全高清内容带为多上两倍的受众,或者,减少 50%
流媒体播放所待的带来富。高清或者 4K/8K
超高清流媒体播发,低顺延/低带宽视频会议,以及完整的动设备覆盖。具有「拥塞感知」视频编码的康乐,十分称采取在
3/4G 和 LTE 网络。

VP9 和 H.264 和 HEVC 比较

Codec HEVC x264 vp9
HEVC -42.2% 32.6%
x264 75.8% 18.5%
vp9 48.3% -14.6%
Codec HEVC vs. VP9(in %) VP9 vs. x264 (in %)
Total Average 612 39399

引用 Comparative Assessment of H.265/MPEG-HEVC, VP9, and
H.264/MPEG-AVC Encoders for Low-Delay Video Applications
这首比较新的舆论对,低延迟视频进行编码的测试结果。

HEVC/H.265

VP8

(二)处理

FFmpeg 录制屏幕并直播

足持续扩大例子1,直播时屏幕的情,向大家介绍一下怎么通过几尽命令搭建筑一个测试用之直播服务:

Step 1:首先安装 docker:
访问 Docker
Download
,按操作系统下载安装。

Step 2:下载 nginx-rtmp 镜像:

docker pull chakkritte/docker-nginx-rtmp

Step 3:创建 nginx html 路径,启动 docker-nginx-rtmp

mkdir ~/rtmp

docker run -d -p 80:80 -p 1935:1935 -v ~/rtmp:/usr/local/nginx/html chakkritte/docker-nginx-rtmp

Step 4:推送屏幕录制到 nignx-rtmp

ffmpeg -y -loglevel warning -f avfoundation -i 2 -r 30 -s 480x320 -threads 2 -vcodec libx264  -f flv rtmp://127.0.0.1/live/test

Step 5:用 ffplay 播放

ffplay rtmp://127.0.0.1/live/test

总一下,FFmpeg
是只了不起的工具,可以由此它们做到很多平淡无奇的工作和实验,但是距提供真正可用的流媒体服务、直播服务还有挺多的劳作使召开,这点可参见七牛云发布之
七牛直播云服务

简介

赛效率视频编码(High Efficiency Video
Coding,简称HEVC)是同一栽视频压缩标准,被视为是 ITU-T H.264/MPEG-4 AVC
标准的后任。2004 年始由于 ISO/IEC Moving Picture Experts
Group(MPEG)和 ITU-T Video Coding Experts Group(VCEG)作为 ISO/IEC
23008-2 MPEG-H Part 2 或如作 ITU-T H.265 开始制订。第一版本的 HEVC/H.265
视频压缩标准于 2013 年 4 月 13
日被领吗国际电信联盟(ITU-T)的正统标准。HEVC
被当不但提升视频质量,同时为克上 H.264/MPEG-4 AVC
两倍的压缩率(等同于同一画面质量下比特率减少了 50%),可支撑 4K
分辨率甚至到超高清电视(UHDTV),最高分辨率可达成
8192×4320(8K分辨率)。

如果管整流媒体比喻成一个物流系统,那么编解码就是内部配货及装货的进程,这个进程很关键,它的快慢及减少比对物流体系的义大非常,影响物流系统的完整进度与资本。同样,对流媒体传输来说,编码为酷主要,它的编码性能、编码速度和编码压缩比会直接影响整个流媒体传输的用户体验及传导成本。

视频编码是视频直播技术多元文章的老三篇,是以系列一个不胜主要之一部分,是挪支付必修的功底教程,本篇文章由理论到实践一网自尽主流编码器。

专利许可

及 MPEG-2 第一有、第二局部,MPEG-4第二片同样,使用 H.264/AVC
的制品制造商和服务提供商需要往她们之活所采用的专利的主人支付专利许可费用。这些专利许可的根本源于是均等小叫
MPEG-LA LLC 的村办组织,该组织同 MPEG
标准化组织并未另外涉及,但是该团队为管理著 MPEG-2
第一有些系、第二有的视频、MPEG-4
第二有的视频以及其他一些技能的专利许可。

旁的专利许可则需要向其它一样寒名叫 VIA Licensing
的私房组织申请,这家店铺另外呢管理偏向音频压缩的正规化要 MPEG-2 AAC 及
MPEG-4 Audio 的专利许可。