এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

একই সাথে একাধিক ক্যামেরা স্ট্রিম ব্যবহার করুন

দ্রষ্টব্য: এই পৃষ্ঠাটি Camera2 প্যাকেজকে বোঝায়। আপনার অ্যাপের Camera2 থেকে নির্দিষ্ট, নিম্ন-স্তরের বৈশিষ্ট্যের প্রয়োজন না হলে, আমরা CameraX ব্যবহার করার পরামর্শ দিই। CameraX এবং Camera2 উভয়ই Android 5.0 (API স্তর 21) এবং উচ্চতর সমর্থন করে।

একটি ক্যামেরা অ্যাপ্লিকেশন একই সাথে একাধিক ফ্রেম ব্যবহার করতে পারে। কিছু ক্ষেত্রে, বিভিন্ন স্ট্রীম এমনকি একটি ভিন্ন ফ্রেম রেজোলিউশন বা পিক্সেল বিন্যাস প্রয়োজন। কিছু সাধারণ ব্যবহারের ক্ষেত্রে অন্তর্ভুক্ত:

ভিডিও রেকর্ডিং : একটি স্ট্রিম প্রিভিউয়ের জন্য, আরেকটি এনকোড করা হচ্ছে এবং ফাইলে সেভ করা হচ্ছে।
বারকোড স্ক্যানিং : একটি প্রিভিউয়ের জন্য, আরেকটি বারকোড সনাক্তকরণের জন্য।
কম্পিউটেশনাল ফটোগ্রাফি : একটি প্রিভিউয়ের জন্য, অন্যটি মুখ/দৃশ্য সনাক্তকরণের জন্য।

ফ্রেম প্রক্রিয়াকরণের সময় একটি অ-তুচ্ছ কর্মক্ষমতা খরচ আছে, এবং সমান্তরাল স্ট্রিম বা পাইপলাইন প্রক্রিয়াকরণ করার সময় খরচ গুণিত হয়।

সিপিইউ, জিপিইউ এবং ডিএসপির মতো সংস্থানগুলি ফ্রেমওয়ার্কের পুনঃপ্রসেসিং ক্ষমতাগুলির সুবিধা নিতে সক্ষম হতে পারে, তবে মেমরির মতো সংস্থানগুলি রৈখিকভাবে বৃদ্ধি পাবে।

অনুরোধ প্রতি একাধিক লক্ষ্য

একাধিক ক্যামেরা স্ট্রীম একটি একক CameraCaptureRequest এ একত্রিত করা যেতে পারে। নিম্নলিখিত কোড স্নিপেটটি ব্যাখ্যা করে কিভাবে ক্যামেরা প্রিভিউয়ের জন্য একটি স্ট্রীম এবং ইমেজ প্রসেসিংয়ের জন্য আরেকটি স্ট্রিম সহ একটি ক্যামেরা সেশন সেট আপ করতে হয়:

কোটলিন

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

আপনি যদি টার্গেট সারফেসগুলি সঠিকভাবে কনফিগার করেন, তাহলে এই কোডটি শুধুমাত্র স্ট্রিম তৈরি করবে যা StreamComfigurationMap.GetOutputMinFrameDuration(int, Size) এবং StreamComfigurationMap.GetOutputStallDuration(int, Size) দ্বারা নির্ধারিত ন্যূনতম FPS পূরণ করে। প্রকৃত কর্মক্ষমতা ডিভাইস থেকে ডিভাইসে পরিবর্তিত হয়, যদিও Android তিনটি ভেরিয়েবলের উপর নির্ভর করে নির্দিষ্ট সংমিশ্রণ সমর্থন করার জন্য কিছু গ্যারান্টি প্রদান করে: আউটপুট প্রকার , আউটপুট আকার এবং হার্ডওয়্যার স্তর ।

ভেরিয়েবলের একটি অসমর্থিত সংমিশ্রণ ব্যবহার করা কম ফ্রেম হারে কাজ করতে পারে; যদি এটি না হয়, এটি ব্যর্থ কলব্যাকগুলির একটিকে ট্রিগার করবে। createCaptureSession এর ডকুমেন্টেশন বর্ণনা করে যে কি কাজ করার নিশ্চয়তা আছে।

আউটপুট প্রকার

আউটপুট টাইপ সেই বিন্যাসকে বোঝায় যেখানে ফ্রেমগুলি এনকোড করা হয়। সম্ভাব্য মানগুলি হল PRIV, YUV, JPEG এবং RAW৷ createCaptureSession এর ডকুমেন্টেশন তাদের বর্ণনা করে।

