chomium webrc hw h264分析报告

最新推荐文章于 2024-04-03 13:38:24 发布
最新推荐文章于 2024-04-03 13:38:24 发布
阅读量716 收藏
点赞数
分类专栏： Android 文章标签： chromium webrtc hwh264
转载请邮件联系我(hello@yeshen.org)，以取得授权，谢谢！https://yeshen.org
本文链接：https://blog.csdn.net/yeshennet/article/details/90237967
版权

本文主要解决几个问题

1.chromium是否支持硬解码？
2.chromium在硬解这个支持上是否存在系统差异性？
3.为什么H264在Android上会存在碎片化？

硬解和软解的区别？有什么标识？

硬解流畅度高一点，对设备性能要求较低，但是也需要硬件厂商支持。
在Android系统上。

  • 硬解码用的是MediaCodec。
  • 软解可以用ffmpeg/openH264。

chromium是否支持MediaCodeC？

是支持的。这个有点代码细节，我找到了对应的codereview内容：
https://codereview.chromium.org/2358683002/#ps1

chromium是如何做支持的？

从代码上来看(函数入口：isEncoderSupportedByDevice)。

  1. 系统小于KITKAT 4.4.4的一律不支持
  2. 在黑名单中的手机不支持：“SAMSUNG-SGH-I337”, “Nexus 7”, “Nexus 4”
  3. 硬件如果是Qcom、Exynos返回支持
QcomVp8(MimeTypes.VIDEO_VP8, "OMX.qcom.", Build.VERSION_CODES.KITKAT),
QcomH264(MimeTypes.VIDEO_H264, "OMX.qcom.", Build.VERSION_CODES.KITKAT),
ExynosVp8(MimeTypes.VIDEO_VP8, "OMX.Exynos.", Build.VERSION_CODES.M),
ExynosH264(MimeTypes.VIDEO_H264, "OMX.Exynos.", Build.VERSION_CODES.LOLLIPOP);

// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package org.chromium.media;
import android.annotation.TargetApi;
import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaCodecList;
import android.os.Build;
import org.chromium.base.Log;
import org.chromium.base.annotations.CalledByNative;
import org.chromium.base.annotations.JNINamespace;
import org.chromium.base.annotations.MainDex;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
/**
 * A collection of MediaCodec utility functions.
 */
