VENDAS: 1-800-867-1389

Ingerindo ativos com os Serviços de Mídia SDK para .NET

Atualizado: agosto de 2014

Este tópico mostra como ingerir (carregar) conteúdo no Serviços de Mídia. Em um aplicativo do Serviços de Mídia, a ingestão de tarefas é o processo de carregar conteúdo (ativos, arquivos de mídia e assim por diante) no sistema. O objeto de conteúdo mais fundamental no Serviços de Mídia é um IAsset, que é uma coleção de metadados sobre um conjunto de arquivos de mídia. Cada IAsset contém um ou mais objetos IAssetFile. Para obter uma explicação mais detalhada do que é um Asset no Serviços de Mídia, consulteAtivo.

noteObservação
O Media Services utiliza o valor da propriedade IAssetFile.Name ao criar URLs para o conteúdo de streaming (por exemplo, http://{WAMSAccount}.origin.mediaservices.windows.net/{GUID}/{IAssetFile.Name}/streamingParameters.) Por esse motivo, a codificação por percentual não é permitida. O valor da propriedade Name não pode conter qualquer um dos seguintes caracteres reservados codificados por percentual: !*'();:@&=+$,/?%#[]". Além disso, pode somente haver um ‘.’ para cada extensão de nome de arquivo.

Existem algumas abordagens diferentes para a ingestão de ativos no Serviços de Mídia:

  • Criar um Asset, criar um ou mais AssetFiles associados ao Asset e então carregar AssetFiles no Serviços de Mídia do Microsoft Azure. Use essa abordagem quando estiver trabalhando com conjuntos menores de arquivos de mídia e quando não estiver usando uma solução de upload separada. Todos os exemplos deste tópico são desse tipo.

  • Faça a ingestão em massa de um conjunto de arquivos preparando um manifesto e carregando-os no Serviços de Mídia do Microsoft Azure usando uma solução de upload separada. Para obter mais informações sobre essa abordagem, consulte Ingerindo ativos em massa com os SDK dos Serviços de Mídia para .NET.

TipDica
Ao carregar um grande número de ativos, considere o seguinte.

O código deste tópico mostra como executar as seguintes tarefas comuns:

noteObservação
Para criar um ativo, primeiro você deve ter uma referência para o contexto do servidor do Serviços de Mídia, como descrito no tópico Conectando-se aos Serviços de Mídia com o SDK dos Serviços de Mídia para .NET. O objeto de contexto é representado pela variável _context nos exemplos de código a seguir.

Antes de você poder carregar um arquivo para o servidor do Serviços de Mídia, primeiro será necessário criar um ativo usando o métodoCreate ou CreateAsync. Ambos os métodos usam o nome do ativo e a opção de criptografia como parâmetros.

Ao criar ativos, você pode especificar três opções diferentes para criptografá-los:

  • AssetCreationOptions.None: nenhuma criptografia.

  • AssetCreationOptions.CommonEncryptionProtected: para arquivos CENC (Common Encryption Protected). Um exemplo é um conjunto de arquivos já criptografados com o PlayReady.

  • AssetCreationOptions.StorageEncrypted: criptografia de armazenamento. Criptografa um arquivo de entrada clara antes que ele seja carregado no armazenamento do Azure.

    noteObservação
    Observe que os Serviços de Mídia fornecem criptografia de armazenamento em disco, e não por cabo como a solução DRM (Digital Rights Manager).

O método CreateEmptyAsset mostra como criar um ativo vazio.

static private IAsset CreateEmptyAsset(string assetName, AssetCreationOptions assetCreationOptions)
{
    var asset = _context.Assets.Create(assetName, assetCreationOptions);

    Console.WriteLine("Asset name: " + asset.Name);
    Console.WriteLine("Time created: " + asset.Created.Date.ToString());

    return asset;
}

O código nesta seção faz o seguinte:

  1. Cria um Asset vazio usando o método CreateEmptyAsset definido na etapa anterior.

  2. Cria uma instância de AssetFile associada com o Asset.

  3. Carrega o arquivo de mídia associado ao AssetFile no Serviços de Mídia.

noteObservação
A instância de AssetFile e o arquivo de mídia real são dois objetos distintos. A instância de AssetFile contém metadados sobre o arquivo de mídia, enquanto o arquivo de mídia contém a mídia real.

static public IAsset CreateAssetAndUploadSingleFile( AssetCreationOptions assetCreationOptions, string singleFilePath)
{   
    var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
    var asset = CreateEmptyAsset(assetName, assetCreationOptions);
    var fileName = Path.GetFileName(singleFilePath);
    var assetFile = asset.AssetFiles.Create(fileName);

    Console.WriteLine("Created assetFile {0}", assetFile.Name);
    Console.WriteLine("Upload {0}", assetFile.Name);

    assetFile.Upload(singleFilePath);
    Console.WriteLine("Done uploading of {0}", assetFile.Name);

    return asset;

}

O código nesta seção faz o seguinte:

  1. Cria um ativo vazio usando o método CreateEmptyAsset definido na etapa anterior.

  2. Cria uma instância de AccessPolicy que define as permissões e a duração do acesso ao ativo.

  3. Cria uma instância do Locator que fornece acesso ao ativo.

  4. Cria a instância de BlobTransferClient. Esse tipo representa um clique que opera nos blobs do Azure. Neste exemplo, usamos o cliente para monitorar o andamento do upload.

  5. Enumera os arquivos no diretório especificado e cria uma instância de AssetFile para cada arquivo.

  6. Carrega os arquivos no Serviços de Mídia usando o método UploadAsync.

    TipDica
    Use o método UploadAsync para garantir que as chamadas não estejam sendo bloqueadas e que os arquivos estejam sendo carregados em paralelo.

static public IAsset CreateAssetAndUploadMultipleFiles(AssetCreationOptions assetCreationOptions, string folderPath)
{
      var assetName = "UploadMultipleFiles_" + DateTime.UtcNow.ToString();
      var asset = CreateEmptyAsset(assetName, assetCreationOptions);
      var accessPolicy = _context.AccessPolicies.Create(assetName, TimeSpan.FromDays(30), AccessPermissions.Write | AccessPermissions.List);
      var locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);

      var blobTransferClient = new BlobTransferClient();
      blobTransferClient.NumberOfConcurrentTransfers = 20;
      blobTransferClient.ParallelTransferThreadCount = 20;
      blobTransferClient.TransferProgressChanged += blobTransferClient_TransferProgressChanged;

       var filePaths = Directory.EnumerateFiles(folderPath);

       Console.WriteLine("There are {0} files in {1}", filePaths.Count(), folderPath);

       if (!filePaths.Any())
       {
           throw new FileNotFoundException(String.Format("No files in directory, check folderPath: {0}", folderPath));
       }

       var uploadTasks = new List<Task>();
       foreach (var filePath in filePaths)
       {
            var assetFile = asset.AssetFiles.Create(Path.GetFileName(filePath));

            Console.WriteLine("Start uploading of {0}", assetFile.Name);
            uploadTasks.Add(assetFile.UploadAsync(filePath, blobTransferClient, locator, CancellationToken.None));
       }

      Task.WaitAll(uploadTasks.ToArray());
      Console.WriteLine("Done uploading the files");

      blobTransferClient.TransferProgressChanged -= blobTransferClient_TransferProgressChanged;
      locator.Delete();
      accessPolicy.Delete();

      return asset;

}

static void  blobTransferClient_TransferProgressChanged(object sender, BlobTransferProgressChangedEventArgs e)
{
    Console.WriteLine("{0}% upload competed for {1}.", e.ProgressPercentage, e.LocalFile);
}

Você está pronto para seguir para o próximo tópico: Ingerindo ativos em massa com os SDK dos Serviços de Mídia para .NET.

Consulte também

Isso foi útil para você?
(1500 caracteres restantes)
Agradecemos os seus comentários
Mostrar:
© 2015 Microsoft