del: 移除安卓支持

src/video/pipeline/encoder_state.rs

@@ -6,16 +6,9 @@ use crate::video::codec::registry::{EncoderBackend, EncoderRegistry, VideoEncode
 use crate::video::codec::traits::EncoderConfig;
 use crate::video::codec::vp8::{VP8Config, VP8Encoder};
 use crate::video::codec::vp9::{VP9Config, VP9Encoder};
-#[cfg(feature = "android-mediacodec")]
-use crate::video::codec::AndroidMediaCodecH264Encoder;
-#[cfg(feature = "android-mediacodec")]
-use crate::video::codec::AndroidMediaCodecMjpegDecoder;
 use crate::video::format::{PixelFormat, Resolution};
 use bytes::Bytes;
-#[cfg(all(
-    any(target_arch = "aarch64", target_arch = "arm"),
-    not(target_os = "android")
-))]
+#[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
 use hwcodec::ffmpeg_hw::{
     last_error_message as ffmpeg_hw_last_error, HwMjpegH26xConfig, HwMjpegH26xPipeline,
 };
@@ -29,15 +22,9 @@ pub(super) struct EncoderThreadState {
     pub(super) nv12_converter: Option<Nv12Converter>,
     pub(super) yuv420p_converter: Option<PixelConverter>,
     pub(super) encoder_needs_yuv420p: bool,
-    #[cfg(all(
-        any(target_arch = "aarch64", target_arch = "arm"),
-        not(target_os = "android")
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
     pub(super) ffmpeg_hw_pipeline: Option<HwMjpegH26xPipeline>,
-    #[cfg(all(
-        any(target_arch = "aarch64", target_arch = "arm"),
-        not(target_os = "android")
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
     pub(super) ffmpeg_hw_enabled: bool,
     pub(super) fps: u32,
     pub(super) codec: VideoEncoderType,
@@ -129,35 +116,6 @@ impl VideoEncoderTrait for H265EncoderWrapper {
     }
 }
 
-#[cfg(feature = "android-mediacodec")]
-struct AndroidMediaCodecH264EncoderWrapper(AndroidMediaCodecH264Encoder);
-
-#[cfg(feature = "android-mediacodec")]
-impl VideoEncoderTrait for AndroidMediaCodecH264EncoderWrapper {
-    fn encode_raw(&mut self, data: &[u8], pts_ms: i64) -> Result<Vec<EncodedFrame>> {
-        let frames = self.0.encode_raw(data, pts_ms)?;
-        Ok(frames
-            .into_iter()
-            .map(|f| EncodedFrame {
-                data: f.data,
-                key: if f.key_frame { 1 } else { 0 },
-            })
-            .collect())
-    }
-
-    fn set_bitrate(&mut self, bitrate_kbps: u32) -> Result<()> {
-        self.0.set_bitrate(bitrate_kbps)
-    }
-
-    fn codec_name(&self) -> &str {
-        self.0.codec_name()
-    }
-
-    fn request_keyframe(&mut self) {
-        self.0.request_keyframe()
-    }
-}
-
 struct VP8EncoderWrapper(VP8Encoder);
 
 impl VideoEncoderTrait for VP8EncoderWrapper {
@@ -209,50 +167,12 @@ impl VideoEncoderTrait for VP9EncoderWrapper {
 }
 
 pub(super) enum MjpegDecoderKind {
-    #[cfg(feature = "android-mediacodec")]
-    AndroidMediaCodec {
-        decoder: AndroidMediaCodecMjpegDecoder,
-        fallback: Box<MjpegDecoderKind>,
-        fallback_active: bool,
-        output: Vec<u8>,
-    },
-    Libyuv {
-        decoder: MjpegToNv12Decoder,
-    },
+    Libyuv { decoder: MjpegToNv12Decoder },
 }
 
 impl MjpegDecoderKind {
     pub(super) fn decode(&mut self, data: &[u8]) -> Result<&[u8]> {
         match self {
-            #[cfg(feature = "android-mediacodec")]
-            MjpegDecoderKind::AndroidMediaCodec {
-                decoder,
-                fallback,
-                fallback_active,
-                output,
-            } => {
-                if !*fallback_active {
-                    match decoder.decode_to_nv12(data) {
-                        Ok(decoded) => {
-                            *output = decoded;
-                            return Ok(output.as_slice());
-                        }
-                        Err(AppError::VideoError(message))
-                            if message.contains("needs more input") =>
-                        {
-                            return Err(AppError::VideoError(message));
-                        }
-                        Err(err) => {
-                            tracing::warn!(
-                                "Android MediaCodec MJPEG decode failed; falling back to libyuv MJPEG->NV12: {}",
-                                err
-                            );
-                            *fallback_active = true;
-                        }
-                    }
-                }
-                fallback.decode(data)
-            }
             MjpegDecoderKind::Libyuv { decoder } => decoder.decode(data),
         }
     }
@@ -265,40 +185,6 @@ fn libyuv_mjpeg_decoder(resolution: Resolution) -> MjpegDecoderKind {
 }
 
 fn create_mjpeg_decoder(resolution: Resolution) -> Result<(MjpegDecoderKind, PixelFormat)> {
-    #[cfg(feature = "android-mediacodec")]
-    {
-        if std::env::var_os("ONE_KVM_ANDROID_MJPEG_MEDIACODEC").is_none() {
-            info!("MJPEG input detected, using libyuv decoder (MJPEG -> NV12)");
-            return Ok((libyuv_mjpeg_decoder(resolution), PixelFormat::Nv12));
-        }
-
-        info!("MJPEG input detected, trying Android MediaCodec decoder (MJPEG -> NV12)");
-        match AndroidMediaCodecMjpegDecoder::new(resolution) {
-            Ok(decoder) => {
-                info!("Using Android MediaCodec MJPEG decoder");
-                return Ok((
-                    MjpegDecoderKind::AndroidMediaCodec {
-                        decoder,
-                        fallback: Box::new(libyuv_mjpeg_decoder(resolution)),
-                        fallback_active: false,
-                        output: Vec::with_capacity(
-                            PixelFormat::Nv12
-                                .frame_size(resolution)
-                                .unwrap_or((resolution.width * resolution.height * 3 / 2) as usize),
-                        ),
-                    },
-                    PixelFormat::Nv12,
-                ));
-            }
-            Err(err) => {
-                tracing::warn!(
-                    "Android MediaCodec MJPEG decoder unavailable; using libyuv MJPEG->NV12: {}",
-                    err
-                );
-            }
-        }
-    }
-
     info!("MJPEG input detected, using libyuv decoder (MJPEG -> NV12)");
     Ok((libyuv_mjpeg_decoder(resolution), PixelFormat::Nv12))
 }
@@ -400,15 +286,9 @@ pub(super) fn build_encoder_state(
         }
     };
 
-    #[cfg(all(
-        any(target_arch = "aarch64", target_arch = "arm"),
-        not(target_os = "android")
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
     let is_rkmpp_encoder = selected_codec_name.contains("rkmpp");
-    #[cfg(all(
-        any(target_arch = "aarch64", target_arch = "arm"),
-        not(target_os = "android")
-    ))]
+    #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
     if needs_mjpeg_decode
         && is_rkmpp_encoder
         && matches!(
@@ -448,15 +328,9 @@ pub(super) fn build_encoder_state(
             nv12_converter: None,
             yuv420p_converter: None,
             encoder_needs_yuv420p: false,
-            #[cfg(all(
-                any(target_arch = "aarch64", target_arch = "arm"),
-                not(target_os = "android")
-            ))]
+            #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
             ffmpeg_hw_pipeline: Some(pipeline),