@JNINamespace("media")
class MediaCodecUtil {
    private static final String TAG = "cr_MediaCodecUtil";
    // Codec direction.  Keep this in sync with media_codec_direction.h.
    static final int MEDIA_CODEC_DECODER = 0;
    static final int MEDIA_CODEC_ENCODER = 1;
    /**
     * Class to pass parameters from createDecoder()
     */
    @MainDex
    public static class CodecCreationInfo {
        public MediaCodec mediaCodec = null;
        public boolean supportsAdaptivePlayback = false;
    }
    @MainDex
    public static final class MimeTypes {
        public static final String VIDEO_MP4 = "video/mp4";
        public static final String VIDEO_WEBM = "video/webm";
        public static final String VIDEO_H264 = "video/avc";
        public static final String VIDEO_H265 = "video/hevc";
        public static final String VIDEO_VP8 = "video/x-vnd.on2.vp8";
        public static final String VIDEO_VP9 = "video/x-vnd.on2.vp9";
    }
    /**
     * Class to abstract platform version API differences for interacting with
     * the MediaCodecList.
     */
    @MainDex
    private static class MediaCodecListHelper {
        @TargetApi(Build.VERSION_CODES.LOLLIPOP)
        public MediaCodecListHelper() {
            if (hasNewMediaCodecList()) {
                mCodecList = new MediaCodecList(MediaCodecList.ALL_CODECS).getCodecInfos();
            }
        }
        @SuppressWarnings("deprecation")
        public int getCodecCount() {
            if (hasNewMediaCodecList()) return mCodecList.length;
            return MediaCodecList.getCodecCount();
        }
        @SuppressWarnings("deprecation")
        public MediaCodecInfo getCodecInfoAt(int index) {
            if (hasNewMediaCodecList()) return mCodecList[index];
            return MediaCodecList.getCodecInfoAt(index);
        }
        private boolean hasNewMediaCodecList() {
            return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP;
        }
        private MediaCodecInfo[] mCodecList;
    }
    /**
     * Return true if and only if name is a software codec.
     * @param name The codec name, e.g. from MediaCodecInfo.getName().
     */
    public static boolean isSoftwareCodec(String name) {
        // This is structured identically to libstagefright/OMXCodec.cpp .
        if (name.startsWith("OMX.google.")) return true;
        if (name.startsWith("OMX.")) return false;
        return true;
    }
    /**
     * Get a name of default android codec.
     * @param mime MIME type of the media.
     * @param direction Whether this is encoder or decoder.
     * @param requireSoftwareCodec Whether we require a software codec.
     * @return name of the codec.
     */
    @CalledByNative
    private static String getDefaultCodecName(
            String mime, int direction, boolean requireSoftwareCodec) {
        MediaCodecListHelper codecListHelper = new MediaCodecListHelper();
        int codecCount = codecListHelper.getCodecCount();
        for (int i = 0; i < codecCount; ++i) {
            MediaCodecInfo info = codecListHelper.getCodecInfoAt(i);
            int codecDirection = info.isEncoder() ? MEDIA_CODEC_ENCODER : MEDIA_CODEC_DECODER;
            if (codecDirection != direction) continue;
            if (requireSoftwareCodec && !isSoftwareCodec(info.getName())) continue;
            String[] supportedTypes = info.getSupportedTypes();
            for (int j = 0; j < supportedTypes.length; ++j) {
                if (supportedTypes[j].equalsIgnoreCase(mime)) return info.getName();
            }
        }
        Log.e(TAG, "Decoder for type %s is not supported on this device", mime);
        return "";
    }
    /**
     * Get a list of encoder supported color formats for specified MIME type.
     * @param mime MIME type of the media format.
     * @return a list of encoder supported color formats.
     */
    @CalledByNative
    private static int[] getEncoderColorFormatsForMime(String mime) {
        MediaCodecListHelper codecListHelper = new MediaCodecListHelper();
        int codecCount = codecListHelper.getCodecCount();
        for (int i = 0; i < codecCount; i++) {
            MediaCodecInfo info = codecListHelper.getCodecInfoAt(i);
            if (!info.isEncoder()) continue;
            String[] supportedTypes = info.getSupportedTypes();
            for (int j = 0; j < supportedTypes.length; ++j) {
                if (supportedTypes[j].equalsIgnoreCase(mime)) {
                    return info.getCapabilitiesForType(supportedTypes[j]).colorFormats;
                }
            }
        }
        return null;
    }
    /**
      * Check if a given MIME type can be decoded.
      * @param mime MIME type of the media.
      * @param secure Whether secure decoder is required.
      * @return true if system is able to decode, or false otherwise.
      */
    @CalledByNative
    private static boolean canDecode(String mime, boolean isSecure) {
        // TODO(liberato): Should we insist on software here?
        CodecCreationInfo info = createDecoder(mime, isSecure, false);
        if (info.mediaCodec == null) return false;
        try {
            info.mediaCodec.release();
        } catch (IllegalStateException e) {
            Log.e(TAG, "Cannot release media codec", e);
        }
        return true;
    }
    /**
     * Creates MediaCodec decoder.
     * @param mime MIME type of the media.
     * @param secure Whether secure decoder is required.
     * @param requireSoftwareCodec Whether a software decoder is required.
     * @return CodecCreationInfo object
     */
    static CodecCreationInfo createDecoder(
            String mime, boolean isSecure, boolean requireSoftwareCodec) {
        // Always return a valid CodecCreationInfo, its |mediaCodec| field will be null
        // if we cannot create the codec.
        CodecCreationInfo result = new CodecCreationInfo();
        assert result.mediaCodec == null;
        // Creation of ".secure" codecs sometimes crash instead of throwing exceptions
        // on pre-JBMR2 devices.
        if (isSecure && Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) return result;
        // Do not create codec for blacklisted devices.
        if (!isDecoderSupportedForDevice(mime)) {
            Log.e(TAG, "Decoder for type %s is not supported on this device", mime);
            return result;
        }
        try {
            // |isSecure| only applies to video decoders.
            if (mime.startsWith("video") && isSecure) {
                String decoderName =
                        getDefaultCodecName(mime, MEDIA_CODEC_DECODER, requireSoftwareCodec);
                if (decoderName.equals("")) return null;
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    // To work around an issue that we cannot get the codec info from the secure
                    // decoder, create an insecure decoder first so that we can query its codec
                    // info. http://b/15587335.
                    // Futhermore, it is impossible to create an insecure decoder if the secure
                    // one is already created.
                    MediaCodec insecureCodec = MediaCodec.createByCodecName(decoderName);
                    result.supportsAdaptivePlayback =
                            codecSupportsAdaptivePlayback(insecureCodec, mime);
                    insecureCodec.release();
                }
                result.mediaCodec = MediaCodec.createByCodecName(decoderName + ".secure");
            } else {
                if (requireSoftwareCodec) {
                    String decoderName =
                            getDefaultCodecName(mime, MEDIA_CODEC_DECODER, requireSoftwareCodec);
                    result.mediaCodec = MediaCodec.createByCodecName(decoderName);
                } else {
                    result.mediaCodec = MediaCodec.createDecoderByType(mime);
                }
                result.supportsAdaptivePlayback =
                        codecSupportsAdaptivePlayback(result.mediaCodec, mime);
            }
        } catch (Exception e) {
            Log.e(TAG, "Failed to create MediaCodec: %s, isSecure: %s, requireSoftwareCodec: %s",
                    mime, isSecure, requireSoftwareCodec ? "yes" : "no", e);
            result.mediaCodec = null;
        }
        return result;
    }
    /**
     * This is a way to blacklist misbehaving devices.
     * Some devices cannot decode certain codecs, while other codecs work fine.
     * @param mime MIME type as passed to mediaCodec.createDecoderByType(mime).
     * @return true if this codec is supported for decoder on this device.
     */
    @CalledByNative
    static boolean isDecoderSupportedForDevice(String mime) {
        // *************************************************************
        // *** DO NOT ADD ANY NEW CODECS WITHOUT UPDATING MIME_UTIL. ***
        // *************************************************************
        if (mime.equals("video/x-vnd.on2.vp8")) {
            // Only support VP8 on Android versions where we don't have to synchronously
            // tear down the MediaCodec on surface destruction because VP8 requires us to
            // completely drain the decoder before releasing it, which is difficult and
            // time consuming to do while the surface is being destroyed.
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) return false;
            if (Build.MANUFACTURER.toLowerCase(Locale.getDefault()).equals("samsung")) {
                // Some Samsung devices cannot render VP8 video directly to the surface.
                // Samsung Galaxy S4.
                // Only GT-I9505G with Android 4.3 and SPH-L720 (Sprint) with Android 5.0.1
                // were tested. Only the first device has the problem.
                // We blacklist popular Samsung Galaxy S4 models before Android L.
                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP
                        && (Build.MODEL.startsWith("GT-I9505")
                                   || Build.MODEL.startsWith("GT-I9500"))) {
                    return false;
                }
                // Samsung Galaxy S4 Mini.
                // Only GT-I9190 was tested with Android 4.4.2
                // We blacklist it and the popular GT-I9195 for all Android versions.
                if (Build.MODEL.startsWith("GT-I9190") || Build.MODEL.startsWith("GT-I9195")) {
                    return false;
                }
                // Some Samsung devices have problems with WebRTC.
                // We copy blacklisting patterns from software_renderin_list_json.cc
                // although they are broader than the bugs they refer to.
                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
                    // Samsung Galaxy Note 2, http://crbug.com/308721.
                    if (Build.MODEL.startsWith("GT-")) return false;
                    // Samsung Galaxy S4, http://crbug.com/329072.
                    if (Build.MODEL.startsWith("SCH-")) return false;
                    // Samsung Galaxy Tab, http://crbug.com/408353.
                    if (Build.MODEL.startsWith("SM-T")) return false;
                }
            }
            // MediaTek decoders do not work properly on vp8. See http://crbug.com/446974 and
            // http://crbug.com/597836.
            if (Build.HARDWARE.startsWith("mt")) return false;
        } else if (mime.equals("video/x-vnd.on2.vp9")) {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) return false;
            // MediaTek decoders do not work properly on vp9 before Lollipop. See
            // http://crbug.com/597836.
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP
                    && Build.HARDWARE.startsWith("mt")) {
                return false;
            }
        } else if (mime.equals("audio/opus")
                && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            return false;
        }
        // *************************************************************
        // *** DO NOT ADD ANY NEW CODECS WITHOUT UPDATING MIME_UTIL. ***
        // *************************************************************
        return true;
    }
    /**
     * Returns true if and only enabling adaptive playback is unsafe.  On some
     * device / os combinations, enabling it causes decoded frames to be
     * unusable.  For example, the S3 on 4.4.2 returns black and white, tiled
     * frames when this is enabled.
     */
    private static boolean isAdaptivePlaybackBlacklisted(String mime) {
        if (!mime.equals("video/avc") && !mime.equals("video/avc1")) {
            return false;
        }
        if (!Build.VERSION.RELEASE.equals("4.4.2")) {
            return false;
        }
        if (!Build.MANUFACTURER.toLowerCase(Locale.getDefault()).equals("samsung")) {
            return false;
        }
        return Build.MODEL.startsWith("GT-I9300") || // S3 (I9300 / I9300I)
                Build.MODEL.startsWith("SCH-I535"); // S3
    }
    /**
     * Returns true if the given codec supports adaptive playback (dynamic resolution change).
     * @param mediaCodec the codec.
     * @param mime MIME type that corresponds to the codec creation.
     * @return true if this codec and mime type combination supports adaptive playback.
     */
    @TargetApi(Build.VERSION_CODES.KITKAT)
    private static boolean codecSupportsAdaptivePlayback(MediaCodec mediaCodec, String mime) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT || mediaCodec == null) {
            return false;
        }
        try {
            MediaCodecInfo info = mediaCodec.getCodecInfo();
            if (info.isEncoder()) {
                return false;
            }
            if (isAdaptivePlaybackBlacklisted(mime)) {
                return false;
            }
            MediaCodecInfo.CodecCapabilities capabilities = info.getCapabilitiesForType(mime);
            return (capabilities != null)
                    && capabilities.isFeatureSupported(
                               MediaCodecInfo.CodecCapabilities.FEATURE_AdaptivePlayback);
        } catch (IllegalArgumentException e) {
            Log.e(TAG, "Cannot retrieve codec information", e);
        }
        return false;
    }
    // List of supported HW encoders.
    private static enum HWEncoderProperties {
        QcomVp8(MimeTypes.VIDEO_VP8, "OMX.qcom.", Build.VERSION_CODES.KITKAT),
        QcomH264(MimeTypes.VIDEO_H264, "OMX.qcom.", Build.VERSION_CODES.KITKAT),
        ExynosVp8(MimeTypes.VIDEO_VP8, "OMX.Exynos.", Build.VERSION_CODES.M),
        ExynosH264(MimeTypes.VIDEO_H264, "OMX.Exynos.", Build.VERSION_CODES.LOLLIPOP);
        private final String mMime;
        private final String mPrefix;
        private final int mMinSDK;
        private HWEncoderProperties(String mime, String prefix, int minSDK) {
            this.mMime = mime;
            this.mPrefix = prefix;
            this.mMinSDK = minSDK;
        }
        public String getMime() {
            return mMime;
        }
        public String getPrefix() {
            return mPrefix;
        }
        public int getMinSDK() {
            return mMinSDK;
        }
    }
    // List of devices with poor H.264 encoder quality.
    private static final String[] H264_ENCODER_MODEL_BLACKLIST = new String[] {
            // HW H.264 encoder on below devices has poor bitrate control - actual bitrates deviates
            // a lot from the target value.
            "SAMSUNG-SGH-I337", "Nexus 7", "Nexus 4"};
    /**
     * Creates MediaCodec encoder.
     * @param mime MIME type of the media.
     * @return CodecCreationInfo object
     */
    static CodecCreationInfo createEncoder(String mime) {
        // Always return a valid CodecCreationInfo, its |mediaCodec| field will be null
        // if we cannot create the codec.
        CodecCreationInfo result = new CodecCreationInfo();
        if (!isEncoderSupportedByDevice(mime)) return result;
        try {
            result.mediaCodec = MediaCodec.createEncoderByType(mime);
            result.supportsAdaptivePlayback = false;
        } catch (Exception e) {
            Log.e(TAG, "Failed to create MediaCodec: %s", mime, e);
        }
        return result;
    }
    /**
     * This is a way to blacklist misbehaving devices.
     * @param mime MIME type as passed to mediaCodec.createEncoderByType(mime).
     * @return true if this codec is supported for encoder on this device.
     */
    @CalledByNative
    static boolean isEncoderSupportedByDevice(String mime) {
        // MediaCodec.setParameters is missing for JB and below, so bitrate
        // can not be adjusted dynamically.
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
            return false;
        }
        // Check if this is supported HW encoder.
        if (mime.equals(MimeTypes.VIDEO_H264)) {
            // Check if device is in H.264 exception list.
            List<String> exceptionModels = Arrays.asList(H264_ENCODER_MODEL_BLACKLIST);
            if (exceptionModels.contains(Build.MODEL)) {
                Log.w(TAG, "Model: " + Build.MODEL + " has blacklisted H.264 encoder.");
                return false;
            }
        }
        MediaCodecListHelper codecListHelper = new MediaCodecListHelper();
        int codecCount = codecListHelper.getCodecCount();
        for (int i = 0; i < codecCount; ++i) {
            MediaCodecInfo info = codecListHelper.getCodecInfoAt(i);
            if (!info.isEncoder() || isSoftwareCodec(info.getName())) continue;
            String encoderName = null;
            for (String mimeType : info.getSupportedTypes()) {
                if (mimeType.equalsIgnoreCase(mime)) {
                    encoderName = info.getName();
                    break;
                }
            }
            if (encoderName == null) {
                continue; // No HW support in this codec; try the next one.
            }
            // Check if this is supported HW encoder.
            for (HWEncoderProperties codecProperties : HWEncoderProperties.values()) {
                if (!mime.equalsIgnoreCase(codecProperties.getMime())) continue;
                if (encoderName.startsWith(codecProperties.getPrefix())) {
                    if (Build.VERSION.SDK_INT < codecProperties.getMinSDK()) {
                        Log.w(TAG, "Codec " + encoderName + " is disabled due to SDK version "
                                        + Build.VERSION.SDK_INT);
                        continue;
                    }
                    Log.d(TAG, "Found target encoder for mime " + mime + " : " + encoderName);
                    return true;
                }
            }
        }
        Log.w(TAG, "HW encoder for " + mime + " is not available on this device.");
        return false;
    }
}

