Amazon MediaConvert

Un service de transcodage file-based qui convertit vos contenus audiovisuels en formats adaptés au streaming et à la diffusion sur n'importe quel appareil.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce qu'Amazon MediaConvert ?

Imaginez que vous avez une vidéo de haute qualité que vous souhaitez diffuser sur votre site web, via des applications mobiles et des smart TVs. Chaque appareil a besoin d'un format différent, d'une résolution adaptée et d'un débit optimal pour offrir la meilleure expérience possible.

Amazon MediaConvert est comme une usine automatisée qui transforme rapidement votre vidéo source en différentes versions optimisées pour tous les appareils et débits internet. Il s'occupe de toute la complexité technique du transcodage et de la compression vidéo.

Pourquoi utiliser MediaConvert ?

Qualité professionnelle

Transforme vos vidéos avec une qualité digne des diffuseurs professionnels, avec support pour la 4K, le HDR, les sous-titres et bien plus.

Simplicité et évolutivité

Convertit des milliers de vidéos sans gérer d'infrastructure complexe, avec un paiement à l'usage qui s'adapte à vos besoins.

En résumé, MediaConvert permet à n'importe quelle entreprise de créer des flux de travail vidéo professionnels sans avoir à se préoccuper des défis techniques de l'encodage vidéo. Que vous soyez un diffuseur de contenu, une agence de marketing ou une entreprise avec des besoins vidéo, il simplifie considérablement la distribution de vos contenus.

Pour les développeurs

Fonctionnement technique

Amazon MediaConvert est un service de transcodage vidéo file-based qui permet de convertir des fichiers vidéo stockés dans Amazon S3 en formats adaptés à la diffusion sur différents appareils. Il utilise la technologie AWS Elemental et offre des fonctionnalités avancées de traitement vidéo.

Fonctionnalités principales

Création de tâches de transcodage

Pour convertir une vidéo, vous créez une "tâche" (job) qui spécifie les fichiers d'entrée, les paramètres de sortie souhaités, et d'autres options de traitement. Voici un exemple complet de création d'une tâche MediaConvert avec le SDK AWS:

Création d'une tâche MediaConvert

// Création d'une tâche de conversion vidéo avec MediaConvert
const { MediaConvertClient, CreateJobCommand } = require('@aws-sdk/client-mediaconvert');

