O Oracle Cloud Infrastructure (OCI) Media Streams é um serviço que ajuda os desenvolvedores a empacotar conteúdo de vídeo para transmiti-lo a partir da OCI ou por meio de uma rede de distribuição de conteúdo (Content Delivery Network, CDN). Ele criptografa o conteúdo de mídia para distribui-lo de forma segura a dispositivos, incluindo televisões inteligentes, celulares, computadores e consoles de jogos. Os desenvolvedores agora podem aproveitar a escalabilidade da OCI para oferecer uma experiência de vídeo completa sem precisar gerenciar a infraestrutura.
Ao usar um serviço de empacotamento de vídeo just-in-time (JIT), como o OCI Media Streams, você só precisa transcodificar seu conteúdo uma vez. O serviço converte automaticamente o arquivo de origem nas representações desejadas. A criptografia de conteúdo e os formatos de streaming são aplicados dinamicamente com base nas solicitações de vários dispositivos, o que economiza tempo e esforço.
As cargas de aplicações de vídeo variam consideravelmente. Aproveite que o OCI Media Streams tem a oferecer e a OCI irá aumentar ou diminuir automaticamente a infraestrutura com base no tráfego. Transmita diretamente da OCI, por meio da CDN ou de uma experiência personalizada.
Proteja a distribuição do seu conteúdo com métodos fortes de criptografia e garanta que ele seja entregue com segurança. Como um serviço da OCI, o OCI Media Streams vem automaticamente com altos padrões de conformidade e criptografia de segurança, facilitando a conformidade com os padrões do GDPR.
Veja como transmitir mídia e executar jobs do OCI Media Streams. Isso requer o Java SDK mais recente da OCI, e você deve inserir o nome da playlist principal e o do bucket residente. O propósito é apenas para demonstração e não para uso em produção.
/***********
This is a demo program to create media streams.
This requires the latest java SDK of OCI.
Takes input of the master playlist name and residing bucket name.
This is intended for a demonstration only and not for Production usage.
************/
/***********
1. Accept User Input of Object Storage Bucket name & HLS Master playlist (m3u8).
(Note: This takes only master.m3u8 and not sub-playlists as input)
2. Create Media Client.
3. Create Distribution Channel.
4. Configure CDN for Distribution Channel.
5. Create Stream Packaging Configuration.
6. Create Asset ID for the provided input master playlist.
7. Ingest the Asset ID into the Distribution Channel.
8. Create MediaStreams Client with distribution channel as endpoint.
9. After Ingest complete, generate Session Token.
10. Display's URL that is HLS streamable.
************/
import com.oracle.bmc.auth.InstancePrincipalsAuthenticationDetailsProvider;
import com.oracle.bmc.auth.AuthenticationDetailsProvider;
import com.oracle.bmc.auth.ConfigFileAuthenticationDetailsProvider;
import com.oracle.bmc.mediaservices.MediaServicesClient;
import com.oracle.bmc.mediaservices.*;
import com.oracle.bmc.mediaservices.requests.*;
import com.oracle.bmc.mediaservices.responses.*;
import com.oracle.bmc.mediaservices.model.*;
import com.oracle.bmc.mediaservices.requests.CreateStreamCdnConfigRequest;
import com.oracle.bmc.mediaservices.requests.CreateStreamDistributionChannelRequest;
import com.oracle.bmc.mediaservices.requests.CreateMediaAssetRequest;
import com.oracle.bmc.mediaservices.requests.CreateStreamPackagingConfigRequest;
import com.oracle.bmc.mediaservices.requests.IngestStreamDistributionChannelRequest;
import com.oracle.bmc.mediaservices.responses.CreateMediaAssetResponse;
import com.oracle.bmc.mediaservices.responses.CreateStreamCdnConfigResponse;
import com.oracle.bmc.mediaservices.responses.CreateStreamDistributionChannelResponse;
import com.oracle.bmc.mediaservices.responses.CreateStreamPackagingConfigResponse;
import com.oracle.bmc.mediaservices.responses.IngestStreamDistributionChannelResponse;
import com.oracle.bmc.mediaservices.model.IngestStreamDistributionChannelResult;
import com.oracle.bmc.mediaservices.model.MediaAsset;
import com.oracle.bmc.mediaservices.model.StreamCdnConfig;
import com.oracle.bmc.mediaservices.model.StreamDistributionChannel;
import com.oracle.bmc.mediaservices.model.StreamPackagingConfig;
import com.oracle.bmc.mediaservices.MediaStreamClient;
import com.oracle.bmc.mediaservices.model.CreateStreamDistributionChannelDetails;
import com.oracle.bmc.mediaservices.model.CreateStreamCdnConfigDetails;
import com.oracle.bmc.mediaservices.model.IngestStreamDistributionChannelDetails;
import com.oracle.bmc.mediaservices.requests.CreateStreamDistributionChannelRequest;
import com.oracle.bmc.mediaservices.model.EdgeStreamCdnConfig;
import com.oracle.bmc.mediaservices.model.StreamCdnConfigSection;
import com.oracle.bmc.mediaservices.model.CreateStreamPackagingConfigDetails.StreamPackagingFormat;
import com.oracle.bmc.mediaservices.model.StreamPackagingConfigEncryptionNone;
import com.oracle.bmc.mediaservices.model.AssetType;
import com.oracle.bmc.mediaservices.requests.GenerateSessionTokenRequest;
import com.oracle.bmc.mediaservices.model.GenerateSessionTokenDetails;
import com.oracle.bmc.mediaservices.requests.GetMediaWorkflowJobRequest;
import com.oracle.bmc.mediaservices.responses.GetMediaWorkflowJobResponse;
import com.oracle.bmc.mediaservices.model.MediaWorkflowJob.LifecycleState;
import org.json.simple.*;
import org.json.simple.parser.*;
import java.util.Collections;
import java.util.*;
import java.util.Scanner;
public class MediastreamsDemoApp {
// User Input
public static String[] getUserInput(){
String[] inputs = new String[2];
MediastreamsDemoApp.printString("\n", "Enter name of bucket where master playlist is located:");
Scanner input = new Scanner(System.in);
String inputBucketName = input.nextLine();
MediastreamsDemoApp.printString("\n","Enter name of master playlist to be ingested:");
String inputPlaylistName = input.nextLine();
input.close();
inputs[0] = inputBucketName;
inputs[1] = inputPlaylistName;
return inputs;
}
// Print Function
public static void printString(Object stringtoPrint , Object stringtoPrint2){
System.out.println(stringtoPrint);
System.out.println(stringtoPrint2);
}
// Media Client Creation by default with Instance Principal.
// Toggle the other java lines in this code for User Principal.
public static MediaServicesClient connectMediaService(){
InstancePrincipalsAuthenticationDetailsProvider provider = InstancePrincipalsAuthenticationDetailsProvider.builder().build();
MediaServicesClient mediaClient = new MediaServicesClient(provider);
// User Principal
// Read config from the profile DEFAULT in the file "~/.oci/config". You can switch to different profile.
// AuthenticationDetailsProvider authenticationDetailsProvider = new ConfigFileAuthenticationDetailsProvider(PROFILE_DEFAULT);
// MediaServicesClient mediaClient = MediaServicesClient.builder().build(authenticationDetailsProvider);
return mediaClient;
}
// Closing Media Client
public static void closeMediaService(MediaServicesClient mc,MediaStreamClient ms){
mc.close();
ms.close();
MediastreamsDemoApp.printString("\n", "Media Clients are Closed");
}
// Create Media Streams Client
// Default this program creates using Instance Principal
public static MediaStreamClient connectMediaStreams(StreamDistributionChannel dc){
String endpoint = dc.getDomainName();
InstancePrincipalsAuthenticationDetailsProvider provider = InstancePrincipalsAuthenticationDetailsProvider.builder().build();
MediaStreamClient mediaStreamsClient = new MediaStreamClient(provider);
// User Principal
// Read config from the profile DEFAULT in the file "~/.oci/config". You can switch to different profile.
// AuthenticationDetailsProvider authenticationDetailsProvider = new ConfigFileAuthenticationDetailsProvider(PROFILE_DEFAULT);
// MediaStreamClient mediaStreamsClient = MediaStreamClient.builder().build(authenticationDetailsProvider);
mediaStreamsClient.setEndpoint("https://"+endpoint);
MediastreamsDemoApp.printString("\n" ,"Media Streams Client Instatiated Successfully");
return mediaStreamsClient;
}
// Create Distribution Channel
public static StreamDistributionChannel createDistributionChannel(MediaServicesClient mc, String compartment_id){
CreateStreamDistributionChannelRequest request = CreateStreamDistributionChannelRequest.builder().createStreamDistributionChannelDetails(CreateStreamDistributionChannelDetails.builder().displayName("test-java-sdk").compartmentId(compartment_id).build()).build();
CreateStreamDistributionChannelResponse response = mc.createStreamDistributionChannel(request);
StreamDistributionChannel dc = response.getStreamDistributionChannel();
return dc;
}
//Create CDN - In this case, its OCI Edge.
public static void createCDN(MediaServicesClient mc, String compartment_id, StreamDistributionChannel dc){
String channelId = dc.getId();
CreateStreamCdnConfigRequest request = CreateStreamCdnConfigRequest.builder().createStreamCdnConfigDetails(
CreateStreamCdnConfigDetails.builder().displayName("test-java-sdk").isEnabled(true).distributionChannelId(channelId).config(EdgeStreamCdnConfig.builder().build()).build()).build();
CreateStreamCdnConfigResponse response = mc.createStreamCdnConfig(request);
StreamCdnConfig cdnConfig = response.getStreamCdnConfig();
}
// Create Streaming Package Configuration
// By default Unencrypted in this code.
public static StreamPackagingConfig createStreamPackage(MediaServicesClient mc, StreamDistributionChannel dc){
String channelId = dc.getId();
// Unencrypted Stream
CreateStreamPackagingConfigRequest request = CreateStreamPackagingConfigRequest.builder().createStreamPackagingConfigDetails(CreateStreamPackagingConfigDetails.builder().displayName("test-java-sdk").distributionChannelId(channelId).streamPackagingFormat(CreateStreamPackagingConfigDetails.StreamPackagingFormat.valueOf("Hls")).segmentTimeInSeconds(6).encryption(StreamPackagingConfigEncryptionNone.builder().build()).build()).build();
// AES 128 encrypted stream
//CreateStreamPackagingConfigRequest request = CreateStreamPackagingConfigRequest.builder().createStreamPackagingConfigDetails(CreateStreamPackagingConfigDetails.builder().displayName("test-java-sdk").distributionChannelId(channelId).streamPackagingFormat(CreateStreamPackagingConfigDetails.StreamPackagingFormat.valueOf("Hls")).segmentTimeInSeconds(6).encryption(StreamPackagingConfigEncryptionAes128.builder().build()).build()).build();
CreateStreamPackagingConfigResponse response = mc.createStreamPackagingConfig(request);
StreamPackagingConfig packageConfig = response.getStreamPackagingConfig();
return packageConfig;
}
// Create Media Asset ID for given master playlist
public static MediaAsset createAsset(MediaServicesClient mc, String inputBucket,String masterPlayList, String namespace, String compartmentId){
CreateMediaAssetRequest request = CreateMediaAssetRequest.builder().createMediaAssetDetails(CreateMediaAssetDetails.builder().bucketName(inputBucket).displayName("test-java-sdk").objectName(masterPlayList).namespaceName(namespace).type(AssetType.valueOf("Playlist")).compartmentId(compartmentId).build()).build();
CreateMediaAssetResponse response = mc.createMediaAsset(request);
MediaAsset mediaAsset = response.getMediaAsset();
return mediaAsset;
}
// Ingest the Master Playlist to Distribution Channel
public static IngestStreamDistributionChannelResult ingestAsset(MediaServicesClient mc, MediaAsset ma, StreamDistributionChannel dc, String compartmentId){
String assetId = ma.getId();
String channelId = dc.getId();
IngestStreamDistributionChannelRequest request = IngestStreamDistributionChannelRequest.builder().ingestStreamDistributionChannelDetails(AssetMetadataEntryDetails.builder().mediaAssetId(assetId).compartmentId(compartmentId).build()).streamDistributionChannelId(channelId).build();
IngestStreamDistributionChannelResponse response = mc.ingestStreamDistributionChannel(request);
IngestStreamDistributionChannelResult ingestResult = response.getIngestStreamDistributionChannelResult();
return ingestResult;
}
// Get the Media WorkflowJob ID for the Ingest Job
public static MediaWorkflowJob checkIngestJobStatus(MediaServicesClient mc, IngestStreamDistributionChannelResult ingestStatus) {
String mediaWorkflowId = ingestStatus.getMediaWorkflowJobId();
GetMediaWorkflowJobRequest request = GetMediaWorkflowJobRequest.builder().mediaWorkflowJobId(mediaWorkflowId).build();
GetMediaWorkflowJobResponse response = mc.getMediaWorkflowJob(request);
MediaWorkflowJob mediaWorkflowJob = response.getMediaWorkflowJob();
return mediaWorkflowJob;
}
// Check the status of the Ingest Job using above Media Workflow Job ID
public static String jobLifecycleState(MediaServicesClient mediaClient,IngestStreamDistributionChannelResult ingestStatus){
MediaWorkflowJob mediaWorkflowJob = MediastreamsDemoApp.checkIngestJobStatus(mediaClient,ingestStatus);
MediaWorkflowJob.LifecycleState lifestate = mediaWorkflowJob.getLifecycleState();
String ingestCurrentStatus = lifestate.getValue();
return ingestCurrentStatus;
}
// Create Session Token
// Defaults to 24 hour validity
public static SessionToken generateSessionToken(MediaStreamClient ms, StreamPackagingConfig sp, MediaAsset ma){
String streamPackagingId = sp.getId();
String mediaAssetId = ma.getId();
List<GenerateSessionTokenDetails.Scopes> scopes = new ArrayList<GenerateSessionTokenDetails.Scopes>();
scopes.add(GenerateSessionTokenDetails.Scopes.valueOf("Edge"));
scopes.add(GenerateSessionTokenDetails.Scopes.valueOf("Playlist"));
List<String> assetIds = new ArrayList<String>();
assetIds.add(mediaAssetId);
GenerateSessionTokenRequest request = GenerateSessionTokenRequest.builder().generateSessionTokenDetails(GenerateSessionTokenDetails.builder().packagingConfigId(streamPackagingId).scopes(scopes).assetIds(assetIds).build()).build();
GenerateSessionTokenResponse response = ms.generateSessionToken(request);
SessionToken sessionToken = response.getSessionToken();
return sessionToken;
}
public static void spinningWheel() throws InterruptedException{
String a = "|/-\\";
while (true) {
for (int i = 0; i < 4; i++) {
System.out.print("\033[0;0H"); // place cursor at top left corner
for (int j = 0; j < 80; j++) { // 80 character terminal width, say
System.out.print(a.charAt(i));
}
Thread.sleep(250);
}
}
}
public static void main(String[] args) throws InterruptedException{
// **Variable Declarations** //
String compartment_id = "ocid1.compartment.oc1..aaaaaaaabhuut4zoztxlfneotrwuauqt5wjhmj4kxaka6ajme4ipxqlcwv6a";
String namespace = "axjagzvlc4vi";
String [] inputs = MediastreamsDemoApp.getUserInput();
String inputBucket = inputs[0];
String masterPlayList = inputs[1];
// Connect to media services
MediaServicesClient mediaClient = MediastreamsDemoApp.connectMediaService();
MediastreamsDemoApp.printString("\n", "Media Client Instatiated Successfully");
// Create Distribution Channel
StreamDistributionChannel distributionChannel = MediastreamsDemoApp.createDistributionChannel(mediaClient, compartment_id);
MediastreamsDemoApp.printString("\n Distribution Channel Created Successfully",distributionChannel.getId());
// Configure CDN for the distribution channel
MediastreamsDemoApp.createCDN(mediaClient, compartment_id, distributionChannel);
// Create stream packaging Configuration
StreamPackagingConfig streamPackageConfig = MediastreamsDemoApp.createStreamPackage(mediaClient, distributionChannel);
MediastreamsDemoApp.printString("\n Streaming Packaging Configuration Created Successfully", streamPackageConfig.getId());
// Create Media Asset for provided master playlist
MediaAsset mediaAsset = MediastreamsDemoApp.createAsset(mediaClient, inputBucket, masterPlayList, namespace, compartment_id);
MediastreamsDemoApp.printString("\n Media Asset Registered Successfully" , mediaAsset.getId());
// Initiate Ingest of the master playlist into the Distribution channel
IngestStreamDistributionChannelResult ingestStatus = MediastreamsDemoApp.ingestAsset(mediaClient, mediaAsset, distributionChannel, compartment_id);
MediastreamsDemoApp.printString("\n Ingest of Asset Initiated with Job", ingestStatus.getMediaWorkflowJobId());
// Run Loop for ingest job to complete.
boolean status = false;
System.out.print("Ingesting");
while (!status){
String ingestValue = MediastreamsDemoApp.jobLifecycleState(mediaClient,ingestStatus);
System.out.print(".");
Thread.sleep(3000);
//System.out.println(ingestCurrentStatus);
if ((ingestValue == "SUCCEEDED") || (ingestValue == "FAILED")){
break;
}
}
String ingestOutcome = MediastreamsDemoApp.jobLifecycleState(mediaClient,ingestStatus);
MediastreamsDemoApp.printString("\nIngest Completed with status", ingestOutcome);
if (ingestOutcome == "SUCCEEDED") {
// Create media Streams Client with distribution cahnnel
MediaStreamClient mediaStreamsClient = MediastreamsDemoApp.connectMediaStreams(distributionChannel);
// Generate session token for the master playlist.
SessionToken sessionToken = MediastreamsDemoApp.generateSessionToken(mediaStreamsClient, streamPackageConfig, mediaAsset);
//MediastreamsDemoApp.printString(sessionToken.getToken());
MediastreamsDemoApp.printString("\n\nStream Media with your player:\n\n","https://"+distributionChannel.getDomainName()+"/20211101/actions/generatePlaylist?mediaAssetId="+mediaAsset.getId()+"&streamPackagingConfigId="+streamPackageConfig.getId()+"&token="+sessionToken.getToken());
// Close the Media Clients
MediastreamsDemoApp.closeMediaService(mediaClient,mediaStreamsClient);
}
else {
mediaClient.close();
}
}
}
Facilite o acesso a vídeos armazenados por meio de IDs de ativos com o OCI Media Streams, que empacota o conteúdo para que você só precise transcodificá-lo uma vez para transmitir em vários formatos e tipos de dispositivos. A criptografia do conteúdo e os formatos de streaming são aplicados dinamicamente para maximizar o tempo e o esforço do desenvolvedor.
Depois que o OCI Media Flow fornece o formato de vídeo correto para sites populares de mídia social, o serviço empacota o conteúdo de vídeo e o criptografa para transmitir a partir de uma variedade de dispositivos, incluindo telefones celulares e consoles de jogos.
Crie, processe e armazene vídeos para ter uma experiência de plataforma de aprendizagem com o OCI Media Flow. Em seguida, use o OCI Media Streams para empacotar e criptografar o conteúdo para uma transmissão mais segura. Métodos robustos de criptografia de conteúdo garantem que seus vídeos sejam transmitidos apenas para onde você deseja.
Remi Fourreau, Gerente Principal de Produtos, Oracle
Temos o prazer de anunciar a disponibilidade geral dos Digital Media Services (DMS) na Oracle Cloud Infrastructure (OCI). Os clientes da OCI que possuem conteúdo de vídeo podem aproveitar os recursos de processamento de mídia de baixo custo com o DMS Media Flow e distribuição de mídia com os serviços DMS Media Streams. Esses serviços podem aprimorar aplicações e processos corporativos com novos recursos de mídia que proporcionam melhores experiências para os clientes e melhoram as operações de negócios.
Leia a publicação completaA Oracle oferece um Modo Gratuito sem limite de tempo na seleção de serviços como Media Streams, Media Flow e AI Services, bem como US$ 300 em créditos gratuitos para experimentar serviços de nuvem adicionais. Obtenha os detalhes e inscreva-se para uma conta gratuita hoje mesmo.
Tem interesse em aprender mais sobre o Media Streams? Deixe um de nossos especialistas ajudar.