शुरू करें

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

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

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

Media3 Transformer को डिपेंडेंसी के तौर पर जोड़ना

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

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

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 आपका पसंदीदा वर्शन है. नया वर्शन देखने के लिए, प्रॉडक्ट की जानकारी देखें.

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

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

अगर यह सुविधा पहले से चालू नहीं है, तो आपको build.gradle Transformer पर निर्भर सभी android सेक्शन में जावा 8 की सुविधा चालू करनी होगी. इसके लिए, इन चीज़ों को जोड़ें:

compileOptions {
  targetCompatibility JavaVersion.VERSION_1_8
}

ट्रांसफ़ॉर्मेशन शुरू करना

यहां किसी इनपुट फ़ाइल से ऑडियो हटाने के लिए EditedMediaItem बनाने का उदाहरण दिया गया है. इसके बाद, H.265/HEVC वीडियो एक्सपोर्ट करने के लिए Transformer इंस्टेंस बनाना और कॉन्फ़िगर करना, और नतीजे को 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 इंस्टेंस पर, कई एक्सपोर्ट ऑपरेशन को क्रम से चलाया जा सकता है. हालांकि, एक ही इंस्टेंस के साथ एक साथ कई एक्सपोर्ट नहीं किए जा सकते.

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

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

इवेंट सुनना

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 का इस्तेमाल करके एक्सपोर्ट की प्रोसेस रद्द करें. खास तौर पर, कम कीमत वाले डिवाइसों पर हार्डवेयर वीडियो कोडेक जैसे संसाधन सीमित होते हैं. इसलिए, अगर आउटपुट की ज़रूरत न हो, तो संसाधनों को खाली करने के लिए ऐसा करना ज़रूरी है.