// Fonction pour créer une tâche de conversion
async function createConversionJob() {
  // Créer un client MediaConvert avec des points de terminaison spécifiques à la région
  const mediaConvertClient = new MediaConvertClient({ 
    region: 'eu-west-1',
    endpoint: 'https://mediaconvert.eu-west-1.amazonaws.com' 
  });
  
  // Configuration de la tâche
  const params = {
    Queue: 'arn:aws:mediaconvert:eu-west-1:123456789012:queues/Default',
    Role: 'arn:aws:iam::123456789012:role/MediaConvert_Role',
    Settings: {
      // Configuration des entrées
      Inputs: [
        {
          FileInput: 's3://input-bucket/my-video.mp4',
          AudioSelectors: {
            'Audio Selector 1': {
              DefaultSelection: 'DEFAULT'
            }
          },
          VideoSelector: {
            ColorSpace: 'FOLLOW',
            Rotate: 'AUTO'
          },
          TimecodeSource: 'EMBEDDED'
        }
      ],
      // Configuration des groupes de sortie
      OutputGroups: [
        {
          // Groupe de sortie pour HLS (streaming adaptatif)
          Name: 'Apple HLS',
          OutputGroupSettings: {
            Type: 'HLS_GROUP_SETTINGS',
            HlsGroupSettings: {
              SegmentLength: 6,
              MinSegmentLength: 0,
              Destination: 's3://output-bucket/hls/',
              DestinationSettings: {
                S3Settings: {
                  AccessControl: {
                    CannedAcl: 'PUBLIC_READ'
                  }
                }
              },
              DirectoryStructure: 'SINGLE_DIRECTORY',
              ManifestDurationFormat: 'FLOATING_POINT',
              StreamInfResolution: 'INCLUDE',
              ClientCache: 'ENABLED',
              CaptionLanguageSetting: 'OMIT',
              ManifestCompression: 'NONE',
              CodecSpecification: 'RFC_4281',
              OutputSelection: 'MANIFESTS_AND_SEGMENTS',
              ProgramDateTimePeriod: 600,
              ProgramDateTime: 'EXCLUDE',
              TimedMetadataId3Period: 10,
              TimedMetadataId3Frame: 'PRIV',
              HlsCaptionLanguageSetting: 'OMIT',
              ManifestDurationFormat: 'INTEGER',
              SegmentControl: 'SEGMENTED_FILES',
              MinFinalSegmentLength: 0,
              SegmentLength: 6,
              MinSegmentLength: 0
            }
          },
          Outputs: [
            {
              // Configuration de variante 720p
              NameModifier: '_720p',
              VideoDescription: {
                ScalingBehavior: 'DEFAULT',
                TimecodeInsertion: 'DISABLED',
                AntiAlias: 'ENABLED',
                Sharpness: 50,
                CodecSettings: {
                  Codec: 'H_264',
                  H264Settings: {
                    InterlaceMode: 'PROGRESSIVE',
                    ParNumerator: 1,
                    ParDenominator: 1,
                    RateControlMode: 'QVBR',
                    QvbrSettings: {
                      QvbrQualityLevel: 8,
                      QvbrQualityLevelFineTune: 0
                    },
                    CodecProfile: 'HIGH',
                    MaxBitrate: 5000000,
                    QualityTuningLevel: 'SINGLE_PASS_HQ',
                    FlickerAdaptiveQuantization: 'ENABLED',
                    SpatialAdaptiveQuantization: 'ENABLED',
                    TemporalAdaptiveQuantization: 'ENABLED',
                    FramerateControl: 'INITIALIZE_FROM_SOURCE',
                    GopSize: 2,
                    GopSizeUnits: 'SECONDS',
                    GopClosedCadence: 1,
                    HrdBufferSize: 10000000,
                    HrdBufferInitialFillPercentage: 90,
                    SlowPal: 'DISABLED',
                    SyntaxType: 'DEFAULT',
                    DropFrameTimecode: 'ENABLED',
                    GopBReference: 'DISABLED',
                    AdaptiveQuantization: 'HIGH',
                    EndOfStreamMarkers: 'ENABLED'
                  }
                },
                AfdSignaling: 'NONE',
                DropFrameTimecode: 'ENABLED',
                RespondToAfd: 'NONE',
                ColorMetadata: 'INSERT',
                Width: 1280,
                Height: 720
              },
              AudioDescriptions: [
                {
                  AudioTypeControl: 'FOLLOW_INPUT',
                  CodecSettings: {
                    Codec: 'AAC',
                    AacSettings: {
                      AudioDescriptionBroadcasterMix: 'NORMAL',
                      RateControlMode: 'CBR',
                      CodecProfile: 'LC',
                      CodingMode: 'CODING_MODE_2_0',
                      RawFormat: 'NONE',
                      SampleRate: 48000,
                      Specification: 'MPEG4',
                      Bitrate: 96000
                    }
                  },
                  LanguageCodeControl: 'FOLLOW_INPUT',
                  AudioSourceName: 'Audio Selector 1'
                }
              ],
              OutputSettings: {
                HlsSettings: {
                  AudioGroupId: 'program_audio',
                  IFrameOnlyManifest: 'EXCLUDE'
                }
              },
              ContainerSettings: {
                Container: 'M3U8',
                M3u8Settings: {
                  AudioFramesPerPes: 4,
                  PcrControl: 'PCR_EVERY_PES_PACKET',
                  PmtPid: 480,
                  PrivateMetadataPid: 503,
                  ProgramNumber: 1,
                  PatInterval: 0,
                  PmtInterval: 0,
                  Scte35Source: 'NONE',
                  NielsenId3: 'NONE',
                  TimedMetadata: 'NONE',
                  VideoPid: 481,
                  AudioPids: [
                    482,
                    483,
                    484,
                    485,
                    486,
                    487,
                    488,
                    489,
                    490,
                    491,
                    492
                  ],
                  AudioDuration: 'DEFAULT_CODEC_DURATION'
                }
              }
            },
            {
              // Configuration de variante 480p
              NameModifier: '_480p',
              VideoDescription: {
                ScalingBehavior: 'DEFAULT',
                TimecodeInsertion: 'DISABLED',
                AntiAlias: 'ENABLED',
                Sharpness: 50,
                CodecSettings: {
                  Codec: 'H_264',
                  H264Settings: {
                    InterlaceMode: 'PROGRESSIVE',
                    ParNumerator: 1,
                    ParDenominator: 1,
                    RateControlMode: 'QVBR',
                    QvbrSettings: {
                      QvbrQualityLevel: 7,
                      QvbrQualityLevelFineTune: 0
                    },
                    CodecProfile: 'MAIN',
                    MaxBitrate: 2000000,
                    QualityTuningLevel: 'SINGLE_PASS_HQ',
                    FlickerAdaptiveQuantization: 'ENABLED',
                    SpatialAdaptiveQuantization: 'ENABLED',
                    TemporalAdaptiveQuantization: 'ENABLED',
                    FramerateControl: 'INITIALIZE_FROM_SOURCE',
                    GopSize: 2,
                    GopSizeUnits: 'SECONDS',
                    GopClosedCadence: 1,
                    HrdBufferSize: 4000000,
                    HrdBufferInitialFillPercentage: 90,
                    SlowPal: 'DISABLED',
                    SyntaxType: 'DEFAULT',
                    DropFrameTimecode: 'ENABLED',
                    GopBReference: 'DISABLED',
                    AdaptiveQuantization: 'HIGH',
                    EndOfStreamMarkers: 'ENABLED'
                  }
                },
                AfdSignaling: 'NONE',
                DropFrameTimecode: 'ENABLED',
                RespondToAfd: 'NONE',
                ColorMetadata: 'INSERT',
                Width: 854,
                Height: 480
              },
              AudioDescriptions: [
                {
                  AudioTypeControl: 'FOLLOW_INPUT',
                  CodecSettings: {
                    Codec: 'AAC',
                    AacSettings: {
                      AudioDescriptionBroadcasterMix: 'NORMAL',
                      RateControlMode: 'CBR',
                      CodecProfile: 'LC',
                      CodingMode: 'CODING_MODE_2_0',
                      RawFormat: 'NONE',
                      SampleRate: 48000,
                      Specification: 'MPEG4',
                      Bitrate: 64000
                    }
                  },
                  LanguageCodeControl: 'FOLLOW_INPUT',
                  AudioSourceName: 'Audio Selector 1'
                }
              ],
              OutputSettings: {
                HlsSettings: {
                  AudioGroupId: 'program_audio',
                  IFrameOnlyManifest: 'EXCLUDE'
                }
              },
              ContainerSettings: {
                Container: 'M3U8',
                M3u8Settings: {
                  AudioFramesPerPes: 4,
                  PcrControl: 'PCR_EVERY_PES_PACKET',
                  PmtPid: 480,
                  PrivateMetadataPid: 503,
                  ProgramNumber: 1,
                  PatInterval: 0,
                  PmtInterval: 0,
                  Scte35Source: 'NONE',
                  NielsenId3: 'NONE',
                  TimedMetadata: 'NONE',
                  VideoPid: 481,
                  AudioPids: [
                    482,
                    483,
                    484,
                    485,
                    486,
                    487,
                    488,
                    489,
                    490,
                    491,
                    492
                  ],
                  AudioDuration: 'DEFAULT_CODEC_DURATION'
                }
              }
            }
          ]
        },
        {
          // Groupe de sortie MP4 pour téléchargement
          Name: 'File Group',
          OutputGroupSettings: {
            Type: 'FILE_GROUP_SETTINGS',
            FileGroupSettings: {
              Destination: 's3://output-bucket/mp4/',
              DestinationSettings: {
                S3Settings: {
                  AccessControl: {
                    CannedAcl: 'PUBLIC_READ'
                  }
                }
              }
            }
          },
          Outputs: [
            {
              NameModifier: '_download',
              VideoDescription: {
                ScalingBehavior: 'DEFAULT',
                TimecodeInsertion: 'DISABLED',
                AntiAlias: 'ENABLED',
                Sharpness: 50,
                CodecSettings: {
                  Codec: 'H_264',
                  H264Settings: {
                    InterlaceMode: 'PROGRESSIVE',
                    ParNumerator: 1,
                    ParDenominator: 1,
                    RateControlMode: 'QVBR',
                    QvbrSettings: {
                      QvbrQualityLevel: 9,
                      QvbrQualityLevelFineTune: 0
                    },
                    CodecProfile: 'HIGH',
                    MaxBitrate: 8000000,
                    QualityTuningLevel: 'MULTI_PASS_HQ',
                    FramerateControl: 'INITIALIZE_FROM_SOURCE',
                    GopSize: 2,
                    GopSizeUnits: 'SECONDS',
                    HrdBufferSize: 16000000,
                    HrdBufferInitialFillPercentage: 90,
                    SlowPal: 'DISABLED',
                    SyntaxType: 'DEFAULT',
                    GopBReference: 'ENABLED',
                    AdaptiveQuantization: 'HIGH',
                    SpatialAdaptiveQuantization: 'ENABLED',
                    TemporalAdaptiveQuantization: 'ENABLED',
                    FlickerAdaptiveQuantization: 'ENABLED'
                  }
                },
                AfdSignaling: 'NONE',
                DropFrameTimecode: 'ENABLED',
                RespondToAfd: 'NONE',
                ColorMetadata: 'INSERT'
              },
              AudioDescriptions: [
                {
                  AudioTypeControl: 'FOLLOW_INPUT',
                  CodecSettings: {
                    Codec: 'AAC',
                    AacSettings: {
                      AudioDescriptionBroadcasterMix: 'NORMAL',
                      RateControlMode: 'CBR',
                      CodecProfile: 'LC',
                      CodingMode: 'CODING_MODE_2_0',
                      RawFormat: 'NONE',
                      SampleRate: 48000,
                      Specification: 'MPEG4',
                      Bitrate: 192000
                    }
                  },
                  LanguageCodeControl: 'FOLLOW_INPUT',
                  AudioSourceName: 'Audio Selector 1'
                }
              ],
              ContainerSettings: {
                Container: 'MP4',
                Mp4Settings: {
                  CslgAtom: 'INCLUDE',
                  FreeSpaceBox: 'EXCLUDE',
                  MoovPlacement: 'PROGRESSIVE_DOWNLOAD',
                  AudioDuration: 'DEFAULT_CODEC_DURATION'
                }
              }
            }
          ]
        }
      ]
    },
    // Métadonnées et balises
    UserMetadata: {
      'Customer': 'WebTV',
      'ProjectName': 'Summer Special 2023'
    },
    Tags: {
      'Project': 'SummerPromos',
      'Department': 'Marketing'
    },
    // Paramètres de priorité et notifications
    Priority: 0,
    StatusUpdateInterval: 'SECONDS_60',
    AccelerationSettings: {
      Mode: 'PREFERRED'
    },
    HopDestinations: []
  };

  try {
    // Soumettre la tâche à MediaConvert
    const data = await mediaConvertClient.send(new CreateJobCommand(params));
    console.log('Tâche de conversion créée avec succès, ID:', data.Job.Id);
    return data.Job.Id;
  } catch (err) {
    console.error('Erreur lors de la création de la tâche de conversion:', err);
    throw err;
  }
}

