/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.media;

import android.annotation.IntDef;
import android.annotation.NonNull;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Describes a set of encoding profiles for a given media (audio and/or video) profile.
 * These settings are read-only.
 *
 * <p>Currently, this is used to describe camera recording profile with more detail than {@link
 * CamcorderProfile}, by providing encoding parameters for more than just the default audio
 * and/or video codec.
 *
 * <p>The compressed output from a camera recording session contains two tracks:
 * one for audio and one for video.
 * <p>In the future audio-only recording profiles may be defined.
 *
 * <p>Each media profile specifies a set of audio and a set of video specific settings.
 * <ul>
 * <li> The file output format
 * <li> Default file duration
 * <p>Video-specific settings are:
 * <li> Video codec format
 * <li> Video bit rate in bits per second
 * <li> Video frame rate in frames per second
 * <li> Video frame width and height,
 * <li> Video encoder profile.
 * <p>Audio-specific settings are:
 * <li> Audio codec format
 * <li> Audio bit rate in bits per second,
 * <li> Audio sample rate
 * <li> Number of audio channels for recording.
 * </ul>
 */
public final class EncoderProfiles
{
    /**
     * Default recording duration in seconds before the session is terminated.
     * This is useful for applications like MMS that have a limited file size requirement.
     * This could be 0 if there is no default recording duration.
     */
    public int getDefaultDurationSeconds() {
        return durationSecs;
    }

    /**
     * Recommended output file format
     * @see android.media.MediaRecorder.OutputFormat
     */
    public @MediaRecorder.OutputFormatValues int getRecommendedFileFormat() {
        return fileFormat;
    }

    /**
     * Configuration for a video encoder.
     */
    public final static class VideoProfile {
        /**
         * The video encoder being used for the video track
         * @see android.media.MediaRecorder.VideoEncoder
         */
        public @MediaRecorder.VideoEncoderValues int getCodec() {
            return codec;
        }

        /**
         * The media type of the video encoder being used for the video track
         * @see android.media.MediaFormat#KEY_MIME
         */
        public @NonNull String getMediaType() {
            if (codec == MediaRecorder.VideoEncoder.H263) {
                return MediaFormat.MIMETYPE_VIDEO_H263;
            } else if (codec == MediaRecorder.VideoEncoder.H264) {
                return MediaFormat.MIMETYPE_VIDEO_AVC;
            } else if (codec == MediaRecorder.VideoEncoder.MPEG_4_SP) {
                return MediaFormat.MIMETYPE_VIDEO_MPEG4;
            } else if (codec == MediaRecorder.VideoEncoder.VP8) {
                return MediaFormat.MIMETYPE_VIDEO_VP8;
            } else if (codec == MediaRecorder.VideoEncoder.HEVC) {
                return MediaFormat.MIMETYPE_VIDEO_HEVC;
            } else if (codec == MediaRecorder.VideoEncoder.VP9) {
                return MediaFormat.MIMETYPE_VIDEO_VP9;
            } else if (codec == MediaRecorder.VideoEncoder.DOLBY_VISION) {
                return MediaFormat.MIMETYPE_VIDEO_DOLBY_VISION;
            } else if (codec == MediaRecorder.VideoEncoder.AV1) {
                return MediaFormat.MIMETYPE_VIDEO_AV1;
            }
            // we should never be here
            throw new RuntimeException("Unknown codec");
        }

