Korzystanie z kilku transmisji z kamery jednocześnie

Uwaga: ta strona dotyczy pakietu Aparat2. Jeśli Twoja aplikacja nie wymaga konkretnych, niskopoziomowych funkcji z Aparatu 2, zalecamy używanie AparatuX. Aparaty CameraX i Aparat 2 obsługują Androida 5.0 (poziom interfejsu API 21) i nowsze wersje.

Aplikacja aparatu może korzystać z więcej niż 1 strumienia klatek jednocześnie. W w niektórych przypadkach różne strumienie wymagają nawet innej rozdzielczości klatki lub piksela. . Oto kilka typowych zastosowań:

• Nagrywanie filmów: jeden strumień do podglądu, drugi jest kodowany i zapisywany. do pliku.
• Skanowanie kodów kreskowych: jeden strumień do podglądu, drugi do wykrywania kodów kreskowych.
• Fotografia cyfrowa: jeden strumień do podglądu, drugi do ujęcia twarzy/sceny wykrywaniem zagrożeń.

Przy przetwarzaniu klatek występuje niezrozumiały koszt wydajności, pomnożonej podczas przetwarzania równoległego strumienia lub potoku.

Zasoby takie jak CPU, GPU i DSP mogą wykorzystać ponownego przetwarzania danych platformy ale zasoby takie jak pamięć będą rosły liniowo.

Wiele celów na żądanie

Wiele strumieni z kamery można połączyć w jeden CameraCaptureRequest Fragment kodu poniżej pokazuje, jak skonfigurować sesję kamery z użyciem jednego strumień na potrzeby podglądu z kamery, a drugi do przetwarzania obrazu:

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)

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 platformy docelowe, ten kod wygeneruje tylko strumienie, które mają minimalną liczbę klatek na sekundę określoną przez StreamComfigurationMap.GetOutputMinFrameDuration(int, Size) oraz StreamComfigurationMap.GetOutputStallDuration(int, Size) Rzeczywista wydajność różni się w zależności od urządzenia, chociaż Android zapewnia pewne gwarantuje obsługę określonych kombinacji w zależności od trzech zmiennych: typ urządzenia wyjściowego, rozmiar wyjściowy i poziom sprzętu.

Używanie nieobsługiwanej kombinacji zmiennych może działać przy małej liczbie klatek. jeśli nie, wywoła jedno z nieudanych wywołań zwrotnych. Dokumentacja createCaptureSession co gwarantuje skuteczność.

Typ wyjściowy

Typ wyjściowy określa format, w którym klatki są kodowane. możliwe wartości to PRIV, YUV, JPEG i RAW. Dokumentacja createCaptureSession i je opisuje.

Jeśli podczas wyboru typu danych wyjściowych aplikacji celem jest maksymalizacja zgodności, a potem użyj ImageFormat.YUV_420_888 do analizy klatek ImageFormat.JPEG za zdjęcie obrazów. W przypadku podglądów i nagrywania będziesz pewnie używać SurfaceView, TextureView, MediaRecorder MediaCodec lub RenderScript.Allocation. W w takich przypadkach, nie określaj formatu obrazu. Dla zgodności będzie to liczone jako ImageFormat.PRIVATE, niezależnie od rzeczywistego formatu używanego wewnętrznie. Do wysyłania zapytań o obsługiwane formaty przez urządzenie, biorąc pod uwagę CameraCharacteristics, użyj tego kodu:

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

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

Rozmiar wyjściowy

Wszystkie dostępne rozmiary wyjściowe wyświetlają się, StreamConfigurationMap.getOutputSizes(), ale tylko dwa są związane ze zgodnością: PREVIEW i MAXIMUM. Rozmiary i działają jak górne granice. Jeśli działa coś o rozmiarze PREVIEW, rozmiar mniejszy niż PREVIEW również będzie działać. To samo dotyczy funkcji MAXIMUM. dokumentacja dla CameraDevice które wyjaśniają te rozmiary.

