Birden fazla kamera akışını aynı anda kullanma

Not: Bu sayfada Camera2 paketi ele alınmaktadır. Uygulamanız Camera2'den belirli, düşük seviyeli özellikler gerektirmediği sürece CameraX'i kullanmanızı öneririz. Hem CameraX hem de Camera2, Android 5.0 (API düzeyi 21) ve sonraki sürümleri destekler.

Kamera uygulamaları aynı anda birden fazla kare akışı kullanabilir. Bazı durumlarda, farklı yayınlar için farklı kare çözünürlüğü veya piksel biçimi gerekir. Tipik kullanım alanlarından bazıları şunlardır:

• Video kaydı: Önizleme için bir yayın, kodlanıp dosyaya kaydedilmek üzere başka bir yayın.
• Barkod tarama: Biri önizleme, diğeri barkod algılama için olmak üzere iki akış.
• Hesaplamalı fotoğrafçılık: Önizleme için bir akış, yüz/sahne algılama için başka bir akış.

Kareler işlenirken önemli bir performans maliyeti oluşur ve paralel akış veya işlem hattı işleme yapılırken bu maliyet katlanır.

CPU, GPU ve DSP gibi kaynaklar, çerçevenin yeniden işleme özelliklerinden yararlanabilir ancak bellek gibi kaynaklar doğrusal olarak büyür.

İstek başına birden fazla hedef

Birden fazla kamera akışı tek bir CameraCaptureRequest içinde birleştirilebilir. Aşağıdaki kod snippet'inde, kamera önizlemesi için bir akış ve görüntü işleme için başka bir akış kullanarak kamera oturumunun nasıl ayarlanacağı gösterilmektedir:

Kotlin

val session: CameraCaptureSession = ...  // from CameraCaptureSession.StateCallback

// You will use the preview capture template for the combined streams
// because it is optimized for low latency; for high-quality images, use
// TEMPLATE_STILL_CAPTURE, and for a steady frame rate use TEMPLATE_RECORD
val requestTemplate = CameraDevice.TEMPLATE_PREVIEW
val combinedRequest = session.device.createCaptureRequest(requestTemplate)

// Link the Surface targets with the combined request
combinedRequest.addTarget(previewSurface)
combinedRequest.addTarget(imReaderSurface)

// In this simple case, the SurfaceView gets updated automatically. ImageReader
// has its own callback that you have to listen to in order to retrieve the
// frames so there is no need to set up a callback for the capture request
session.setRepeatingRequest(combinedRequest.build(), null, null)

Java

CameraCaptureSession session = …;  // from CameraCaptureSession.StateCallback

// You will use the preview capture template for the combined streams
// because it is optimized for low latency; for high-quality images, use
// TEMPLATE_STILL_CAPTURE, and for a steady frame rate use TEMPLATE_RECORD
        CaptureRequest.Builder combinedRequest = session.getDevice().createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

// Link the Surface targets with the combined request
        combinedRequest.addTarget(previewSurface);
        combinedRequest.addTarget(imReaderSurface);

// In this simple case, the SurfaceView gets updated automatically. ImageReader
// has its own callback that you have to listen to in order to retrieve the
// frames so there is no need to set up a callback for the capture request
        session.setRepeatingRequest(combinedRequest.build(), null, null);

Hedef yüzeyleri doğru şekilde yapılandırırsanız bu kod yalnızca StreamComfigurationMap.GetOutputMinFrameDuration(int, Size) ve StreamComfigurationMap.GetOutputStallDuration(int, Size) tarafından belirlenen minimum FPS'yi karşılayan yayınlar oluşturur. Android, üç değişkene bağlı olarak belirli kombinasyonları destekleme konusunda bazı garantiler sunsa da gerçek performans cihazdan cihaza değişir: Çıkış türü, çıkış boyutu ve donanım düzeyi.

Desteklenmeyen bir değişken kombinasyonu kullanmak düşük kare hızında çalışabilir. Çalışmazsa hata geri çağırmalarından birini tetikler. createCaptureSession ile ilgili dokümanlarda, hangi işlevlerin kesin olarak çalışacağı açıklanmaktadır.