Suivi des tâches

Après avoir soumis une tâche, vous pouvez suivre son état et obtenir des informations sur sa progression:

Vérification du statut d'une tâche MediaConvert

// Vérification du statut d'une tâche MediaConvert
const { MediaConvertClient, GetJobCommand } = require('@aws-sdk/client-mediaconvert');

// Fonction pour vérifier le statut d'une tâche de conversion
async function checkJobStatus(jobId) {
  // Créer un client MediaConvert
  const mediaConvertClient = new MediaConvertClient({ 
    region: 'eu-west-1',
    endpoint: 'https://mediaconvert.eu-west-1.amazonaws.com' 
  });
  
  try {
    // Récupérer les détails de la tâche
    const data = await mediaConvertClient.send(new GetJobCommand({ Id: jobId }));
    
    // Afficher le statut actuel
    const job = data.Job;
    const status = job.Status;
    const progress = job.JobPercentComplete || 0;
    const createdAt = job.CreatedAt;
    const startedAt = job.StartedAt;
    const completedAt = job.CompletedAt;
    
    console.log(`Statut de la tâche ${jobId}: ${status}`);
    console.log(`Progression: ${progress}%`);
    console.log(`Créée le: ${new Date(createdAt).toLocaleString()}`);
    
    if (startedAt) {
      console.log(`Démarrée le: ${new Date(startedAt).toLocaleString()}`);
    }
    
    if (completedAt) {
      console.log(`Terminée le: ${new Date(completedAt).toLocaleString()}`);
    }
    
    if (status === 'ERROR' && job.ErrorMessage) {
      console.error(`Erreur: ${job.ErrorMessage}`);
    }
    
    if (status === 'COMPLETE') {
      // Afficher les informations sur les sorties générées
      job.OutputGroupDetails.forEach((group, groupIndex) => {
        console.log(`Groupe de sortie ${groupIndex + 1}: ${group.Type}`);
        
        group.OutputDetails.forEach((output, outputIndex) => {
          console.log(`  Sortie ${outputIndex + 1}:`);
          console.log(`    Durée: ${output.DurationInMs} ms`);
          console.log(`    Taille: ${output.SizeInBytes} octets`);
          
          if (output.VideoDetails) {
            console.log(`    Vidéo: ${output.VideoDetails.WidthInPx}x${output.VideoDetails.HeightInPx}, ${output.VideoDetails.CodecDetails.Codec}`);
          }
        });
      });
    }
    
    return {
      status,
      progress,
      createdAt,
      startedAt,
      completedAt,
      job
    };
  } catch (err) {
    console.error(`Erreur lors de la vérification du statut de la tâche ${jobId}:`, err);
    throw err;
  }
}