Dostępne rozmiary wyjściowe zależą od wybranego formatu. Biorąc pod uwagę CameraCharacteristics i formatu, możesz zapytać o dostępne rozmiary wyjściowe w następujący sposób:

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

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

W podglądzie kamery i nagrywaniu przypadków użycia użyj klasy docelowej, aby określić obsługiwanych rozmiarów. Format będzie obsługiwany przez platformę kamery:

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

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

Aby uzyskać rozmiar MAXIMUM, posortuj rozmiary wyjściowe według obszaru i zwróć największą wartość pierwsze:

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

 @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 odnosi się do najlepszego dopasowania rozmiaru do rozdzielczości ekranu urządzenia lub 1080p (1920 x 1080) w zależności od tego, która z tych wartości jest mniejsza. Format obrazu może nie pasować do proporcje ekranu, więc może być konieczne zastosowanie czarnych pasów przycinając go do strumienia, aby wyświetlić go w trybie pełnoekranowym. Po prawej porównaj dostępne rozmiary wyjściowe z rozmiarami interfejsu biorąc pod uwagę, że obraz może być obrócony.

Ten kod definiuje klasę pomocniczą (SmartSize) tworzącą rozmiar porównywanie danych jest nieco łatwiejsze.

/** 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
}

/** 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ć możliwości dostępne w czasie działania, sprawdź obsługiwany sprzęt poziom za pomocą CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL

Dzięki CameraCharacteristics możesz pobrać poziom sprzętowy za pomocą jednej instrukcji:

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)

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

Składanie elementów w całość

Na podstawie typu danych wyjściowych, rozmiaru wyjściowego i poziomu sprzętowego możesz określić, kombinacje strumieni są prawidłowe. Na wykresie poniżej znajdziesz podsumowanie konfiguracje obsługiwane przez operatora CameraDevice z LEGACY. na poziomie sprzętowym.

LEGACY to najniższy możliwy poziom sprzętu. Z tej tabeli wynika, że co urządzenie obsługujące Aparat 2 (poziom interfejsu API 21 lub nowsze) może wyświetlać maksymalnie trzy jednoczesnych strumieni w odpowiedniej konfiguracji, jeśli nie jest ich za dużo ograniczające wydajność, takie jak ograniczenia dotyczące pamięci, procesora czy temperatury.

Aplikacja musi też skonfigurować bufory wyjściowe kierowania. Aby na przykład: kierować reklamy na urządzenie z poziomem sprzętowym LEGACY, możesz ustawić 2 docelowe wyjście jednej platformy, a drugiej za pomocą ImageFormat.PRIVATE, a drugiej ImageFormat.YUV_420_888 To jest obsługiwana kombinacja w przypadku użycia Rozmiar: PREVIEW. Przy użyciu funkcji zdefiniowanej wcześniej w tym temacie, aby pobrać wymagane rozmiary podglądu dla identyfikatora kamery wymagają tego kodu:

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)

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 oczekiwania, aż SurfaceView będzie gotowy przy użyciu podanych wywołań zwrotnych:

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

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 kamery, wywołując SurfaceHolder.setFixedSize(). lub możesz zastosować podejście podobne do AutoFitSurfaceView ze strony Wspólny część próbek z kamery w serwisie GitHub, który określa rozmiar bezwzględny, biorąc pod uwagę weź pod uwagę zarówno format obrazu, jak i dostępną przestrzeń. dostosowania po wywołaniu zmian aktywności.

Przygotowanie drugiego miejsca z: ImageReader z wybranym formatem to , bo nie ma żadnych wywołań zwrotnych, na które trzeba czekać:

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)

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 docelowego blokowania, takiego jak ImageReader, odrzuć klatki po :

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

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

Urządzenie LEGACY jest kierowane na urządzenia o najniższym wspólnym mianowniku. Dostępne opcje dodaj rozgałęzienie warunkowe i użyj rozmiaru RECORD dla jednego z docelowych danych wyjściowych na urządzeniach z poziomem sprzętowym LIMITED, a nawet zwiększyć go do Rozmiar: MAXIMUM dla urządzeń na poziomie sprzętowym FULL.