আপনার পছন্দের ভাষায় কন্টেন্ট অনুবাদ করতে Google তার AI প্রযুক্তি ব্যবহার করে। AI-এর মাধ্যমে করা অনুবাদে ভুল থাকতে পারে।

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

মনে রাখবেন: এই পৃষ্ঠা Camera2 প্যাকেজকে রেফার করে। আপনার অ্যাপের জন্য Camera2 থেকে নির্দিষ্ট, লো-লেভেল ফিচারের প্রয়োজন না হলে, আমরা CameraX ব্যবহার করার সাজেশন দিই। CameraX এবং Camera2, দুটিই Android 5.0 (API লেভেল ২১) এবং তার পরবর্তী যেকোনও ভার্সনে কাজ করে।

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

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

ফ্রেম প্রসেস করার সময় পারফর্ম্যান্সের উপর উল্লেখযোগ্য প্রভাব পড়ে এবং প্যারালাল স্ট্রিম বা পাইপলাইন প্রসেস করার সময় এই প্রভাব আরও বেশি হয়।

সিপিইউ, জিপিইউ এবং ডিএসপির মতো রিসোর্স ফ্রেমওয়ার্কের রিপ্রসেসিং ক্ষমতার সুবিধা নিতে পারে, তবে মেমরির মতো রিসোর্স লিনিয়ারলি বৃদ্ধি পাবে।

প্রতিটি অনুরোধে একাধিক টার্গেট

একাধিক ক্যামেরা স্ট্রিমকে একটি CameraCaptureRequest-এ একত্রিত করা যেতে পারে। নিচের কোড স্নিপেট থেকে বোঝা যাবে যে কীভাবে ক্যামেরা প্রিভিউয়ের জন্য একটি স্ট্রিম এবং ইমেজ প্রসেসিংয়ের জন্য আরেকটি স্ট্রিম সহ ক্যামেরা সেশন সেট-আপ করতে হয়:

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)

জাভা

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-এর মাধ্যমে কোনও ডিভাইসে সমর্থিত ফর্ম্যাটগুলি কোয়েরি করতে, নিম্নলিখিত কোডটি ব্যবহার করুন:

Kotlin

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 এবং একটি ফর্ম্যাট দেওয়া থাকলে, আপনি এইভাবে উপলভ্য আউটপুট সাইজের জন্য কোয়েরি করতে পারেন:

Kotlin

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

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

Kotlin

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 সাইজ পেতে, আউটপুট সাইজগুলি এলাকা অনুসারে সাজান এবং সবচেয়ে বড়টি ফেরত দিন:

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

জাভা

 @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, সংজ্ঞায়িত করে, যা সাইজের তুলনা করা একটু সহজ করে তুলবে:

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
}

জাভা

/** 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 অবজেক্টের সাহায্যে, আপনি একটি স্টেটমেন্টের মাধ্যমে হার্ডওয়্যার লেভেল ফিরিয়ে আনতে পারবেন:

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)

জাভা

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

সব তথ্য একত্রিত করা হচ্ছে

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

টার্গেট ১		টার্গেট ২		টার্গেট ৩		ব্যবহারের নমুনা
ধরন	সর্বাধিক সাইজ	ধরন	সর্বাধিক সাইজ	ধরন	সর্বাধিক সাইজ	ব্যবহারের নমুনা
`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`	`JPEG`	`MAXIMUM`	স্টিল ক্যাপচার প্লাস ইন-অ্যাপ প্রসেসিং।

LEGACY হল সবচেয়ে কম সম্ভাব্য হার্ডওয়্যার লেভেল। এই সারণী থেকে দেখা যায় যে Camera2 (API লেভেল ২১ এবং তার বেশি) সাপোর্ট করে এমন প্রতিটি ডিভাইস সঠিক কনফিগারেশন ব্যবহার করে এবং মেমরি, CPU বা থার্মাল সীমাবদ্ধতার মতো ওভারহেড পারফর্ম্যান্স সীমিত না করলে, একসাথে তিনটি পর্যন্ত স্ট্রিম আউটপুট করতে পারে।

এছাড়াও, আপনার অ্যাপকে টার্গেটিং আউটপুট বাফার কনফিগার করতে হবে। যেমন, LEGACY হার্ডওয়্যার লেভেল সহ কোনও ডিভাইসকে টার্গেট করতে, আপনি দুটি টার্গেট আউটপুট সারফেস সেট-আপ করতে পারেন, একটি ImageFormat.PRIVATE ব্যবহার করে এবং অন্যটি ImageFormat.YUV_420_888 ব্যবহার করে। PREVIEW সাইজ ব্যবহার করার সময় এটি একটি কাজ করে এমন কম্বিনেশন। এই বিষয়ে আগে উল্লেখ করা ফাংশন ব্যবহার করে, ক্যামেরা আইডির জন্য প্রয়োজনীয় প্রিভিউ সাইজ পেতে নিম্নলিখিত কোড প্রয়োজন:

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)

জাভা

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 রেডি না হওয়া পর্যন্ত অপেক্ষা করতে হবে:

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

জাভা

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-কে ক্যামেরার আউটপুট সাইজের সাথে ম্যাচ করতে বাধ্য করতে পারেন অথবা আপনি GitHub-এ ক্যামেরা স্যাম্পেলের কমন মডিউল থেকে AutoFitSurfaceView-এর মতো একই পদ্ধতি অবলম্বন করতে পারেন, যা অ্যাস্পেক্ট রেশিও এবং উপলভ্য স্পেস, দুটিই বিবেচনা করে একটি অ্যাবসোলিউট সাইজ সেট করে, একই সাথে অ্যাক্টিভিটি পরিবর্তন ট্রিগার হলে অটোমেটিক অ্যাডজাস্ট করে।

ImageReader থেকে অন্য সারফেস সেট-আপ করা সহজ, কারণ কলব্যাকের জন্য অপেক্ষা করতে হয় না:

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)

জাভা

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-এর মতো ব্লকিং টার্গেট বাফার ব্যবহার করার সময়, ফ্রেমগুলি ব্যবহার করার পরে বাতিল করুন:

Kotlin

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 সাইজ করতে পারেন।