Korzystanie z kilku transmisji z kamery jednocześnie

Uwaga: ta strona dotyczy pakietu Camera2. Jeśli Twoja aplikacja nie wymaga konkretnych funkcji niskiego poziomu z interfejsu Camera2, zalecamy używanie CameraX. Zarówno CameraX, jak i Camera2 obsługują Androida 5.0 (poziom interfejsu API 21) i nowsze wersje.

Aplikacja aparatu może używać jednocześnie więcej niż jednego strumienia klatek. W niektórych przypadkach różne strumienie wymagają nawet innej rozdzielczości klatek lub formatu pikseli. Oto kilka typowych przypadków użycia:

• Nagrywanie wideo: jeden strumień do podglądu, drugi kodowany i zapisywany w pliku.
• Skanowanie kodów kreskowych: jeden strumień do podglądu, drugi do wykrywania kodów kreskowych.
• Fotografia obliczeniowa: jeden strumień do podglądu, drugi do wykrywania twarzy lub scen.

Przetwarzanie klatek wiąże się ze znacznymi kosztami wydajności, które wzrastają w przypadku przetwarzania równoległego lub potokowego.

Zasoby takie jak procesor, GPU i DSP mogą korzystać z możliwości ponownego przetwarzania platformy, ale zasoby takie jak pamięć będą rosły liniowo.

Wiele miejsc docelowych w jednym żądaniu

Wiele strumieni z kamer można połączyć w jeden CameraCaptureRequest. Poniższy fragment kodu pokazuje, jak skonfigurować sesję aparatu z 1 strumieniem do podglądu z aparatu i 1 strumieniem do przetwarzania obrazu:

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);

Jeśli prawidłowo skonfigurujesz docelowe platformy, ten kod będzie generować tylko strumienie, które spełniają minimalną liczbę klatek na sekundę określoną przez StreamComfigurationMap.GetOutputMinFrameDuration(int, Size) i StreamComfigurationMap.GetOutputStallDuration(int, Size). Rzeczywista wydajność różni się w zależności od urządzenia, ale Android gwarantuje obsługę określonych kombinacji w zależności od 3 zmiennych: typu wyjścia, rozmiaru wyjścia i poziomu sprzętu.

Użycie nieobsługiwanej kombinacji zmiennych może działać przy niskiej liczbie klatek na sekundę. Jeśli tak się nie stanie, zostanie wywołane jedno z wywołań zwrotnych w przypadku błędu. Dokumentacja createCaptureSession zawiera informacje o tym, co na pewno będzie działać.

Typ wyjściowy

Typ wyjściowy odnosi się do formatu, w którym są kodowane klatki. Możliwe wartości to PRIV, YUV, JPEG i RAW. Opis tych funkcji znajdziesz w dokumentacji createCaptureSession.

Jeśli wybierasz typ danych wyjściowych aplikacji i chcesz zmaksymalizować zgodność, użyj ImageFormat.YUV_420_888 do analizy klatek i ImageFormat.JPEG do obrazów statycznych. W przypadku podglądu i nagrywania prawdopodobnie będziesz używać SurfaceView, TextureView, MediaRecorder, MediaCodec lub RenderScript.Allocation. W takich przypadkach nie podawaj formatu obrazu. Dla zachowania zgodności będzie on traktowany jako ImageFormat.PRIVATE, niezależnie od formatu używanego wewnętrznie. Aby wysłać zapytanie o formaty obsługiwane przez urządzenie na podstawie jego CameraCharacteristics, użyj tego kodu:

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();

Rozmiar danych wyjściowych

Wszystkie dostępne rozmiary wyjściowe są wymienione według StreamConfigurationMap.getOutputSizes(), ale tylko 2 z nich są związane ze zgodnością: PREVIEW i MAXIMUM. Rozmiary są górnymi granicami. Jeśli coś o rozmiarze PREVIEW działa, to wszystko o rozmiarze mniejszym niż PREVIEW też będzie działać. To samo dotyczy MAXIMUM. Dokumentacja CameraDevice wyjaśnia te rozmiary.

Dostępne rozmiary wyjściowe zależą od wybranego formatu. Mając podany CameraCharacteristics i format, możesz wysłać zapytanie o dostępne rozmiary danych wyjściowych w ten sposób:

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);

W przypadku podglądu z kamery i nagrywania użyj klasy docelowej, aby określić obsługiwane rozmiary. Format będzie obsługiwany przez samą platformę aparatu:

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);