哪个版本？

code提交是在2016.10月，我检查了发布的版本号：https://chromereleases.googleblog.com/2016/10/

根据时间线推测是 chromium57 开始支持的。
PS：我在chromium58找到对应修改的代码，可以确认58是支持的。

H264在Android上会存在碎片化？

背景信息是H264实际上是需要收费的专利。在openH264出来之后，软解也跟上来的，google才开始表示支持H264的。

增加支持硬解的设备？

看起来修改一下 MediaCodecUtil.java 中的 HWEncoderProperties 即可。待实验。

小结

chromium是支持硬解的，版本要求在M57+。

参考资料：

  1. https://developer.android.com/reference/android/media/MediaCodec
  2. http://www.openh264.org/
雨声不在
关注
专栏目录
WebRTC SDK API封装(4)-WebRTC添加HW/SW H264编解码
bingdele的专栏
05-25 1918
背景 WebRTC由于license及其他的一些原因，默认的视频编解码只有使用vp8跟vp9，没有支持h264的编解码，但是我经过一些对比测试（vp9 vs h264）的数据发现，vp9的优势在于1080p以上才开始渐渐追上h264的效率，并且目前大多数的视频设备，还是使用h264的比较多，因此要实现对h264的编解码，就必须重新编译WebRTC添加对h264的支持。 实现 通过研究WebRTC的...
Fmpeg在各个平台上进行H.264和H.265硬件编码的示例
最新发布
zhangyihu321的专栏
07-31 1296
ffmpeg 264 265 硬件编码
选择最新 Chromium，支持 H264 / H265
啊渊的专栏
12-09 246
在做了充分的准备后，我信心满满的向着 H265 8K 视频解码这个目标发起进攻，然而，正打算动手的时候，我突然发现，别说支持 H265 ，自编的 Chromium WebView 连 H264 解码都不支持。在梳理了一遍又一遍的流程，跟踪调试了一遍又一遍的代码，两眼发花。最后需要说明一下，不能简单说 Chromium 105 之后的版本支持 H264 / H265，在 Android 上，还取决于 MediaCodec 组件的解码能力，Chromium 只是把上面的流程走通了，但实际解码还是依赖底层硬件。
Chromium Video 是如何播放的
m0_56146626的博客
04-03 879
本文基于Android平台简单梳理了Chromium在打开一个视频资源时背后所发生的逻辑与源码调用流程。
FFmpeg新版本支持的硬件解码
tugouxp的专栏
05-28 2367
【代码】FFmpeg新版本支持的硬件解码。
android 使用MediaCodec 编解码总结（最全）
STN_LCD的专栏
12-16 1万+
http://blog.csdn.net/gh_home/article/details/52143102   android 使用MediaCodec 编解码总结 标签： android编码异步解码硬件 2016-08-07 16:32 1906人阅读 评论(4) 收藏 举报  分类： Android（16）  版权声明：本文
Android 硬解码MediaCodec配合SurfaceView的踏坑之旅
u012521570的博客
12-12 3万+
一 前言最近在看一些Android硬解码的内容，顺便写了一个硬解码demo，简直就是踏坑之旅。使用Android自带的MediaCodec会有很多问题，动不动就卡死甚至crash。废话少说直接上代码，最后会将踩过的坑列觉出来并给出fix的办法二 demo1 初始化 首先 使用MediaCodec的静态方法创建一个解码器MediaCodec，记住是解码器，后面的mMimeType的参数就是解码视
HW_H265dec_Win32.lib
05-06
HW_H265dec_Win32.lib默认带着hisilicon,用反编译的方法，去掉hisi logo
启明HW-流量分析考题
04-24
本资源是启明星辰对于护网的考核题目，主要是流量分析方面的实战题目。
VP8_H264_HW_ENC_Q_COMPARE:比较 Android 设备上的 VP8 和 H.264 硬件编码器质量
06-25
VP8_H264_HW_ENC_Q_COMPARE 比较 Android 设备上的 VP8 和 H.264 硬件编码器质量。 应用程序将以给定的比特率和分辨率对 yuv 文件进行编码和解码，并将计算 PSNR。 HW VP8/H.264 之间的切换是通过在 Vp8...
使用MediaCodec将摄像头采集的视频编码为h264的问题
wangpeng_55的博客
09-11 7371
参考https://www.cnblogs.com/CoderTian/p/6224605.html案例时所遇到问题，记录一下： 错误日志 2019-09-11 15:18:59.791 6287-6329/com.hkst.testmuxer E/ACodec: [OMX.MTK.VIDEO.ENCODER.AVC] does not support color format 15 2019-0...
EasyPusher安卓Android手机直播推送之MediaCodec 硬编码H264格式
细心程度决定你的成败
07-10 1714
本文转自Holo的博客：http://blog.csdn.net/u013758734/article/details/50834770 最近在研究EasyDarwin的Push库EasyPusher，EasyPusher可以推送H264视频到EasyDarwin服务器，终端可以通过rtsp协议访问该实时流，达到手机直播的功能，延迟基本在2秒以内。  EasyDarwinQQ群：49625
Android多媒体(一)--mediacodec剖析
zhuchengcheng1992的博客
03-17 434
sfaf
ffmpeg支持的硬解码接口
热门推荐
ljh081231的专栏
06-28 3万+
GPU可以支持视频解码，而且在ffmpeg中也提供了解码的接口，一个是NVIDIA的VDPAU，一个是intel的VAAPI。 1、首先安装最新的Nvidia显卡驱动 安装后一般会在/usr/lib下面找到libvdpau库，查看/usr/include下面有无vdpau文件夹及相关头文件，如果没有，在这里下载：ftp://download.nvidia.com/XFree86/vdp
Android MediaCodec硬解码H264文件
Black_Hao的博客
05-22 9378
利用MediaCodec解码H264文件之后利用SurfaceView进行显示
Chrome/Chromium HTML5 video 视频播放硬件加速
小向的专栏
06-18 8365
Chromium网站上有个大致的框图，描述了Chromium的video
8K HDR!｜为 Chromium 实现 HEVC 硬解 - 原理/实测指南
字节跳动视频云
07-13 5833
如果有 HEVC 视频播放需求，不妨可以尝试一下 Chrome Canary 版本或预编译版本。
关闭硬解，修改代码方法
shi_xin的专栏
11-03 1463
有时候，显示有问题，需要判断是软绘有问题还是硬解有问题。 可以在code ActivityThread.java中强制关闭硬解 if (data.persistent) { // Persistent processes on low-memory devices do not get to // use hardwar
VCODEC-H264-D4视频压缩卡H.264硬件手册A.02版本
VCODEC-H264-D4-HW-A02是关于一款四通道H.264视频编码卡的专业硬件参考手册，适用于PC/104-Plus平台。该文档版本为A.02，包含了对产品设计、功能和性能的详细描述。AMP（Advanced Micro Peripherals）和Advanced ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值