प्रारंभ करना

Transformer का इस्तेमाल शुरू करने के लिए यह तरीका अपनाएं:

1. अपने प्रोजेक्ट में डिपेंडेंसी के तौर पर Media3 ट्रांसफ़ॉर्मर जोड़ें.
2. प्रोसेस करने और उसमें बदलाव करने के लिए, मीडिया के तौर पर EditedMediaItem बनाएं उस पर लागू करें.
3. ज़रूरी आउटपुट और लिसनर के बारे में जानकारी देते हुए, Transformer बनाएं पूरा करने और गड़बड़ी वाले इवेंट के लिए.
4. निर्यात कार्रवाई शुरू करें, संपादित करने के लिए EditedMediaItem में पास करें और आउटपुट पाथ. एक्सपोर्ट के दौरान, मौजूदा प्रोग्रेस के बारे में क्वेरी की जा सकती है या कार्रवाई.
5. एक्सपोर्ट पूरा हो जाने के बाद, आउटपुट को ज़रूरत के मुताबिक हैंडल करें. उदाहरण के लिए, आपके पास आउटपुट को किसी दूसरे ऐप्लिकेशन पर शेयर करें या इसे सर्वर पर अपलोड करें.

इन चरणों के बारे में ज़्यादा जानकारी के लिए आगे पढ़ें और यहां देखें TransformerActivity ट्रांसफ़ॉर्मर डेमो ऐप्लिकेशन के लिए पूरा उदाहरण.

Media3 ट्रांसफ़ॉर्मर को डिपेंडेंसी के तौर पर जोड़ें

ट्रांसफ़ॉर्मर का इस्तेमाल शुरू करने का सबसे आसान तरीका यह है कि ग्रेडल डिपेंडेंसी जोड़ें अपने ऐप्लिकेशन मॉड्यूल की build.gradle फ़ाइल की लाइब्रेरी में:

implementation("androidx.media3:media3-transformer:1.4.0")
implementation("androidx.media3:media3-effect:1.4.0")
implementation("androidx.media3:media3-common:1.4.0")

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

जहां 1.4.0 आपका पसंदीदा वर्शन है. सबसे नए वर्शन में रिलीज़ नोट.

उपलब्ध लाइब्रेरी मॉड्यूल के बारे में ज़्यादा जानकारी यहां मिल सकती है: Google Maven AndroidX Media3 पेज पर जाएं.

Java 8 समर्थन चालू करें

अगर यह पहले से सक्षम नहीं है, तो आपको सभी build.gradle में Java 8 समर्थन चालू करना होगा ऐसी फ़ाइलें जो ट्रांसफ़ॉर्मर पर निर्भर करती हैं. इसके लिए, android में इन फ़ाइलों को जोड़ा जाता है सेक्शन:

compileOptions {
  targetCompatibility JavaVersion.VERSION_1_8
}

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

किसी इनपुट से ऑडियो हटाने के लिए, EditedMediaItem बनाने का एक उदाहरण यहां दिया गया है फ़ाइल डाउनलोड करें, फिर एक्सपोर्ट करने के लिए Transformer इंस्टेंस को बनाकर उसे कॉन्फ़िगर करें H.265/HEVC वीडियो, outputPath के तौर पर नतीजा दिखाता है.

val inputMediaItem = MediaItem.fromUri("path_to_input_file")
val editedMediaItem =
    EditedMediaItem.Builder(inputMediaItem).setRemoveAudio(true).build()
val transformer = Transformer.Builder(context)
    .setVideoMimeType(MimeTypes.VIDEO_H265)
    .addListener(transformerListener)
    .build()
transformer.start(editedMediaItem, outputPath)

MediaItem inputMediaItem = MediaItem.fromUri("path_to_input_file");
EditedMediaItem editedMediaItem =
    new EditedMediaItem.Builder(inputMediaItem).setRemoveAudio(true).build();
Transformer transformer =
    new Transformer.Builder(context)
        .setVideoMimeType(MimeTypes.VIDEO_H265)
        .addListener(transformerListener)
        .build();