-            #[cfg(all(
-                any(target_arch = "aarch64", target_arch = "arm"),
-                not(target_os = "android")
-            ))]
+            #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
             ffmpeg_hw_enabled: true,
             fps: config.fps,
             codec: config.output_codec,
@@ -495,40 +369,7 @@ pub(super) fn build_encoder_state(
                 );
             }
 
-            #[cfg(feature = "android-mediacodec")]
-            {
-                if codec_name == "h264_mediacodec" {
-                    info!(
-                        "Creating Android MediaCodec H264 encoder for {:?} input",
-                        input_format
-                    );
-                    let pixel_format = match input_format {
-                        H264InputFormat::Nv12 => PixelFormat::Nv12,
-                        H264InputFormat::Yuv420p => PixelFormat::Yuv420,
-                        other => {
-                            return Err(AppError::VideoError(format!(
-                                "Android MediaCodec H264 does not support {:?} direct input",
-                                other
-                            )));
-                        }
-                    };
-                    let encoder = AndroidMediaCodecH264Encoder::new(
-                        config.resolution,
-                        pixel_format,
-                        config.fps,
-                        config.bitrate_kbps(),
-                    )?;
-                    info!("Created Android MediaCodec H264 encoder");
-                    Box::new(AndroidMediaCodecH264EncoderWrapper(encoder))
-                } else {
-                    create_h264_encoder(config, input_format, &codec_name)?
-                }
-            }
-
-            #[cfg(not(feature = "android-mediacodec"))]
-            {
-                create_h264_encoder(config, input_format, &codec_name)?
-            }
+            create_h264_encoder(config, input_format, &codec_name)?
         }
         VideoEncoderType::H265 => {
             let codec_name = selected_codec_name.clone();
@@ -622,11 +463,6 @@ pub(super) fn build_encoder_state(
             pipeline_input_format,
             PixelFormat::Nv12 | PixelFormat::Nv16 | PixelFormat::Nv21 | PixelFormat::Yuv420
         )
-    } else if codec_name.contains("mediacodec") {
-        matches!(
-            pipeline_input_format,
-            PixelFormat::Nv12 | PixelFormat::Yuv420
-        )
     } else {
         false
     };
@@ -676,15 +512,9 @@ pub(super) fn build_encoder_state(
         nv12_converter,
         yuv420p_converter,
         encoder_needs_yuv420p: needs_yuv420p,
-        #[cfg(all(
-            any(target_arch = "aarch64", target_arch = "arm"),
-            not(target_os = "android")
-        ))]
+        #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
         ffmpeg_hw_pipeline: None,
-        #[cfg(all(
-            any(target_arch = "aarch64", target_arch = "arm"),
-            not(target_os = "android")
-        ))]
+        #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
         ffmpeg_hw_enabled: false,
         fps: config.fps,
         codec: config.output_codec,
@@ -708,12 +538,6 @@ fn h264_direct_input_format(
             PixelFormat::Nv24 => Some(H264InputFormat::Nv24),
             _ => None,
         }
-    } else if codec_name.contains("mediacodec") {
-        match input_format {
-            PixelFormat::Nv12 => Some(H264InputFormat::Nv12),
-            PixelFormat::Yuv420 => Some(H264InputFormat::Yuv420p),
-            _ => None,
-        }
     } else if codec_name.contains("libx264") {
         match input_format {
             PixelFormat::Nv12 => Some(H264InputFormat::Nv12),