        /**
         * The target video output bitrate in bits per second
         * <p>
         * This is the target recorded video output bitrate if the application configures the video
         * recording via {@link MediaRecorder#setProfile} without specifying any other
         * {@link MediaRecorder} encoding parameters. For example, for high speed quality profiles
         * (from {@link CamcorderProfile#QUALITY_HIGH_SPEED_LOW} to {@link
         * CamcorderProfile#QUALITY_HIGH_SPEED_2160P}), this is the bitrate where the video is
         * recorded with. If the application intends to record slow motion videos with the high
         * speed quality profiles, it must set a different video bitrate that is corresponding to
         * the desired recording output bit rate (i.e., the encoded video bitrate during normal
         * playback) via {@link MediaRecorder#setVideoEncodingBitRate}. For example, if {@link
         * CamcorderProfile#QUALITY_HIGH_SPEED_720P} advertises 240fps {@link #getFrameRate} and
         * 64Mbps {@link #getBitrate} in the high speed VideoProfile, and the application
         * intends to record 1/8 factor slow motion recording videos, the application must set 30fps
         * via {@link MediaRecorder#setVideoFrameRate} and 8Mbps ( {@link #getBitrate} * slow motion
         * factor) via {@link MediaRecorder#setVideoEncodingBitRate}. Failing to do so will result
         * in videos with unexpected frame rate and bit rate, or {@link MediaRecorder} error if the
         * output bit rate exceeds the encoder limit. If the application intends to do the video
         * recording with {@link MediaCodec} encoder, it must set each individual field of {@link
         * MediaFormat} similarly according to this VideoProfile.
         * </p>
         *
         * @see #getFrameRate
         * @see MediaRecorder
         * @see MediaCodec
         * @see MediaFormat
         */
        public int getBitrate() {
            return bitrate;
        }

        /**
         * The target video frame rate in frames per second.
         * <p>
         * This is the target recorded video output frame rate per second if the application
         * configures the video recording via {@link MediaRecorder#setProfile} without specifying
         * any other {@link MediaRecorder} encoding parameters. For example, for high speed quality
         * profiles (from {@link CamcorderProfile#QUALITY_HIGH_SPEED_LOW} to {@link
         * CamcorderProfile#QUALITY_HIGH_SPEED_2160P}), this is the frame rate where the video is
         * recorded and played back with. If the application intends to create slow motion use case
         * with the high speed quality profiles, it must set a different video frame rate that is
         * corresponding to the desired output (playback) frame rate via {@link
         * MediaRecorder#setVideoFrameRate}. For example, if {@link
         * CamcorderProfile#QUALITY_HIGH_SPEED_720P} advertises 240fps {@link #getFrameRate}
         * in the VideoProfile, and the application intends to create 1/8 factor slow motion
         * recording videos, the application must set 30fps via {@link
         * MediaRecorder#setVideoFrameRate}. Failing to do so will result in high speed videos with
         * normal speed playback frame rate (240fps for above example). If the application intends
         * to do the video recording with {@link MediaCodec} encoder, it must set each individual
         * field of {@link MediaFormat} similarly according to this VideoProfile.
         * </p>
         *
         * @see #getBitrate
         * @see MediaRecorder
         * @see MediaCodec
         * @see MediaFormat
         */
        public int getFrameRate() {
            return frameRate;
        }

        /**
         * The target video frame width in pixels
         */
        public int getWidth() {
            return width;
        }

        /**
         * The target video frame height in pixels
         */
        public int getHeight() {
            return height;
        }

        /**
         * The video encoder profile being used for the video track.
         * <p>
         * This value is negative if there is no profile defined for the video codec.
         *
         * @see MediaRecorder#setVideoEncodingProfileLevel
         * @see MediaFormat#KEY_PROFILE
         */
        public int getProfile() {
            return profile;
        }

        /**
         * The bit depth of the encoded video.
         * <p>
         * This value is effectively 8 or 10, but some devices may
         * support additional values.
         */
        public int getBitDepth() {
            return bitDepth;
        }

        /**
         * The chroma subsampling of the encoded video.
         * <p>
         * For most devices this is always YUV_420 but some devices may
         * support additional values.
         *
         * @see #YUV_420
         * @see #YUV_422
         * @see #YUV_444
         */
        public @ChromaSubsampling int getChromaSubsampling() {
            return chromaSubsampling;
        }