transformer.start(editedMediaItem, outputPath);

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

एक ही समय पर, डेटा एक्सपोर्ट करने की प्रोसेस को एक क्रम में पूरा किया जा सकता है Transformer इंस्टेंस, लेकिन एक ही इंस्टेंस के साथ एक साथ एक्सपोर्ट किए जाने वाले डेटा समर्थित हैं.

थ्रेडिंग के बारे में जानकारी

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

इवेंट सुनना

start तरीका एसिंक्रोनस है. यह तुरंत वापस आ जाता है और ऐप्लिकेशन Transformer बिल्डर को पास किए गए लिसनर के ज़रिए, इवेंट की सूचना दी गई.

val transformerListener: Transformer.Listener =
    object : Transformer.Listener {
  override fun onCompleted(composition: Composition, result: ExportResult) {
    playOutput()
  }

  override fun onError(composition: Composition, result: ExportResult,
                       exception: ExportException) {
    displayError(exception)
  }
}

Transformer.Listener transformerListener =
    new Transformer.Listener() {
      @Override
      public void onCompleted(Composition composition, ExportResult result) {
        playOutput();
      }

      @Override
      public void onError(Composition composition, ExportResult result,
          ExportException exception) {
        displayError(exception);
      }
    };

ExportResult में आउटपुट फ़ाइल के बारे में जानकारी होती है. इसमें फ़ाइल भी शामिल होती है ऑडियो और वीडियो के लिए साइज़ और औसत बिटरेट, जैसा भी लागू हो.

प्रोग्रेस के बारे में अपडेट पाएं

इसकी मौजूदा प्रोग्रेस के बारे में क्वेरी करने के लिए, Transformer.getProgress को कॉल करें बदलाव. दिखाई गई वैल्यू से, प्रोग्रेस की स्थिति का पता चलता है. अगर गेम की प्रोग्रेस राज्य PROGRESS_STATE_AVAILABLE है, तो दिया गया ProgressHolder यह है प्रोग्रेस के मौजूदा प्रतिशत के हिसाब से अपडेट किया गया. नीचे दिए गए उदाहरण में, समय-समय पर बदलाव की प्रोग्रेस के बारे में क्वेरी करते हैं, जहां प्रोग्रेस बार को अपडेट करने के लिए, updateProgressInUi तरीका लागू किया जा सकता है.

transformer.start(inputMediaItem, outputPath)
val progressHolder = ProgressHolder()
mainHandler.post(
    object : Runnable {
      override fun run() {
        val progressState: @ProgressState Int = transformer.getProgress(progressHolder)
        updateProgressInUi(progressState, progressHolder)
        if (progressState != Transformer.PROGRESS_STATE_NOT_STARTED) {
          mainHandler.postDelayed(/* r= */this,  /* delayMillis= */500)
        }
      }
    }
)

transformer.start(inputMediaItem, outputPath);
ProgressHolder progressHolder = new ProgressHolder();
mainHandler.post(
    new Runnable() {
      @Override
      public void run() {
        @Transformer.ProgressState int progressState = transformer.getProgress(progressHolder);
        updateProgressInUi(progressState, progressHolder);
        if (progressState != PROGRESS_STATE_NOT_STARTED) {
          mainHandler.postDelayed(/* r= */ this, /* delayMillis= */ 500);
        }
      }
    });

ट्रांसफ़ॉर्मेशन को रद्द करना

अगर उपयोगकर्ता एक्सपोर्ट फ़्लो से बाहर निकलने का विकल्प चुनता है, तो एक्सपोर्ट की कार्रवाई को रद्द कर दें Transformer.cancel के साथ. हार्डवेयर वीडियो कोडेक जैसे संसाधन सीमित हैं, खास तौर पर, कम सुविधाओं वाले डिवाइसों पर. इसलिए, स्टोरेज खाली करने के लिए ऐसा करना ज़रूरी है संसाधनों का इस्तेमाल किया जा सकता है.