/// <summary> /// Upload a file to your Brightcove account /// </summary> /// <param name="video"> /// The metadata for the video you'd like to create. This takes the form of a /// JSON object of name/value pairs, each of which corresponds to a settable /// property of the Video object. /// </param> /// <param name="filename"> /// The name of the file that's being uploaded. You don't need to specify this in /// the JSON if it is specified in the file part of the POST. /// </param> /// <param name="file"> /// A byte array of the video file you're uploading. This takes the /// form of a file part, in a multipart/form-data HTTP request. This input stream and /// the filename and maxSide parameters are automatically inferred from that file part. /// </param> /// <param name="encode_to"> /// If the file requires transcoding, use this parameter to specify the target encoding. Valid /// values are MP4 or FLV, representing the H264 and VP6 codecs respectively. Note that transcoding /// of FLV files to another codec is not currently supported. This parameter is optional and defaults to FLV. /// </param> /// <param name="create_multiple_renditions"> /// If the file is a supported transcodeable type, this optional flag can be used to control the /// number of transcoded renditions. If true (default), multiple renditions at varying encoding /// rates and dimensions are created. Setting this to false will cause a single transcoded VP6 /// rendition to be created at the standard encoding rate and dimensions. /// </param> /// <param name="H264NoProcessing"> /// If the video file is H.264 encoded and if create_multiple_ renditions=true, then multiple /// VP6 renditions are created and in addition the H.264 source is retained as an additional rendition. /// </param> /// <param name="preserve_source_rendition"> /// Use this option to prevent H.264 source files from being transcoded. This parameter cannot be /// used in combination with create_multiple_renditions. It is optional and defaults to false. /// </param> /// <param name="maxsize"> /// The maximum size that the file will be. This is used as a limiter to know when /// something has gone wrong with the upload. The maxSize is same as the file you uploaded. /// You don't need to specify this in the JSON if it is specified in the file part of the POST. /// </param> /// <param name="file_checksum"> /// An optional MD5 hash of the file. The checksum can be used to verify that the file checked /// into your Brightcove Media Library is the same as the file you uploaded. /// </param> /// <returns> /// The id of the video that's been created. if null or error returns -1 /// </returns> private RPCResponse<long> CreateVideo(BCVideo video, string filename, byte[] file, BCEncodeType encode_to, bool create_multiple_renditions, bool H264NoProcessing, bool preserve_source_rendition, long maxsize, string file_checksum) { // Generate post objects Dictionary<string, object> postParams = new Dictionary<string, object>(); //add video to the post params RPCRequest rpc = new RPCRequest(); rpc.method = "create_video"; rpc.parameters = "\"video\": " + video.ToCreateJSON() + ", \"token\": \"" + Account.WriteToken.Value + "\""; if (maxsize > -1) { rpc.parameters += ", \"maxsize\": " + maxsize.ToString(); } if (file_checksum != null) { rpc.parameters += ", \"file_checksum\": \"" + file_checksum + "\""; } rpc.parameters += ", \"filename\": \"" + filename + "\""; if (!encode_to.Equals(BCEncodeType.UNDEFINED)) { rpc.parameters += ", \"encode_to\": " + encode_to.ToString(); } rpc.parameters += ", \"create_multiple_renditions\": " + create_multiple_renditions.ToString().ToLower(); rpc.parameters += ", \"H264NoProcessing\": " + H264NoProcessing.ToString().ToLower(); rpc.parameters += ", \"preserve_source_rendition\": " + preserve_source_rendition.ToString().ToLower(); postParams.Add("json", rpc.ToJSON()); //add the file to the post postParams.Add("file", new FileParameter(file, filename)); //Get the JSon reader returned from the APIRequest RPCResponse rpcr = BCAPIRequest.ExecuteWrite(postParams, this.Account); RPCResponse<long> rpcr2 = new RPCResponse<long>(); rpcr2.error = rpcr.error; rpcr2.id = rpcr.id; if (!string.IsNullOrEmpty(rpcr.result)) { rpcr2.result = long.Parse(rpcr.result); } else { rpcr2.result = -1; } return rpcr2; }
/// <summary> /// Call this function in an HTTP POST request to determine the status of an upload. /// </summary> /// <param name="video_id"> /// The id of the video whose status you'd like to get. /// </param> /// <param name="reference_id"> /// The publisher-assigned reference id of the video whose status you'd like to get. /// </param> /// <returns> /// an UploadStatusEnum that specifies the current state of the upload. /// </returns> private RPCResponse<UploadStatusEnum> GetUploadStatus(long video_id, string reference_id) { // Generate post objects Dictionary<string, object> postParams = new Dictionary<string, object>(); //add video to the post params RPCRequest rpc = new RPCRequest(); rpc.method = "get_upload_status"; if (video_id > -1) { rpc.parameters = "\"video_id\": " + video_id.ToString(); } else if (reference_id != null) { rpc.parameters = "\"reference_id\": " + video_id.ToString(); } rpc.parameters += " ,\"token\": \"" + Account.WriteToken.Value + "\""; postParams.Add("json", rpc.ToJSON()); //Get the JSon reader returned from the APIRequest RPCResponse rpcr = BCAPIRequest.ExecuteWrite(postParams, Account); RPCResponse<UploadStatusEnum> rpcr2 = new RPCResponse<UploadStatusEnum>(); rpcr2.error = rpcr.error; rpcr2.id = rpcr.id; switch (rpcr.result) { case "COMPLETE": rpcr2.result = UploadStatusEnum.COMPLETE; break; case "ERROR": rpcr2.result = UploadStatusEnum.ERROR; break; case "PROCESSING": rpcr2.result = UploadStatusEnum.PROCESSING; break; case "UPLOADING": rpcr2.result = UploadStatusEnum.UPLOADING; break; default: rpcr2.result = UploadStatusEnum.UNDEFINED; break; } return rpcr2; }