Aby uzyskać MAXIMUM, posortuj rozmiary wyjściowe według obszaru i zwróć największy z nich:

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 oznacza najlepsze dopasowanie rozmiaru do rozdzielczości ekranu urządzenia lub do rozdzielczości 1080p (1920 x 1080), w zależności od tego, która z tych wartości jest mniejsza. Format obrazu może nie odpowiadać dokładnie formatowi ekranu, więc aby wyświetlić transmisję w trybie pełnoekranowym, może być konieczne zastosowanie letterboxingu lub przycięcia. Aby uzyskać odpowiedni rozmiar podglądu, porównaj dostępne rozmiary wyjściowe z rozmiarem wyświetlacza, biorąc pod uwagę, że wyświetlacz może być obrócony.

Poniższy kod definiuje klasę pomocniczą SmartSize, która ułatwi porównywanie rozmiarów:

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;
    }

Sprawdzanie obsługiwanego poziomu sprzętu

Aby określić dostępne funkcje w czasie działania, sprawdź obsługiwany poziom sprzętu za pomocą funkcji CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL.

Za pomocą obiektu CameraCharacteristics możesz pobrać poziom sprzętu za pomocą jednego wyrażenia:

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);

Łączenie wszystkich elementów

Typ wyjścia, rozmiar wyjścia i poziom sprzętu pozwalają określić, które kombinacje strumieni są prawidłowe. Poniższy wykres przedstawia zrzut konfiguracji obsługiwanych przez CameraDevice na poziomie sprzętowym LEGACY.

Cel 1		Cel 2		Cel 3		Przykładowe przypadki użycia
Typ	Maksymalny rozmiar	Typ	Maksymalny rozmiar	Typ	Maksymalny rozmiar
PRIV	MAXIMUM					prosty podgląd, przetwarzanie wideo na GPU lub nagrywanie bez podglądu.
JPEG	MAXIMUM					Robienie zdjęć bez wizjera.
YUV	MAXIMUM					Przetwarzanie filmów i obrazów w aplikacji.
PRIV	PREVIEW	JPEG	MAXIMUM			Standardowe zdjęcia.
YUV	PREVIEW	JPEG	MAXIMUM			Przetwarzanie w aplikacji i dodatkowe przechwytywanie.
PRIV	PREVIEW	PRIV	PREVIEW			Standardowe nagrywanie.
PRIV	PREVIEW	YUV	PREVIEW			Podgląd i przetwarzanie w aplikacji.
PRIV	PREVIEW	YUV	PREVIEW	JPEG	MAXIMUM	Zdjęcie i przetwarzanie w aplikacji.

LEGACY to najniższy możliwy poziom sprzętu. Z tej tabeli wynika, że każde urządzenie obsługujące Camera2 (API na poziomie 21 lub wyższym) może generować do 3 strumieni jednocześnie, jeśli ma odpowiednią konfigurację i nie ma zbyt dużego obciążenia ograniczającego wydajność, np. związanego z pamięcią, procesorem lub ograniczeniami termicznymi.

Aplikacja musi też skonfigurować bufory wyjściowe kierowania. Aby na przykład kierować reklamy na urządzenie o poziomie sprzętu LEGACY, możesz skonfigurować 2 powierzchnie wyjściowe kierowania: jedną z użyciem ImageFormat.PRIVATE, a drugą z użyciem ImageFormat.YUV_420_888. Jest to obsługiwana kombinacja przy użyciu rozmiaru PREVIEW. Aby uzyskać wymagane rozmiary podglądu dla identyfikatora kamery za pomocą funkcji zdefiniowanej wcześniej w tym temacie, użyj tego kodu:

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);

Wymaga to poczekania, aż SurfaceView będzie gotowy, przy użyciu podanych wywołań zwrotnych:

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
            }
            ...
        });

Możesz wymusić dopasowanie SurfaceView do rozmiaru wyjściowego aparatu, wywołując SurfaceHolder.setFixedSize() lub zastosować podejście podobne do AutoFitSurfaceView z modułu Common w przykładach dotyczących aparatu na GitHubie, które ustawia rozmiar bezwzględny, biorąc pod uwagę zarówno współczynnik proporcji, jak i dostępną przestrzeń, a jednocześnie automatycznie dostosowując się, gdy zostaną wywołane zmiany aktywności.

Konfigurowanie innej platformy z ImageReader w wybranym formacie jest łatwiejsze, ponieważ nie trzeba czekać na wywołania zwrotne:

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);

Jeśli używasz bufora celu blokującego, np. ImageReader, odrzuć ramki po ich użyciu:

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 poziom sprzętowy jest przeznaczony dla urządzeń o najniższym wspólnym mianowniku. Możesz dodać rozgałęzianie warunkowe i użyć RECORD rozmiaru dla jednego z docelowych obszarów wyjściowych na urządzeniach z LIMITED poziomem sprzętowym, a nawet zwiększyć go do MAXIMUM rozmiaru na urządzeniach z FULL poziomem sprzętowym.