Modèles de tâches

Les modèles de tâches (job templates) permettent de standardiser vos configurations de transcodage et de les réutiliser facilement:

Création d'un modèle de tâche MediaConvert

// Création d'un modèle de tâche réutilisable pour MediaConvert
const { MediaConvertClient, CreateJobTemplateCommand } = require('@aws-sdk/client-mediaconvert');

// Fonction pour créer un modèle de tâche
async function createJobTemplate() {
  // Créer un client MediaConvert
  const mediaConvertClient = new MediaConvertClient({ 
    region: 'eu-west-1',
    endpoint: 'https://mediaconvert.eu-west-1.amazonaws.com' 
  });
  
  // Configuration du modèle
  const params = {
    Name: 'OnDemandStreamingTemplate',
    Description: 'Modèle pour la conversion de vidéos à la demande avec HLS adaptatif',
    Category: 'Web Streaming',
    Queue: 'arn:aws:mediaconvert:eu-west-1:123456789012:queues/Default',
    Settings: {
      // Configuration des entrées (variables, à définir lors de l'utilisation du modèle)
      Inputs: [
        {
          AudioSelectors: {
            'Audio Selector 1': {
              DefaultSelection: 'DEFAULT'
            }
          },
          VideoSelector: {
            ColorSpace: 'FOLLOW',
            Rotate: 'AUTO'
          },
          TimecodeSource: 'EMBEDDED'
        }
      ],
      // Configuration des groupes de sortie
      OutputGroups: [
        {
          // Groupe de sortie pour HLS (streaming adaptatif)
          Name: 'Apple HLS',
          OutputGroupSettings: {
            Type: 'HLS_GROUP_SETTINGS',
            HlsGroupSettings: {
              SegmentLength: 6,
              MinSegmentLength: 0,
              DirectoryStructure: 'SINGLE_DIRECTORY',
              ManifestDurationFormat: 'FLOATING_POINT',
              StreamInfResolution: 'INCLUDE',
              ClientCache: 'ENABLED',
              CaptionLanguageSetting: 'OMIT',
              ManifestCompression: 'NONE',
              CodecSpecification: 'RFC_4281',
              OutputSelection: 'MANIFESTS_AND_SEGMENTS',
              ProgramDateTime: 'EXCLUDE',
              TimedMetadataId3Frame: 'PRIV',
              SegmentControl: 'SEGMENTED_FILES'
            }
          },
          Outputs: [
            {
              // Configuration de variante 720p
              NameModifier: '_720p',
              VideoDescription: {
                ScalingBehavior: 'DEFAULT',
                TimecodeInsertion: 'DISABLED',
                AntiAlias: 'ENABLED',
                Sharpness: 50,
                CodecSettings: {
                  Codec: 'H_264',
                  H264Settings: {
                    InterlaceMode: 'PROGRESSIVE',
                    RateControlMode: 'QVBR',
                    QvbrSettings: {
                      QvbrQualityLevel: 8
                    },
                    CodecProfile: 'HIGH',
                    MaxBitrate: 5000000,
                    QualityTuningLevel: 'SINGLE_PASS_HQ',
                    FlickerAdaptiveQuantization: 'ENABLED',
                    SpatialAdaptiveQuantization: 'ENABLED',
                    TemporalAdaptiveQuantization: 'ENABLED',
                    FramerateControl: 'INITIALIZE_FROM_SOURCE',
                    GopSize: 2,
                    GopSizeUnits: 'SECONDS'
                  }
                },
                Width: 1280,
                Height: 720
              },
              AudioDescriptions: [
                {
                  CodecSettings: {
                    Codec: 'AAC',
                    AacSettings: {
                      RateControlMode: 'CBR',
                      CodecProfile: 'LC',
                      CodingMode: 'CODING_MODE_2_0',
                      SampleRate: 48000,
                      Bitrate: 96000
                    }
                  },
                  AudioSourceName: 'Audio Selector 1'
                }
              ],
              OutputSettings: {
                HlsSettings: {
                  AudioGroupId: 'program_audio',
                  IFrameOnlyManifest: 'EXCLUDE'
                }
              },
              ContainerSettings: {
                Container: 'M3U8',
                M3u8Settings: {}
              }
            },
            {
              // Configuration de variante 480p
              NameModifier: '_480p',
              VideoDescription: {
                ScalingBehavior: 'DEFAULT',
                TimecodeInsertion: 'DISABLED',
                AntiAlias: 'ENABLED',
                Sharpness: 50,
                CodecSettings: {
                  Codec: 'H_264',
                  H264Settings: {
                    InterlaceMode: 'PROGRESSIVE',
                    RateControlMode: 'QVBR',
                    QvbrSettings: {
                      QvbrQualityLevel: 7
                    },
                    CodecProfile: 'MAIN',
                    MaxBitrate: 2000000,
                    QualityTuningLevel: 'SINGLE_PASS_HQ'
                  }
                },
                Width: 854,
                Height: 480
              },
              AudioDescriptions: [
                {
                  CodecSettings: {
                    Codec: 'AAC',
                    AacSettings: {
                      RateControlMode: 'CBR',
                      CodecProfile: 'LC',
                      CodingMode: 'CODING_MODE_2_0',
                      SampleRate: 48000,
                      Bitrate: 64000
                    }
                  },
                  AudioSourceName: 'Audio Selector 1'
                }
              ],
              OutputSettings: {
                HlsSettings: {
                  AudioGroupId: 'program_audio',
                  IFrameOnlyManifest: 'EXCLUDE'
                }
              },
              ContainerSettings: {
                Container: 'M3U8',
                M3u8Settings: {}
              }
            },
            {
              // Configuration de variante 360p
              NameModifier: '_360p',
              VideoDescription: {
                ScalingBehavior: 'DEFAULT',
                TimecodeInsertion: 'DISABLED',
                AntiAlias: 'ENABLED',
                Sharpness: 50,
                CodecSettings: {
                  Codec: 'H_264',
                  H264Settings: {
                    InterlaceMode: 'PROGRESSIVE',
                    RateControlMode: 'QVBR',
                    QvbrSettings: {
                      QvbrQualityLevel: 6
                    },
                    CodecProfile: 'MAIN',
                    MaxBitrate: 1000000,
                    QualityTuningLevel: 'SINGLE_PASS_HQ'
                  }
                },
                Width: 640,
                Height: 360
              },
              AudioDescriptions: [
                {
                  CodecSettings: {
                    Codec: 'AAC',
                    AacSettings: {
                      RateControlMode: 'CBR',
                      CodecProfile: 'LC',
                      CodingMode: 'CODING_MODE_2_0',
                      SampleRate: 48000,
                      Bitrate: 48000
                    }
                  },
                  AudioSourceName: 'Audio Selector 1'
                }
              ],
              OutputSettings: {
                HlsSettings: {
                  AudioGroupId: 'program_audio',
                  IFrameOnlyManifest: 'EXCLUDE'
                }
              },
              ContainerSettings: {
                Container: 'M3U8',
                M3u8Settings: {}
              }
            }
          ]
        }
      ]
    },
    AccelerationSettings: {
      Mode: 'PREFERRED'
    },
    StatusUpdateInterval: 'SECONDS_60',
    Priority: 0,
    Tags: {
      'Purpose': 'WebStreaming',
      'CreatedBy': 'MediaTeam'
    }
  };

  try {
    // Créer le modèle de tâche
    const data = await mediaConvertClient.send(new CreateJobTemplateCommand(params));
    console.log('Modèle de tâche créé avec succès, nom:', data.JobTemplate.Name);
    return data.JobTemplate.Name;
  } catch (err) {
    console.error('Erreur lors de la création du modèle de tâche:', err);
    throw err;
  }
}

