Media3 Transformer का इस्तेमाल करके वीडियो एडिटिंग के लिए एक बेसिक ऐप्लिकेशन बनाएं

Jetpack Media3 में मौजूद Transformer API को इस तरह से डिज़ाइन किया गया है कि यह मीडिया में बदलाव कर सके बेहतर और भरोसेमंद. ट्रांसफ़ॉर्मर कई कामों में मदद करता है. शामिल हैं:

• ट्रिम, स्केल, और रोटेट करने की सुविधा के ज़रिए वीडियो में बदलाव करना
• ओवरले और फ़िल्टर जैसे इफ़ेक्ट जोड़ना
• एचडीआर और स्लो-मोशन वीडियो जैसे खास फ़ॉर्मैट को प्रोसेस करना
• बदलाव लागू करने के बाद मीडिया आइटम को एक्सपोर्ट करना

इस पेज पर, आपको सेवा के इस्तेमाल के कुछ अहम उदाहरणों के बारे में बताया गया है. ट्रांसफ़ॉर्मर. ज़्यादा जानकारी के लिए, हमारी पूरी गाइड देखें Media3 ट्रांसफ़ॉर्मर.

शुरू करें

शुरू करने के लिए, ट्रांसफ़ॉर्मर, इफ़ेक्ट, और कॉमन मॉड्यूल पर डिपेंडेंसी जोड़ें Jetpack Media3 का कुल प्लान:

implementation "androidx.media3:media3-transformer:1.4.1"
implementation "androidx.media3:media3-effect:1.4.1"
implementation "androidx.media3:media3-common:1.4.1"

1.4.1 को, लाइब्रेरी. आप प्रॉडक्ट की जानकारी ताकि आप सबसे नया वर्शन देख सकें.

ज़रूरी क्लास

आउटपुट कॉन्फ़िगर करें

Transformer.Builder की मदद से, अब आप videoMimeType और audioMimetype डायरेक्ट्री को बनाने की ज़रूरत के बिना, फ़ंक्शन सेट करके TransformationRequest ऑब्जेक्ट.

अलग-अलग फ़ॉर्मैट के बीच ट्रांसकोड करें

यहां दिया गया कोड, Transformer ऑब्जेक्ट को कॉन्फ़िगर करने का तरीका बताता है H.265/AVC वीडियो और AAC ऑडियो:

val transformer = Transformer.Builder(context)
    .setVideoMimeType(MimeTypes.VIDEO_H265)
    .setAudioMimeType(MimeTypes.AUDIO_AAC)
    .build()

Transformer transformer = new Transformer.Builder(context)
    .setVideoMimeType(MimeTypes.VIDEO_H265)
    .setAudioMimeType(MimeTypes.AUDIO_AAC)
    .build();

अगर इनपुट मीडिया फ़ॉर्मैट पहले से ही, ऑडियो के बदलाव के अनुरोध से मेल खाता है या वीडियो के लिए, ट्रांसफ़ॉर्मर अपने-आप ट्रांसमक्सिंग पर स्विच हो जाता है, यानी कि कॉपी करना इनपुट कंटेनर से आउटपुट कंटेनर में बिना कंप्रेस किए गए सैंपल बदलाव. इससे कंप्यूटेशनल लागत और क्वालिटी में होने वाले नुकसान से बचा जा सकता है उसी फ़ॉर्मैट में डीकोडिंग और री-एन्कोडिंग करते हैं.

एचडीआर मोड सेट करें

अगर इनपुट मीडिया फ़ाइल एचडीआर फ़ॉर्मैट में है, तो इनमें से कुछ में से किसी एक को चुना जा सकता है एचडीआर की जानकारी को प्रोसेस करने के लिए अलग-अलग मोड. आपने शायद HDR_MODE_KEEP_HDR या HDR_MODE_TONE_MAP_HDR_TO_SDR_USING_OPEN_GL.

उन डिवाइसों पर जिनमें कोड में बदलने के ज़रूरी तरीके काम करते हैं और Android 13 पर काम करते हैं (एपीआई लेवल 33) या उसके बाद के वर्शन Transformer ऑब्जेक्ट से, एचडीआर वीडियो में बदलाव करने की सुविधा मिलती है. Composition ऑब्जेक्ट बनाते समय, HDR_MODE_KEEP_HDR डिफ़ॉल्ट मोड होता है. जैसा कि नीचे दिए गए कोड में दिखाया गया है:

val composition = Composition.Builder(
    ImmutableList.of(videoSequence))
    .setHdrMode(HDR_MODE_KEEP_HDR)
    .build()

Composition composition = new Composition.Builder(
    ImmutableList.of(videoSequence))
    .setHdrMode(Composition.HDR_MODE_KEEP_HDR)
    .build();

मीडिया आइटम तैयार करें

MediaItem, ऑडियो को दिखाता है या वीडियो आइटम जोड़ने की सुविधा मिलती है. EditedMediaItem, साथ में MediaItem इकट्ठा करता है बदलाव करने होंगे.