Çıkış türü

Çıkış türü, karelerin kodlandığı biçimi ifade eder. Olası değerler PRIV, YUV, JPEG ve RAW'dır. createCaptureSession ile ilgili dokümanlarda bu durumlar açıklanmaktadır.

Uygulamanızın çıkış türünü seçerken hedef uyumluluğu en üst düzeye çıkarmaksa kare analizi için ImageFormat.YUV_420_888, hareketsiz görüntüler için ImageFormat.JPEG kullanın. Önizleme ve kayıt senaryolarında büyük olasılıkla SurfaceView, TextureView, MediaRecorder, MediaCodec veya RenderScript.Allocation kullanacaksınız. Bu gibi durumlarda resim biçimi belirtmeyin. Uyumluluk için, dahili olarak kullanılan gerçek biçimden bağımsız olarak ImageFormat.PRIVATE olarak sayılır. Bir cihazın CameraCharacteristics göz önüne alındığında desteklediği biçimleri sorgulamak için aşağıdaki kodu kullanın:

Kotlin

val characteristics: CameraCharacteristics = ...
val supportedFormats = characteristics.get(
    CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP).outputFormats

Java

CameraCharacteristics characteristics = …;
        int[] supportedFormats = characteristics.get(
CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP).getOutputFormats();

Çıkış boyutu

Mevcut tüm çıkış boyutları StreamConfigurationMap.getOutputSizes() tarafından listelenir. Ancak yalnızca ikisi uyumlulukla ilgilidir: PREVIEW ve MAXIMUM. Boyutlar üst sınır olarak kabul edilir. PREVIEW boyutunda bir öğe çalışıyorsa PREVIEW boyutundan küçük olan her şey de çalışır. Aynı durum MAXIMUM için de geçerlidir. CameraDevice ile ilgili dokümanlarda bu boyutlar açıklanmaktadır.

Kullanılabilir çıkış boyutları, biçim seçimine bağlıdır. CameraCharacteristics ve bir biçim verildiğinde, kullanılabilir çıkış boyutlarını şu şekilde sorgulayabilirsiniz:

Kotlin