        /**
         * The HDR format of the encoded video.
         * <p>
         * This is one of the HDR_ values.
         * @see #HDR_NONE
         * @see #HDR_HLG
         * @see #HDR_HDR10
         * @see #HDR_HDR10PLUS
         * @see #HDR_DOLBY_VISION
         */
        public @HdrFormat int getHdrFormat() {
            return hdrFormat;
        }

        // Constructor called by JNI and CamcorderProfile
        /* package private */ VideoProfile(int codec,
                             int width,
                             int height,
                             int frameRate,
                             int bitrate,
                             int profile,
                             int chromaSubsampling,
                             int bitDepth,
                             int hdrFormat) {
            this.codec = codec;
            this.width = width;
            this.height = height;
            this.frameRate = frameRate;
            this.bitrate = bitrate;
            this.profile = profile;
            this.chromaSubsampling = chromaSubsampling;
            this.bitDepth = bitDepth;
            this.hdrFormat = hdrFormat;
        }

        /* package private */ VideoProfile(int codec,
                             int width,
                             int height,
                             int frameRate,
                             int bitrate,
                             int profile) {
            this(codec, width, height, frameRate, bitrate, profile,
                 YUV_420, 8 /* bitDepth */, HDR_NONE);
        }

        private int codec;
        private int width;
        private int height;
        private int frameRate;
        private int bitrate;
        private int profile;
        private int chromaSubsampling;
        private int bitDepth;
        private int hdrFormat;

        /** @hide */
        @IntDef({
            HDR_NONE,
            HDR_HLG,
            HDR_HDR10,
            HDR_HDR10PLUS,
            HDR_DOLBY_VISION,
        })
        @Retention(RetentionPolicy.SOURCE)
        public @interface HdrFormat {}

        /** Not HDR (SDR).
         *  <p>
         *  An HDR format specifying SDR (Standard Dynamic
         *  Range) recording. */
        public static final int HDR_NONE = 0;

        /** HLG (Hybrid-Log Gamma).
         *  <p>
         *  An HDR format specifying HLG. */
        public static final int HDR_HLG = 1;

        /** HDR10.
         *  <p>
         *  An HDR format specifying HDR10. */
        public static final int HDR_HDR10 = 2;

        /** HDR10+.
         *  <p>
         *  An HDR format specifying HDR10+. */
        public static final int HDR_HDR10PLUS = 3;

        /**
         *  Dolby Vision
         *  <p>
         *  An HDR format specifying Dolby Vision. For this format
         *  the codec is always a Dolby Vision encoder. The encoder
         *  profile specifies which Dolby Vision version is being
         *  used.
         *
         *  @see #getProfile
         */
        public static final int HDR_DOLBY_VISION = 4;

        /** @hide */
        @IntDef({
            YUV_420,
            YUV_422,
            YUV_444,
        })
        @Retention(RetentionPolicy.SOURCE)
        public @interface ChromaSubsampling {}


        /** YUV 4:2:0.
         *  <p>
         *  A chroma subsampling where the U and V planes are subsampled
         *  by 2 both horizontally and vertically. */
        public static final int YUV_420 = 0;

        /** YUV 4:2:2.
         *  <p>
         *  A chroma subsampling where the U and V planes are subsampled
         *  by 2 horizontally alone. */
        public static final int YUV_422 = 1;

        /** YUV 4:4:4.
         *  <p>
         *  A chroma subsampling where the U and V planes are not
         *  subsampled. */
        public static final int YUV_444 = 2;
    }

    /**
     * Returns the defined audio encoder profiles.
     * <p>
     * The list may be empty. This means there are no audio encoder
     * profiles defined. Otherwise, the first profile is the default
     * audio profile.
     */
    public @NonNull List<AudioProfile> getAudioProfiles() {
        return audioProfiles;
    }