আপনার অ্যাপ্লিকেশানের আউটপুট প্রকার নির্বাচন করার সময়, যদি লক্ষ্যটি সামঞ্জস্যকে সর্বাধিক করা হয়, তাহলে ফ্রেম বিশ্লেষণের জন্য ImageFormat.YUV_420_888 এবং স্থির চিত্রগুলির জন্য ImageFormat.JPEG ব্যবহার করুন৷ পূর্বরূপ এবং রেকর্ডিং পরিস্থিতিগুলির জন্য, আপনি সম্ভবত একটি SurfaceView , TextureView , MediaRecorder , MediaCodec , বা RenderScript.Allocation ব্যবহার করবেন। এই ক্ষেত্রে, একটি চিত্র বিন্যাস নির্দিষ্ট করবেন না. সামঞ্জস্যের জন্য, এটিকে ImageFormat.PRIVATE হিসাবে গণনা করা হবে, অভ্যন্তরীণভাবে ব্যবহৃত প্রকৃত বিন্যাস নির্বিশেষে। CameraCharacteristics প্রদত্ত একটি ডিভাইস দ্বারা সমর্থিত ফর্ম্যাটগুলি অনুসন্ধান করতে, নিম্নলিখিত কোডটি ব্যবহার করুন:

কোটলিন

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

আউটপুট আকার

সমস্ত উপলব্ধ আউটপুট আকার StreamConfigurationMap.getOutputSizes() দ্বারা তালিকাভুক্ত করা হয়েছে, কিন্তু শুধুমাত্র দুটি সামঞ্জস্যের সাথে সম্পর্কিত: PREVIEW এবং MAXIMUM । মাপ উপরের সীমানা হিসাবে কাজ. PREVIEW এর আকারের কিছু কাজ করলে, PREVIEW এর থেকে ছোট আকারের কিছুও কাজ করবে। MAXIMUM ক্ষেত্রেও একই কথা সত্য। CameraDevice এর জন্য ডকুমেন্টেশন এই মাপ ব্যাখ্যা করে।

উপলব্ধ আউটপুট আকার বিন্যাস পছন্দ উপর নির্ভর করে. CameraCharacteristics এবং একটি বিন্যাস দেওয়া, আপনি এই মত উপলব্ধ আউটপুট আকারের জন্য জিজ্ঞাসা করতে পারেন:

কোটলিন

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

ক্যামেরা প্রিভিউ এবং রেকর্ডিং ব্যবহারের ক্ষেত্রে, সমর্থিত মাপ নির্ধারণ করতে লক্ষ্য শ্রেণী ব্যবহার করুন। বিন্যাসটি ক্যামেরা ফ্রেমওয়ার্ক নিজেই পরিচালনা করবে:

কোটলিন

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

MAXIMUM আকার পেতে, আউটপুট আকারগুলি এলাকা অনুসারে সাজান এবং সবচেয়ে বড়টি ফেরত দিন:

কোটলিন

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 বলতে ডিভাইসের স্ক্রীন রেজোলিউশনের সাথে বা 1080p (1920x1080) এর সাথে সেরা মাপের মিল বোঝায়, যেটি ছোট। আকৃতির অনুপাতটি স্ক্রিনের অনুপাতের সাথে ঠিক মেলে নাও হতে পারে, তাই পূর্ণ স্ক্রীন মোডে এটি প্রদর্শন করার জন্য আপনাকে স্ট্রীমে লেটার-বক্সিং বা ক্রপিং প্রয়োগ করতে হতে পারে। সঠিক প্রিভিউ সাইজ পেতে, ডিসপ্লেটি ঘোরানো হতে পারে তা বিবেচনায় রেখে ডিসপ্লে সাইজের সাথে উপলব্ধ আউটপুট মাপের তুলনা করুন।

নিম্নলিখিত কোডটি একটি সহায়ক শ্রেণী সংজ্ঞায়িত করে, SmartSize , যা আকারের তুলনাকে একটু সহজ করে তুলবে:

কোটলিন

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

সমর্থিত হার্ডওয়্যার স্তর পরীক্ষা করুন

রানটাইমে উপলব্ধ ক্ষমতা নির্ধারণ করতে, CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL ব্যবহার করে সমর্থিত হার্ডওয়্যার স্তর পরীক্ষা করুন।

একটি CameraCharacteristics বস্তুর সাথে, আপনি একটি একক বিবৃতি দিয়ে হার্ডওয়্যার স্তর পুনরুদ্ধার করতে পারেন:

কোটলিন

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

একসাথে সব টুকরা নির্বাণ

আউটপুট টাইপ, আউটপুট সাইজ এবং হার্ডওয়্যার লেভেল সহ, আপনি স্ট্রীমের কোন কম্বিনেশন বৈধ তা নির্ধারণ করতে পারেন। নিচের চার্টটি হল LEGACY হার্ডওয়্যার স্তর সহ একটি CameraDevice দ্বারা সমর্থিত কনফিগারেশনগুলির একটি স্ন্যাপশট৷