val characteristics: CameraCharacteristics = ...
val outputFormat: Int = ...  // such as ImageFormat.JPEG
val sizes = characteristics.get(
    CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
    .getOutputSizes(outputFormat)

Java

CameraCharacteristics characteristics = …;
        int outputFormat = …;  // such as ImageFormat.JPEG
Size[] sizes = characteristics.get(
                CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
                .getOutputSizes(outputFormat);

Kamera önizlemesi ve kayıt kullanım alanlarında, desteklenen boyutları belirlemek için hedef sınıfı kullanın. Biçim, kamera çerçevesi tarafından işlenir:

Kotlin

val characteristics: CameraCharacteristics = ...
val targetClass: Class <T> = ...  // such as SurfaceView::class.java
val sizes = characteristics.get(
    CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
    .getOutputSizes(targetClass)

Java

CameraCharacteristics characteristics = …;
   int outputFormat = …;  // such as ImageFormat.JPEG
   Size[] sizes = characteristics.get(
                CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
                .getOutputSizes(outputFormat);

MAXIMUM boyutunu elde etmek için çıkış boyutlarını alana göre sıralayın ve en büyüğünü döndürün:

Kotlin

fun <T>getMaximumOutputSize(
    characteristics: CameraCharacteristics, targetClass: Class <T>, format: Int? = null):
    Size {
  val config = characteristics.get(
      CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)

  // If image format is provided, use it to determine supported sizes; or else use target class
  val allSizes = if (format == null)
    config.getOutputSizes(targetClass) else config.getOutputSizes(format)
  return allSizes.maxBy { it.height * it.width }
}

Java

 @RequiresApi(api = Build.VERSION_CODES.N)
    <T> Size getMaximumOutputSize(CameraCharacteristics characteristics,
                                            Class <T> targetClass,
                                            Integer format) {
        StreamConfigurationMap config = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);

        // If image format is provided, use it to determine supported sizes; else use target class
        Size[] allSizes;
        if (format == null) {
            allSizes = config.getOutputSizes(targetClass);
        } else {
            allSizes = config.getOutputSizes(format);
        }
        return Arrays.stream(allSizes).max(Comparator.comparing(s -> s.getHeight() * s.getWidth())).get();
    }

PREVIEW, cihazın ekran çözünürlüğüne veya 1080p'ye (1920x1080) en iyi şekilde uyan boyutu ifade eder. En boy oranı, ekranın en boy oranıyla tam olarak eşleşmeyebilir. Bu nedenle, akışı tam ekran modunda görüntülemek için akışa letter-boxing veya kırpma uygulamanız gerekebilir. Doğru önizleme boyutunu elde etmek için, ekranın döndürülmüş olabileceğini göz önünde bulundurarak mevcut çıkış boyutlarını ekran boyutuyla karşılaştırın.

Aşağıdaki kod, boyut karşılaştırmalarını biraz daha kolay hale getirecek bir yardımcı sınıf olan SmartSize'yı tanımlar:

Kotlin

/** Helper class used to pre-compute shortest and longest sides of a [Size] */
class SmartSize(width: Int, height: Int) {
    var size = Size(width, height)
    var long = max(size.width, size.height)
    var short = min(size.width, size.height)
    override fun toString() = "SmartSize(${long}x${short})"
}

/** Standard High Definition size for pictures and video */
val SIZE_1080P: SmartSize = SmartSize(1920, 1080)

/** Returns a [SmartSize] object for the given [Display] */
fun getDisplaySmartSize(display: Display): SmartSize {
    val outPoint = Point()
    display.getRealSize(outPoint)
    return SmartSize(outPoint.x, outPoint.y)
}

/**
 * Returns the largest available PREVIEW size. For more information, see:
 * https://d.android.com/reference/android/hardware/camera2/CameraDevice
 */
fun <T>getPreviewOutputSize(
        display: Display,
        characteristics: CameraCharacteristics,
        targetClass: Class <T>,
        format: Int? = null
): Size {

    // Find which is smaller: screen or 1080p
    val screenSize = getDisplaySmartSize(display)
    val hdScreen = screenSize.long >= SIZE_1080P.long || screenSize.short >= SIZE_1080P.short
    val maxSize = if (hdScreen) SIZE_1080P else screenSize

    // If image format is provided, use it to determine supported sizes; else use target class
    val config = characteristics.get(
            CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)!!
    if (format == null)
        assert(StreamConfigurationMap.isOutputSupportedFor(targetClass))
    else
        assert(config.isOutputSupportedFor(format))
    val allSizes = if (format == null)
        config.getOutputSizes(targetClass) else config.getOutputSizes(format)

    // Get available sizes and sort them by area from largest to smallest
    val validSizes = allSizes
            .sortedWith(compareBy { it.height * it.width })
            .map { SmartSize(it.width, it.height) }.reversed()

    // Then, get the largest output size that is smaller or equal than our max size
    return validSizes.first { it.long <= maxSize.long && it.short <= maxSize.short }.size
}

Java

/** Helper class used to pre-compute shortest and longest sides of a [Size] */
    class SmartSize {
        Size size;
        double longSize;
        double shortSize;

        public SmartSize(Integer width, Integer height) {
            size = new Size(width, height);
            longSize = max(size.getWidth(), size.getHeight());
            shortSize = min(size.getWidth(), size.getHeight());
        }

        @Override
        public String toString() {
            return String.format("SmartSize(%sx%s)", longSize, shortSize);
        }
    }

    /** Standard High Definition size for pictures and video */
    SmartSize SIZE_1080P = new SmartSize(1920, 1080);

    /** Returns a [SmartSize] object for the given [Display] */
    SmartSize getDisplaySmartSize(Display display) {
        Point outPoint = new Point();
        display.getRealSize(outPoint);
        return new SmartSize(outPoint.x, outPoint.y);
    }

    /**
     * Returns the largest available PREVIEW size. For more information, see:
     * https://d.android.com/reference/android/hardware/camera2/CameraDevice
     */
    @RequiresApi(api = Build.VERSION_CODES.N)
    <T> Size getPreviewOutputSize(
            Display display,
            CameraCharacteristics characteristics,
            Class <T> targetClass,
            Integer format
    ){

        // Find which is smaller: screen or 1080p
        SmartSize screenSize = getDisplaySmartSize(display);
        boolean hdScreen = screenSize.longSize >= SIZE_1080P.longSize || screenSize.shortSize >= SIZE_1080P.shortSize;
        SmartSize maxSize;
        if (hdScreen) {
            maxSize = SIZE_1080P;
        } else {
            maxSize = screenSize;
        }

        // If image format is provided, use it to determine supported sizes; else use target class
        StreamConfigurationMap config = characteristics.get(
                CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        if (format == null)
            assert(StreamConfigurationMap.isOutputSupportedFor(targetClass));
        else
            assert(config.isOutputSupportedFor(format));
        Size[] allSizes;
        if (format == null) {
            allSizes = config.getOutputSizes(targetClass);
        } else {
            allSizes = config.getOutputSizes(format);
        }

        // Get available sizes and sort them by area from largest to smallest
        List <Size> sortedSizes = Arrays.asList(allSizes);
        List <SmartSize> validSizes =
                sortedSizes.stream()
                        .sorted(Comparator.comparing(s -> s.getHeight() * s.getWidth()))
                        .map(s -> new SmartSize(s.getWidth(), s.getHeight()))
                        .sorted(Collections.reverseOrder()).collect(Collectors.toList());

        // Then, get the largest output size that is smaller or equal than our max size
        return validSizes.stream()
                .filter(s -> s.longSize <= maxSize.longSize && s.shortSize <= maxSize.shortSize)
                .findFirst().get().size;
    }

Desteklenen donanım düzeyini kontrol etme

Çalışma zamanında kullanılabilen özellikleri belirlemek için CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL kullanarak desteklenen donanım düzeyini kontrol edin.

CameraCharacteristics nesnesiyle tek bir ifade kullanarak donanım düzeyini alabilirsiniz:

Kotlin

val characteristics: CameraCharacteristics = ...

// Hardware level will be one of:
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY,
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL,
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_FULL,
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3
val hardwareLevel = characteristics.get(
        CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL)

Java

CameraCharacteristics characteristics = ...;

// Hardware level will be one of:
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY,
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL,
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_FULL,
// - CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3
Integer hardwareLevel = characteristics.get(
                CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);

Tüm parçaları bir araya getirme

Çıkış türü, çıkış boyutu ve donanım düzeyi ile hangi akış kombinasyonlarının geçerli olduğunu belirleyebilirsiniz. Aşağıdaki grafik, LEGACY donanım düzeyine sahip bir CameraDevice tarafından desteklenen yapılandırmaların anlık görüntüsüdür.

Hedef 1		Hedef 2		Hedef 3		Örnek kullanım alanları
Tür	Maksimum boyut	Tür	Maksimum boyut	Tür	Maksimum boyut
PRIV	MAXIMUM					Basit önizleme, GPU video işleme veya önizlemesiz video kaydı.
JPEG	MAXIMUM					Vizörsüz fotoğraf çekme
YUV	MAXIMUM					Uygulama içi video/resim işleme
PRIV	PREVIEW	JPEG	MAXIMUM			Standart hareketsiz görüntüleme.
YUV	PREVIEW	JPEG	MAXIMUM			Uygulama içi işleme ve yakalama
PRIV	PREVIEW	PRIV	PREVIEW			Standart kayıt
PRIV	PREVIEW	YUV	PREVIEW			Önizleme ve uygulama içi işleme.
PRIV	PREVIEW	YUV	PREVIEW	JPEG	MAXIMUM	Hareketsiz görüntü yakalama ve uygulama içi işleme

LEGACY, olası en düşük donanım seviyesidir. Bu tabloda, Camera2'yi (API düzeyi 21 ve üzeri) destekleyen her cihazın doğru yapılandırma kullanıldığında ve bellek, CPU veya termal kısıtlamalar gibi performansı sınırlayan çok fazla ek yük olmadığında aynı anda en fazla üç yayın çıkışı yapabileceği gösterilmektedir.

Uygulamanızın hedefleme çıkış arabelleklerini de yapılandırması gerekir. Örneğin, LEGACY donanım seviyesine sahip bir cihazı hedeflemek için iki hedef çıkış yüzeyi ayarlayabilirsiniz. Bunlardan biri ImageFormat.PRIVATE, diğeri ise ImageFormat.YUV_420_888 kullanır. Bu, PREVIEW boyutu kullanılırken desteklenen bir kombinasyondur. Bu konunun önceki bölümlerinde tanımlanan işlevi kullanarak bir kamera kimliği için gerekli önizleme boyutlarını almak için aşağıdaki kod gerekir:

Kotlin

val characteristics: CameraCharacteristics = ...
val context = this as Context  // assuming you are inside of an activity

val surfaceViewSize = getPreviewOutputSize(
    context, characteristics, SurfaceView::class.java)
val imageReaderSize = getPreviewOutputSize(
    context, characteristics, ImageReader::class.java, format = ImageFormat.YUV_420_888)

Java

CameraCharacteristics characteristics = ...;
        Context context = this; // assuming you are inside of an activity

        Size surfaceViewSize = getPreviewOutputSize(
                context, characteristics, SurfaceView.class);
        Size imageReaderSize = getPreviewOutputSize(
                context, characteristics, ImageReader.class, format = ImageFormat.YUV_420_888);

SurfaceView hazır olana kadar sağlanan geri çağırmalarla beklemeniz gerekir:

Kotlin

val surfaceView = findViewById <SurfaceView>(...)
surfaceView.holder.addCallback(object : SurfaceHolder.Callback {
  override fun surfaceCreated(holder: SurfaceHolder) {
    // You do not need to specify image format, and it will be considered of type PRIV
    // Surface is now ready and you could use it as an output target for CameraSession
  }
  ...
})

Java

SurfaceView surfaceView = findViewById <SurfaceView>(...);

surfaceView.getHolder().addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(@NonNull SurfaceHolder surfaceHolder) {
                // You do not need to specify image format, and it will be considered of type PRIV
                // Surface is now ready and you could use it as an output target for CameraSession
            }
            ...
        });

SurfaceView'nın kamera çıkış boyutuyla eşleşmesini sağlamak için SurfaceHolder.setFixedSize()'ı çağırabilir veya GitHub'daki kamera örneklerinin Common modülünden AutoFitSurfaceView'a benzer bir yaklaşım kullanabilirsiniz. Bu yaklaşım, hem en boy oranını hem de mevcut alanı dikkate alarak mutlak bir boyut belirler ve etkinlik değişiklikleri tetiklendiğinde otomatik olarak ayarlanır.

Diğer yüzeyi ImageReader üzerinden istenen biçimde ayarlamak, geri çağırma işlemleri için beklemeniz gerekmediğinden daha kolaydır:

Kotlin

val frameBufferCount = 3  // just an example, depends on your usage of ImageReader
val imageReader = ImageReader.newInstance(
    imageReaderSize.width, imageReaderSize.height, ImageFormat.YUV_420_888,
    frameBufferCount)

Java

int frameBufferCount = 3;  // just an example, depends on your usage of ImageReader
ImageReader imageReader = ImageReader.newInstance(
                imageReaderSize.width, imageReaderSize.height, ImageFormat.YUV_420_888,
                frameBufferCount);

ImageReader gibi bir engelleme hedefi arabelleği kullanırken kareleri kullandıktan sonra atın:

Kotlin

imageReader.setOnImageAvailableListener({
  val frame =  it.acquireNextImage()
  // Do something with "frame" here
  it.close()
}, null)

Java

imageReader.setOnImageAvailableListener(listener -> {
            Image frame = listener.acquireNextImage();
            // Do something with "frame" here
            listener.close();
        }, null);

LEGACY donanım düzeyi, en düşük ortak payda cihazları hedefler. Koşullu dallanma ekleyebilir ve RECORD donanım düzeyine sahip cihazlarda çıkış hedef yüzeylerinden birinde RECORD boyutunu kullanabilir, hatta FULL donanım düzeyine sahip cihazlarda MAXIMUM boyutuna yükseltebilirsiniz.LIMITED