Carga de vídeo en YouTube pitón evento livestream

votos
0

Estoy tratando de hacer una aplicación en Python que me permite vivir mi stream de vídeo de la cámara a YouTube. Hasta ahora con la ayuda de la documentación de Google desarrollador he insertado con éxito, en directo por streaming y enlazarlo a emitir.

Actualmente creo que la transmisión en vivo es sólo un evento y voy a tener que subir un video por separado (no sé si estoy bien o mal sobre esto). Si usted me puede explicar cómo añadir vídeo en el mismo (por favor trate de mantenerlo libre como para mi proyecto universitario, no sé si la transmisión en vivo a través de cualquier servicio tiene ningún cargo o no). He leído en alguna parte sobre ffmpeg pero no puedo encontrar la manera de usarlo. Estoy trabajando en Python 3.4, el sistema operativo es Windows 10.

este es mi código:

#!/usr/bin/python


import argparse
import http.client as httplib
import httplib2
import os
import random
import time
import re
import ffmpeg
import google.oauth2.credentials
import google_auth_oauthlib.flow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from googleapiclient.http import MediaFileUpload
from google_auth_oauthlib.flow import InstalledAppFlow
import sys
import  urllib.error
from oauth2client.client import flow_from_clientsecrets
from oauth2client.file import Storage
from oauth2client.tools import argparser, run_flow

# The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
# the OAuth 2.0 information for this application, including its client_id and
# client_secret. You can acquire an OAuth 2.0 client ID and client secret from
# the {{ Google Cloud Console }} at
# {{ https://cloud.google.com/console }}.
# Please ensure that you have enabled the YouTube Data API for your project.
# For more information about using OAuth2 to access the YouTube Data API, see:
#   https://developers.google.com/youtube/v3/guides/authentication
# For more information about the client_secrets.json file format, see:
#   https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
CLIENT_SECRETS_FILE = client_id.json

# This OAuth 2.0 access scope allows for full read/write access to the
# authenticated user's account.
SCOPES = ['https://www.googleapis.com/auth/youtube']
API_SERVICE_NAME = 'youtube'
API_VERSION = 'v3'
YOUTUBE_READ_WRITE_SCOPE = https://www.googleapis.com/auth/youtube
YOUTUBE_API_SERVICE_NAME = youtube
YOUTUBE_API_VERSION = v3

# This variable defines a message to display if the CLIENT_SECRETS_FILE is
# missing.
ACTIONS = ('get', 'list', 'set')
MISSING_CLIENT_SECRETS_MESSAGE = 
WARNING: Please configure OAuth 2.0
To make this sample run you will need to populate the client_secrets.json file
found at:
   %s
with information from the {{ Cloud Console }}
{{ https://cloud.google.com/console }}
For more information about the client_secrets.json file format, please visit:
https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
 % os.path.abspath(os.path.join(os.path.dirname(__file__),
                                   CLIENT_SECRETS_FILE))

def get_authenticated_service_VIDEO():
  flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
  credentials = flow.run_console()
  return build(API_SERVICE_NAME, API_VERSION, credentials = credentials)

def get_authenticated_service(args):
  flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE,
    scope=YOUTUBE_READ_WRITE_SCOPE,
    message=MISSING_CLIENT_SECRETS_MESSAGE)

  storage = Storage(%s-oauth2.json % sys.argv[0])
  credentials = storage.get()

  if credentials is None or credentials.invalid:
    credentials = run_flow(flow, storage, args)

  return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
    http=credentials.authorize(httplib2.Http()))

# Create a liveBroadcast resource and set its title, scheduled start time,
# scheduled end time, and privacy status.
def insert_broadcast(youtube, options):
  insert_broadcast_response = youtube.liveBroadcasts().insert(
    part=snippet,status,
    body=dict(
      snippet=dict(
        title=options.broadcast_title,
        scheduledStartTime=options.start_time,
        scheduledEndTime=options.end_time
      ),
      status=dict(
        privacyStatus=options.privacy_status
      )
    )
  ).execute()

  snippet = insert_broadcast_response[snippet]


  print(Broadcast '%s' with title '%s' was published at '%s'. % (
    insert_broadcast_response[id], snippet[title], snippet[publishedAt]))
  return insert_broadcast_response[id]

# Create a liveStream resource and set its title, format, and ingestion type.
# This resource describes the content that you are transmitting to YouTube.
def insert_stream(youtube, options):
  insert_stream_response = youtube.liveStreams().insert(
    part=snippet,cdn,
    body=dict(
      snippet=dict(
        title=options.stream_title
      ),
      cdn=dict(
        format=1080p,
        ingestionType=rtmp
      )
    )
  ).execute()

  snippet = insert_stream_response[snippet]

  print(Stream '%s' with title '%s' was inserted. % (
    insert_stream_response[id], snippet[title]))
  return insert_stream_response[id]

# Bind the broadcast to the video stream. By doing so, you link the video that
# you will transmit to YouTube to the broadcast that the video is for.
def bind_broadcast(youtube, broadcast_id, stream_id):

  bind_broadcast_response = youtube.liveBroadcasts().bind(
    part=id,contentDetails,
    id=broadcast_id,
    streamId=stream_id
  ).execute()

  print(Broadcast '%s' was bound to stream '%s'. % (
    bind_broadcast_response[id],
    bind_broadcast_response[contentDetails][boundStreamId]))

  # VBR = 2500k  # Bitrate de la vidéo en sortie
  # FPS = 30  # FPS de la vidéo en sortie
  # QUAL = medium  # Preset de qualité FFMPEG
  # YOUTUBE_URL = rtmp://a.rtmp.youtube.com/live2  # URL de base RTMP youtube
  #
  # SOURCE = '/dev/video0'  # Source UDP (voir les annonces SAP)
  # KEY = ....  # Clé à récupérer sur l'event youtube
  #
  # ffmpeg
  #     .input()
  # -i $SOURCE - deinterlace ^
  # -vcodec libx264 - pix_fmt yuv420p - preset $QUAL - r $FPS - g $(($FPS * 2)) - b: v $VBR ^
  # -acodec libmp3lame - ar 44100 - threads 6 - qscale3 - b: a 712000 - bufsize 512 k ^
  # -f flv $YOUTUBE_URL/$KEY
  # vid = youtube.insert(
  #   part=id,contentDetails,
  #   id=broadcast_id,
  #   streamId=stream_id
  # ).execute()


if __name__ == __main__:
  argparser.add_argument(--broadcast-title, help=Broadcast title,
    default=Teing BD)
  argparser.add_argument(--privacy-status, help=Broadcast privacy status,
    default=public)
  argparser.add_argument(--start-time, help=Scheduled start time,
    default='2018-11-27T13:33:00.000Z')
  argparser.add_argument(--end-time, help=Scheduled end time,
    default='2018-11-27T13:50:00.000Z')
  argparser.add_argument(--stream-title, help=Stream title,
    default=Project )
  args = argparser.parse_args()

  youtube = get_authenticated_service(args)
  try:
    broadcast_id = insert_broadcast(youtube, args)
    stream_id = insert_stream(youtube, args)
    bind_broadcast(youtube, broadcast_id, stream_id)
  except (HttpError, e):
    print(An HTTP error %d occurred:\n%s % (e.resp.status, e.content))

dando a la salida:

Screencap

Publicado el 27/11/2018 a las 16:51
fuente por usuario
En otros idiomas...                            

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more