লক্ষ্য 1		লক্ষ্য 2		লক্ষ্য 3		নমুনা ব্যবহার কেস(গুলি)
টাইপ	সর্বোচ্চ আকার	টাইপ	সর্বোচ্চ আকার	টাইপ	সর্বোচ্চ আকার	নমুনা ব্যবহার কেস(গুলি)
`PRIV`	`MAXIMUM`					সহজ পূর্বরূপ, GPU ভিডিও প্রক্রিয়াকরণ, বা নো-প্রিভিউ ভিডিও রেকর্ডিং।
`JPEG`	`MAXIMUM`					নো-ভিউফাইন্ডার স্থির চিত্র ক্যাপচার।
`YUV`	`MAXIMUM`					ইন-অ্যাপ্লিকেশন ভিডিও/ইমেজ প্রসেসিং।
`PRIV`	`PREVIEW`	`JPEG`	`MAXIMUM`			স্ট্যান্ডার্ড স্টিল ইমেজিং।
`YUV`	`PREVIEW`	`JPEG`	`MAXIMUM`			ইন-অ্যাপ প্রক্রিয়াকরণ প্লাস এখনও ক্যাপচার.
`PRIV`	`PREVIEW`	`PRIV`	`PREVIEW`			স্ট্যান্ডার্ড রেকর্ডিং।
`PRIV`	`PREVIEW`	`YUV`	`PREVIEW`			প্রিভিউ প্লাস ইন-অ্যাপ প্রক্রিয়াকরণ।
`PRIV`	`PREVIEW`	`YUV`	`PREVIEW`			প্রিভিউ প্লাস ইন-অ্যাপ প্রক্রিয়াকরণ।
`PRIV`	`PREVIEW`	`YUV`	`PREVIEW`	`JPEG`	`MAXIMUM`	এখনও ক্যাপচার প্লাস ইন-অ্যাপ প্রক্রিয়াকরণ.

LEGACY হল সর্বনিম্ন সম্ভাব্য হার্ডওয়্যার স্তর। এই টেবিলটি দেখায় যে ক্যামেরা 2 (এপিআই স্তর 21 এবং উচ্চতর) সমর্থন করে এমন প্রতিটি ডিভাইস সঠিক কনফিগারেশন ব্যবহার করে তিনটি একযোগে স্ট্রীম পর্যন্ত আউটপুট করতে পারে এবং যদি খুব বেশি ওভারহেড সীমিত কর্মক্ষমতা না থাকে, যেমন মেমরি, সিপিইউ বা তাপীয় সীমাবদ্ধতা।

আপনার অ্যাপ্লিকেশানটিকে লক্ষ্য আউটপুট বাফারগুলিও কনফিগার করতে হবে৷ উদাহরণস্বরূপ, LEGACY হার্ডওয়্যার স্তর সহ একটি ডিভাইসকে লক্ষ্য করতে, আপনি দুটি লক্ষ্য আউটপুট পৃষ্ঠ সেট আপ করতে পারেন, একটি ImageFormat.PRIVATE ব্যবহার করে এবং অন্যটি ImageFormat.YUV_420_888 ব্যবহার করে৷ PREVIEW আকার ব্যবহার করার সময় এটি একটি সমর্থিত সংমিশ্রণ। এই বিষয়ে আগে সংজ্ঞায়িত ফাংশন ব্যবহার করে, একটি ক্যামেরা আইডির জন্য প্রয়োজনীয় পূর্বরূপ আকারগুলি পেতে নিম্নলিখিত কোডের প্রয়োজন:

কোটলিন

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

প্রদত্ত কলব্যাকগুলি ব্যবহার করে SurfaceView প্রস্তুত না হওয়া পর্যন্ত অপেক্ষা করতে হবে:

কোটলিন

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

আপনি SurfaceHolder.setFixedSize() কল করে SurfaceView ক্যামেরার আউটপুট আকারের সাথে মেলাতে বাধ্য করতে পারেন অথবা আপনি গিটহাবের ক্যামেরা নমুনার সাধারণ মডিউল থেকে AutoFitSurfaceView এর মতো একটি পদ্ধতি নিতে পারেন, যা উভয় দিক বিবেচনা করে একটি পরম আকার সেট করে। অনুপাত এবং উপলব্ধ স্থান, যখন কার্যকলাপ পরিবর্তনগুলি ট্রিগার করা হয় তখন স্বয়ংক্রিয়ভাবে সামঞ্জস্য করে।

পছন্দসই বিন্যাস সহ ImageReader থেকে অন্য পৃষ্ঠ সেট আপ করা সহজ, যেহেতু অপেক্ষা করার জন্য কোন কলব্যাক নেই:

কোটলিন

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

ImageReader এর মতো একটি ব্লকিং টার্গেট বাফার ব্যবহার করার সময়, ফ্রেমগুলি ব্যবহার করার পরে বাতিল করুন:

কোটলিন

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

LEGACY হার্ডওয়্যার স্তর সর্বনিম্ন সাধারণ ডিনোমিনেটর ডিভাইসগুলিকে লক্ষ্য করে। আপনি শর্তসাপেক্ষ শাখা যোগ করতে পারেন এবং LIMITED হার্ডওয়্যার স্তর সহ ডিভাইসগুলিতে আউটপুট লক্ষ্য পৃষ্ঠগুলির একটির জন্য RECORD আকার ব্যবহার করতে পারেন, বা এমনকি FULL হার্ডওয়্যার স্তরের ডিভাইসগুলির জন্য এটি MAXIMUM আকারে বাড়াতে পারেন৷