वीडियो में काट-छांट करना

वीडियो के अनचाहे हिस्से हटाने के लिए, वीडियो के शुरू और खत्म होने का समय अपने हिसाब से सेट किया जा सकता है MediaItem में ClippingConfiguration जोड़कर पोज़िशन देखें.

val clippingConfiguration = MediaItem.ClippingConfiguration.Builder()
    .setStartPositionMs(10_000) // start at 10 seconds
    .setEndPositionMs(20_000) // end at 20 seconds
    .build()
val mediaItem = MediaItem.Builder()
    .setUri(videoUri)
    .setClippingConfiguration(clippingConfiguration)
    .build()

ClippingConfiguration clippingConfiguration = new MediaItem.ClippingConfiguration.Builder()
    .setStartPositionMs(10_000) // start at 10 seconds
    .setEndPositionMs(20_000) // end at 20 seconds
    .build();
MediaItem mediaItem = new MediaItem.Builder()
    .setUri(videoUri)
    .setClippingConfiguration(clippingConfiguration)
    .build();

पहले से मौजूद इफ़ेक्ट का इस्तेमाल करना

Media3 में सामान्य बदलावों के लिए, कई बिल्ट-इन वीडियो इफ़ेक्ट शामिल हैं, उदाहरण के लिए:

ऑडियो इफ़ेक्ट के लिए, वीडियो का क्रम जोड़ा जा सकता है AudioProcessor ऑडियो डेटा को पूरी तरह बदल देते हैं. उदाहरण के लिए, ChannelMixingAudioProcessor ऑडियो चैनलों को मिक्स और स्केल कर सकते हैं.

इन इफ़ेक्ट का इस्तेमाल करने के लिए, इफ़ेक्ट या ऑडियो प्रोसेसर का इंस्टेंस बनाएं. ऑडियो और वीडियो इफ़ेक्ट के साथ Effects का एक इंस्टेंस, जिसे आपको लागू करना है मीडिया आइटम को फिर किसी EditedMediaItem में Effects ऑब्जेक्ट जोड़ें.

val channelMixingProcessor = ChannelMixingAudioProcessor()
val rotateEffect = ScaleAndRotateTransformation.Builder().setRotationDegrees(60f).build()
val cropEffect = Crop(-0.5f, 0.5f, -0.5f, 0.5f)

val effects = Effects(listOf(channelMixingProcessor), listOf(rotateEffect, cropEffect))

val editedMediaItem = EditedMediaItem.Builder(mediaItem)
    .setEffects(effects)
    .build()

ChannelMixingAudioProcessor channelMixingProcessor = new ChannelMixingAudioProcessor();
ScaleAndRotateTransformation rotateEffect = new ScaleAndRotateTransformation.Builder()
    .setRotationDegrees(60f)
    .build();
Crop cropEffect = new Crop(-0.5f, 0.5f, -0.5f, 0.5f);

Effects effects = new Effects(
    ImmutableList.of(channelMixingProcessor),
    ImmutableList.of(rotateEffect, cropEffect)
);

EditedMediaItem editedMediaItem = new EditedMediaItem.Builder(mediaItem)
    .setEffects(effects)
    .build();

कस्टम इफ़ेक्ट बनाएं

Media3 में शामिल इफ़ेक्ट को बढ़ाकर, कस्टम इफ़ेक्ट बनाए जा सकते हैं ज़रूरत होती है. नीचे दिए गए उदाहरण में, सब-क्लास का इस्तेमाल करें वीडियो को ज़ूम करके, पहले फ़्रेम पर लाने के लिए MatrixTransformation प्लेबैक का सेकंड:

val zoomEffect = MatrixTransformation { presentationTimeUs ->
    val transformationMatrix = Matrix()
    // Set the scaling factor based on the playback position
    val scale = min(1f, presentationTimeUs / 1_000f)
    transformationMatrix.postScale(/* x */ scale, /* y */ scale)
    transformationMatrix
}