    /**
     * Returns the defined video encoder profiles.
     * <p>
     * The list may be empty. This means there are no video encoder
     * profiles defined. Otherwise, the first profile is the default
     * video profile.
     */
    public @NonNull List<VideoProfile> getVideoProfiles() {
        return videoProfiles;
    }

    /**
     * Configuration for an audio encoder.
     */
    public final static class AudioProfile {
        /**
         * The audio encoder being used for the audio track.
         * @see android.media.MediaRecorder.AudioEncoder
         */
        public @MediaRecorder.AudioEncoderValues int getCodec() {
            return codec;
        }

        /**
         * The media type of the audio encoder being used for the video track
         * @see android.media.MediaFormat#KEY_MIME
         */
        public @NonNull String getMediaType() {
            if (codec == MediaRecorder.AudioEncoder.AMR_NB) {
                return MediaFormat.MIMETYPE_AUDIO_AMR_NB;
            } else if (codec == MediaRecorder.AudioEncoder.AMR_WB) {
                return MediaFormat.MIMETYPE_AUDIO_AMR_WB;
            } else if (codec == MediaRecorder.AudioEncoder.AAC
                    || codec == MediaRecorder.AudioEncoder.HE_AAC
                    || codec == MediaRecorder.AudioEncoder.AAC_ELD) {
                return MediaFormat.MIMETYPE_AUDIO_AAC;
            } else if (codec == MediaRecorder.AudioEncoder.VORBIS) {
                return MediaFormat.MIMETYPE_AUDIO_VORBIS;
            } else if (codec == MediaRecorder.AudioEncoder.OPUS) {
                return MediaFormat.MIMETYPE_AUDIO_OPUS;
            }
            // we should never be here
            throw new RuntimeException("Unknown codec");
        }

        /**
         * The target audio output bitrate in bits per second
         */
        public int getBitrate() {
            return bitrate;
        }

        /**
         * The audio sampling rate used for the audio track
         */
        public int getSampleRate() {
            return sampleRate;
        }

        /**
         * The number of audio channels used for the audio track
         */
        public int getChannels() {
            return channels;
        }

        /**
         * The audio encoder profile being used for the audio track
         * <p>
         * This value is negative if there is no profile defined for the audio codec.
         * @see MediaFormat#KEY_PROFILE
         */
        public int getProfile() {
            if (codec == MediaRecorder.AudioEncoder.AAC) {
                return MediaCodecInfo.CodecProfileLevel.AACObjectMain;
            } else if (codec == MediaRecorder.AudioEncoder.HE_AAC) {
                return MediaCodecInfo.CodecProfileLevel.AACObjectHE;
            } else if (codec == MediaRecorder.AudioEncoder.AAC_ELD) {
                return MediaCodecInfo.CodecProfileLevel.AACObjectELD;
            }
            return profile;
        }


        // Constructor called by JNI and CamcorderProfile
        /* package private */ AudioProfile(
                int codec,
                int channels,
                int sampleRate,
                int bitrate,
                int profile) {
            this.codec = codec;
            this.channels = channels;
            this.sampleRate = sampleRate;
            this.bitrate = bitrate;
            this.profile = profile;
        }

        private int codec;
        private int channels;
        private int sampleRate;
        private int bitrate;
        private int profile;  // this contains the profile if codec itself does not
    }

    private int durationSecs;
    private int fileFormat;
    // non-modifiable lists
    private @NonNull List<AudioProfile> audioProfiles;
    private @NonNull List<VideoProfile> videoProfiles;

    // Constructor called by JNI and CamcorderProfile
    /* package private */ EncoderProfiles(
            int duration,
            int fileFormat,
            VideoProfile[] videoProfiles,
            AudioProfile[] audioProfiles) {
        this.durationSecs     = duration;
        this.fileFormat       = fileFormat;
        this.videoProfiles    = Collections.unmodifiableList(Arrays.asList(videoProfiles));
        this.audioProfiles    = Collections.unmodifiableList(Arrays.asList(audioProfiles));
    }
}