Utilisation des modèles

Une fois qu'un modèle est créé, vous pouvez l'utiliser pour lancer rapidement des conversions avec des paramètres cohérents:

Utilisation d'un modèle de tâche existant

// Utilisation d'un modèle de tâche existant
const { MediaConvertClient, CreateJobCommand } = require('@aws-sdk/client-mediaconvert');

// Fonction pour créer une tâche à partir d'un modèle
async function createJobFromTemplate(inputFile, outputS3Uri, templateName) {
  // Créer un client MediaConvert
  const mediaConvertClient = new MediaConvertClient({ 
    region: 'eu-west-1',
    endpoint: 'https://mediaconvert.eu-west-1.amazonaws.com' 
  });
  
  // Configuration de la tâche basée sur le modèle
  const params = {
    // Référence au modèle existant
    JobTemplate: templateName,
    // Remplacer les valeurs spécifiques à cette tâche
    Role: 'arn:aws:iam::123456789012:role/MediaConvert_Role',
    Settings: {
      // Définir l'entrée spécifique pour cette tâche
      Inputs: [
        {
          FileInput: inputFile,
          AudioSelectors: {
            'Audio Selector 1': {
              DefaultSelection: 'DEFAULT'
            }
          },
          VideoSelector: {},
          TimecodeSource: 'EMBEDDED'
        }
      ],
      // Remplacer les destinations de sortie
      OutputGroups: [
        {
          OutputGroupSettings: {
            HlsGroupSettings: {
              Destination: `${outputS3Uri}/hls/`
            }
          }
        }
      ]
    },
    // Métadonnées spécifiques à cette tâche
    UserMetadata: {
      'SourceFile': inputFile.split('/').pop(),
      'ConversionDate': new Date().toISOString()
    }
  };

  try {
    // Soumettre la tâche à MediaConvert
    const data = await mediaConvertClient.send(new CreateJobCommand(params));
    console.log('Tâche de conversion créée avec succès à partir du modèle, ID:', data.Job.Id);
    return data.Job.Id;
  } catch (err) {
    console.error('Erreur lors de la création de la tâche à partir du modèle:', err);
    throw err;
  }
}

