Snap for 7571067 from 01ddb68c to sc-release

     * camera's crop region is set to maximum size, the FOV of the physical streams for the

     * ultrawide lens will be the same as the logical stream, by making the crop region

     * smaller than its active array size to compensate for the smaller focal length.</p>

     * <p>Even if the underlying physical cameras have different RAW characteristics (such as

     * size or CFA pattern), a logical camera can still advertise RAW capability. In this

     * case, when the application configures a RAW stream, the camera device will make sure

     * the active physical camera will remain active to ensure consistent RAW output

     * behavior, and not switch to other physical cameras.</p>

     * <p>There are two ways for the application to capture RAW images from a logical camera

     * with RAW capability:</p>

     * <ul>

     * <li>Because the underlying physical cameras may have different RAW capabilities (such

     * as resolution or CFA pattern), to maintain backward compatibility, when a RAW stream

     * is configured, the camera device makes sure the default active physical camera remains

     * active and does not switch to other physical cameras. (One exception is that, if the

     * logical camera consists of identical image sensors and advertises multiple focalLength

     * due to different lenses, the camera device may generate RAW images from different

     * physical cameras based on the focalLength being set by the application.) This

     * backward-compatible approach usually results in loss of optical zoom, to telephoto

     * lens or to ultrawide lens.</li>

     * <li>Alternatively, to take advantage of the full zoomRatio range of the logical camera,

     * the application should use <a href="https://developer.android.com/reference/android/hardware/camera2/MultiResolutionImageReader.html">MultiResolutionImageReader</a>

     * to capture RAW images from the currently active physical camera. Because different

     * physical camera may have different RAW characteristics, the application needs to use

     * the characteristics and result metadata of the active physical camera for the

     * relevant RAW metadata.</li>

     * </ul>

     * <p>The capture request and result metadata tags required for backward compatible camera

     * functionalities will be solely based on the logical camera capabiltity. On the other

     * functionalities will be solely based on the logical camera capability. On the other

     * hand, the use of manual capture controls (sensor or post-processing) with a

     * logical camera may result in unexpected behavior when the HAL decides to switch

     * between physical cameras with different characteristics under the hood. For example,

service drm /system/bin/drmserver

    disabled

    class main

    user drm

    group drm system inet drmrpc readproc

    writepid /dev/cpuset/foreground/tasks

on property:drm.service.enabled=true

    start drm

on property:drm.service.enabled=1

    start drm

const sp<IDrmManagerService>& DrmManagerClientImpl::getDrmManagerService() {

    Mutex::Autolock lock(sMutex);

    if (NULL == sDrmManagerService.get()) {

        char value[PROPERTY_VALUE_MAX];

        if (property_get("drm.service.enabled", value, NULL) == 0) {

            // Drm is undefined for this device

        sp<IServiceManager> sm = defaultServiceManager();

        sp<IBinder> binder = sm->getService(String16("drm.drmManager"));

        if (binder == NULL) {

            // Do NOT retry; IServiceManager already waits for ~5 seconds

            // in getService if a service doesn't yet exist.

            return sDrmManagerService;

        }

        sp<IServiceManager> sm = defaultServiceManager();

        sp<IBinder> binder;

        do {

            binder = sm->getService(String16("drm.drmManager"));

            if (binder != 0) {

                break;

            }

            ALOGW("DrmManagerService not published, waiting...");

            struct timespec reqt;

            reqt.tv_sec  = 0;

            reqt.tv_nsec = 500000000; //0.5 sec

            nanosleep(&reqt, NULL);

        } while (true);

        if (NULL == sDeathNotifier.get()) {

            sDeathNotifier = new DeathNotifier();

        }

//#define LOG_NDEBUG 0

#define LOG_TAG "C2SoftMp3Dec"

#include <inttypes.h>

#include <log/log.h>

#include <numeric>

        }

    }

    uint64_t outTimeStamp = mProcessedSamples * 1000000ll / samplingRate;

    int64_t outTimeStamp = mProcessedSamples * 1000000ll / samplingRate;

    mProcessedSamples += ((outSize - outOffset) / (numChannels * sizeof(int16_t)));

    ALOGV("out buffer attr. offset %d size %d timestamp %u", outOffset, outSize - outOffset,

          (uint32_t)(mAnchorTimeStamp + outTimeStamp));

    ALOGV("out buffer attr. offset %d size %d timestamp %" PRId64 " ", outOffset,

          outSize - outOffset, mAnchorTimeStamp + outTimeStamp);

    decodedSizes.clear();

    work->worklets.front()->output.flags = work->input.flags;

    work->worklets.front()->output.buffers.clear();

    bool mSignalledError;

    bool mSignalledOutputEos;

    bool mGaplessBytes;

    uint64_t mAnchorTimeStamp;

    int64_t mAnchorTimeStamp;

    uint64_t mProcessedSamples;

    status_t initDecoder();