val editedMediaItem = EditedMediaItem.Builder(inputMediaItem)
    .setEffects(Effects(listOf(), listOf(zoomEffect))
    .build()

MatrixTransformation zoomEffect = presentationTimeUs -> {
    Matrix transformationMatrix = new Matrix();
    // Set the scaling factor based on the playback position
    float scale = min(1f, presentationTimeUs / 1_000f);
    transformationMatrix.postScale(/* x */ scale, /* y */ scale);
    return transformationMatrix;
};

EditedMediaItem editedMediaItem = new EditedMediaItem.Builder(inputMediaItem)
    .setEffects(new Effects(ImmutableList.of(), ImmutableList.of(zoomEffect)))
    .build();

किसी इफ़ेक्ट के व्यवहार को और ज़्यादा पसंद के मुताबिक बनाने के लिए, GlShaderProgram. कॉन्टेंट बनाने इनपुट फ़्रेम को प्रोसेस करने के लिए, queueInputFrame() तरीके का इस्तेमाल किया जाता है. उदाहरण के लिए, मशीन लर्निंग की क्षमताओं का इस्तेमाल कर सकते हैं. MediaPipe, तो आप MediaPipe FrameProcessor का इस्तेमाल करें. इसका एक उदाहरण ट्रांसफ़ॉर्मर डेमो ऐप्लिकेशन.

इफ़ेक्ट की झलक

ExoPlayer पर, इफ़ेक्ट की झलक देखी जा सकती है एक्सपोर्ट करने की प्रोसेस शुरू करने से पहले, किसी मीडिया आइटम में जोड़ा जाता है. वही तरीका इस्तेमाल किया जा रहा है EditedMediaItem के लिए Effects ऑब्जेक्ट है, अपने इस नंबर पर setVideoEffects() को कॉल करें ExoPlayer इंस्टेंस.

val player = ExoPlayer.builder(context)
    .build()
    .also { exoPlayer ->
        exoPlayer.setMediaItem(inputMediaItem)
        exoPlayer.setVideoEffects(effects)
        exoPlayer.prepare()
    }

ExoPlayer player = new ExoPlayer.builder(context).build();
player.setMediaItem(inputMediaItem);
player.setVideoEffects(effects);
exoPlayer.prepare();

ExoPlayer की मदद से, ऑडियो इफ़ेक्ट की झलक भी देखी जा सकती है. अपनी ExoPlayer इंस्टेंस, कस्टम RenderersFactory में पास करें, जो प्लेयर के ऑडियो रेंडरर से, ऑडियो को उस AudioSink पर आउटपुट करने के लिए जिसमें आपका AudioProcessor क्रम. नीचे दिए गए उदाहरण में, हम एक बार DefaultRenderersFactory में से buildAudioSink() तरीका.

val player = ExoPlayer.Builder(context, object : DefaultRenderersFactory(context) {
    override fun buildAudioSink(
        context: Context,
        enableFloatOutput: Boolean,
        enableAudioTrackPlaybackParams: Boolean,
        enableOffload: Boolean
    ): AudioSink? {
        return DefaultAudioSink.Builder(context)
            .setEnableFloatOutput(enableFloatOutput)
            .setEnableAudioTrackPlaybackParams(enableAudioTrackPlaybackParams)
            .setOffloadMode(if (enableOffload) {
                     DefaultAudioSink.OFFLOAD_MODE_ENABLED_GAPLESS_REQUIRED
                } else {
                    DefaultAudioSink.OFFLOAD_MODE_DISABLED
                })
            .setAudioProcessors(arrayOf(channelMixingProcessor))
            .build()
        }
    }).build()

ExoPlayer player = new ExoPlayer.Builder(context, new DefaultRenderersFactory(context) {
        @Nullable
        @Override
        protected AudioSink buildAudioSink(
            Context context,
            boolean enableFloatOutput,
            boolean enableAudioTrackPlaybackParams,
            boolean enableOffload
        ) {
            return new DefaultAudioSink.Builder(context)
                .setEnableFloatOutput(enableFloatOutput)
                .setEnableAudioTrackPlaybackParams(enableAudioTrackPlaybackParams)
                .setOffloadMode(
                    enableOffload
                        ? DefaultAudioSink.OFFLOAD_MODE_ENABLED_GAPLESS_REQUIRED
                        : DefaultAudioSink.OFFLOAD_MODE_DISABLED)
                .setAudioProcessors(new AudioProcessor[]{channelMixingProcessor})
                .build();
        }
    }).build();

बदलाव की शुरुआत करें

आखिर में, अपने बदलावों को लागू करने के लिए Transformer बनाएं और मिलने वाला मीडिया आइटम.

val transformer = Transformer.Builder(context)
    .addListener(listener)
    .build()
transformer.start(editedMediaItem, outputPath)

Transformer transformer = new Transformer.Builder(context)
    .addListener(listener)
    .build();
transformer.start(editedMediaItem, outputPath);

अगर ज़रूरी हो, तो एक्सपोर्ट की प्रोसेस को रद्द भी किया जा सकता है Transformer.cancel().

प्रोग्रेस से जुड़े अपडेट देखें

Transformer.start तुरंत लौटता है और एसिंक्रोनस रूप से काम करता है. क्वेरी करने के लिए किसी ट्रांसफ़ॉर्मेशन की मौजूदा प्रोग्रेस, कॉल Transformer.getProgress(). इस तरीके को अपनाने में ProgressHolder लगता है. प्रोग्रेस की स्थिति उपलब्ध होने पर, इसका मतलब है कि अगर यह तरीका PROGRESS_STATE_AVAILABLE दिखाता है, तो दिए गए ProgressHolder को प्रोग्रेस के मौजूदा प्रतिशत के हिसाब से अपडेट कर दिया जाएगा.

आप चाहें, तो किसी सुनने वाला आपके Transformer को भेजा जा सकता है.