// Exemple d'utilisation
async function processNewVideo() {
  const templateName = 'OnDemandStreamingTemplate';
  const inputFile = 's3://my-input-bucket/raw-videos/conference-2023.mp4';
  const outputS3Uri = 's3://my-output-bucket/videos/conference-2023';
  
  try {
    const jobId = await createJobFromTemplate(inputFile, outputS3Uri, templateName);
    console.log(`Conversion de la vidéo ${inputFile.split('/').pop()} lancée avec l'ID: ${jobId}`);
    return jobId;
  } catch (err) {
    console.error('Processus de conversion échoué:', err);
    throw err;
  }
}

Fonctionnalités avancées

Formats d'entrée multiples - Prise en charge de nombreux formats d'entrée comme MXF, MP4, MOV, AVI, etc.
Streaming adaptatif - Génération automatique de rendus HLS, DASH, MSS pour le streaming adaptatif
Codecs avancés - Support de H.264, H.265 (HEVC), VP8, VP9, AV1, etc.
Traitement HDR - Support des formats HDR comme HDR10, HDR10+, HLG et Dolby Vision
Traitement audio avancé - Encodage Dolby Digital, Dolby Digital Plus, normalisation du volume, etc.
Sous-titres - Conversion et incrustation de sous-titres dans différents formats
Accélération - Option d'accélération matérielle pour un traitement plus rapide
Files d'attente - Gestion des priorités et réservation de capacité
Intégration avec AWS Media Services - Fonctionne avec AWS Lambda, MediaLive, MediaPackage, MediaStore, etc.

Applications concrètes

Cas d'usage

Vidéo à la demande (VOD)

Plateformes de streaming vidéo comme Netflix, Disney+ ou services de SVOD d'entreprise qui doivent convertir leurs contenus en multiples formats pour tous les appareils.

Archives médias

Diffuseurs et organisations culturelles qui numérisent et convertissent des archives analogiques en formats numériques standardisés avec des métadonnées préservées.

Production cinématographique

Sociétés de production qui ont besoin de convertir des rushes de tournage en formats appropriés pour le montage, la post-production et la distribution.

Marketing et médias sociaux

Entreprises et agences qui doivent adapter leurs publicités vidéo pour différentes plateformes sociales, chacune avec ses propres spécifications techniques.