Auto change quality

app.js

@@ -26,6 +26,7 @@ const ngrok = require('ngrok');
 const commandExists = require('command-exists');
 const errorHandler = require('errorhandler');
 const jsHelpers = require('./lib/helpers/js-helpers');
+const { UI } = require('bull-board');
 
 /** FOR FINDING ERRANT LOGS **/
 if(process.env.SHOW_LOG_LOCATION == 'true' || 2 == 1){
@@ -161,6 +162,12 @@ if(cluster.isMaster){
       path: '/hiddenStatus'
     }));
 
+    // TODO: put this behind auth
+    /** bull-board queue monitor **/
+    if(process.env.NODE_ENV === 'development'){
+      app.use('/admin/queues', UI);
+    }
+
     app.use(compression());
     app.use(sass({
       src: path.join(__dirname, 'public'),

controllers/backend/uploading.js

@@ -31,6 +31,7 @@ const { b2, bucket, hostUrl } = require('../../lib/uploading/backblaze');
 const ffmpegHelper = require('../../lib/uploading/ffmpeg');
 const {
   markUploadAsComplete,
+  markConvertAsComplete,
   updateUsersUnreadSubscriptions,
   runTimeoutFunction,
   userCanUploadContentOfThisRating
@@ -40,6 +41,8 @@ const backblaze = require('../../lib/uploading/backblaze');
 // console.log(`SAVE AND SERVE FILES DIRECTORY: ${saveAndServeFilesDirectory}`);
 
 var resumable = require('../../lib/uploading/resumable.js')(__dirname +  '/upload');
+var Queue = require('bull');
+const { setQueues } = require('bull-board');
 
 const moderationUpdatesToDiscord = process.env.MODERATION_UPDATES_TO_DISCORD == 'true';
 
@@ -537,7 +540,6 @@ exports.postFileUpload = async(req, res) => {
             }
 
             upload.fileType = 'video';
-
             upload = await upload.save();
           }
 
@@ -557,17 +559,148 @@ exports.postFileUpload = async(req, res) => {
 
           uploadLogger.info('Upload marked as complete', logObject);
 
-          updateUsersUnreadSubscriptions(user);
-
-          uploadLogger.info('Updated subscribed users subscriptions', logObject);
-
           if(!responseSent){
             responseSent = true;
             aboutToProcess(res, channelUrl, uniqueTag);
           }
+
+          var videoQualityQueue = new Queue('Video Quality is going to convert');
+          setQueues([videoQualityQueue]);
+
+          videoQualityQueue.process(async function(job, done){
+
+            Upload.update({'videoQualities._id': job.data.videoQualitiesId}, {'$set': {
+              'videoQualities.$.status': 'converting',
+              'videoQualities.$.fileSizeInMb': 2
+            }}, function(err, result){
+
+              if(err){
+                res.send(err);
+              }
+              else {
+                res.send(result);
+              }
+
+            });
+
+            job.progress(5);
+
+            await ffmpegHelper.convertVideo({
+              uploadedPath: job.data.uploadedPath,
+              title: job.data.title,
+              bitrate: job.data.bitrate,
+              savePath: job.data.savePath,
+              uniqueTag: job.data.uniqueTag,
+              quality: job.data.quality
+            });
+
+            job.progress(42); // TODO: set progress based on convert percentage
+
+            Upload.update({'videoQualities._id': job.data.videoQualitiesId}, {'$set': {
+              'videoQualities.$.status': 'complete',
+              'videoQualities.$.fileSizeInMb': 3
+            }}, function(err, result){
+
+              if(err){
+                res.send(err);
+              }
+              // else {
+              //   res.send(result);
+              // }
+
+            });
+
+            // Update if all qualities are converted
+            // TODO: needs some cleanup
+            // db.uploads.findOne({}).videoQualities.every(arr=> arr.status == 'complete');
+            await Upload.findOne({uniqueTag : job.data.uploadUniqueTag })
+              .select('videoQualities')
+              .exec(async function(err, txs){
+                if(txs.videoQualities.every(arr=> arr.status === 'complete')){
+                  await markConvertAsComplete(uniqueTag, channelUrl, user);
+                  uploadLogger.info('Quality all qualities are converted', logObject);
+                  updateUsersUnreadSubscriptions(user);
+                  uploadLogger.info('Updated subscribed users subscriptions', logObject);
+                }
+
+              });
+
+            job.progress(100);
+            done();
+
+          });
+          /*
+          all values in Kbps (kilobits per seconds)
+          2160p (4k) -> 13000
+          1440p 6000
+          1080p 3000
+          720p 2250
+          480p 500
+          360p 400
+          240p 300
+          144p 80
+
+          0-80 144p
+          81-299 360p
+          */
+          // TODO: put qualities somewhere else
+          const qualities = [
+            { name: '256 x 144p', quality: 144, bitrate: 80 },
+            { name: '426 x 240p', quality: 240, bitrate: 300 },
+            { name: '640 x 360p', quality: 360, bitrate: 400 },
+            { name: '854 x 480p', quality: 480, bitrate: 500 },
+            { name: '1280 x 720p', quality: 720, bitrate: 2250 }
+          ];
+          // TODO: Do quality stuff
+          // TODO: loop quality stuff
+          // video will be available in original quality while this is happening in the background
+          // TODO: make a quality conversion counter/progress bar
+          for(var i = 0; i < qualities.length; i = i + 1){
+            if(bitrate >= qualities[i].bitrate){
+              // qualitySavePath = `${channelUrlFolder}/${uniqueTag}-${qualities[i].quality}.mp4`;
+
+              let qualityExists = upload.videoQualities.find(o => o.quality === qualities[i].quality);
+              if(!qualityExists){
+
+                upload.videoQualities.push({
+                  quality: qualities[i].quality,
+                  bitrate: qualities[i].bitrate,
+                  fileSizeInMb: 1,
+                  status: 'pending' // TODO: use enum here not string
+                });
+              }
+
+            }
+          }
+
+          await upload.save();
+
+          for(var i = 0; i < upload.videoQualities.length; i = i + 1){
+            if(bitrate >= upload.videoQualities[i].bitrate){
+              if(upload.videoQualities[i].status != 'complete'){
+                // TODO: this is kind of ugly lmao
+                qualitySavePath = `${channelUrlFolder}/${uniqueTag}-${upload.videoQualities[i].quality}.mp4`;
+
+                videoQualityQueue.add({
+                  uploadId: upload._id,
+                  videoQualitiesId: upload.videoQualities[i]._id,
+                  uploadedPath: fileInDirectory,
+                  title: title,
+                  bitrate: upload.videoQualities[i].bitrate,
+                  savePath: qualitySavePath,
+                  uploadUniqueTag: uniqueTag,
+                  uniqueTag: uniqueTag + '-' + upload.videoQualities[i].quality,
+                  quality: upload.videoQualities[i].quality
+                });
+              }
+
+              await upload.save();
+            }
+
+          }
+
         });
 
-        // });
       }
     });
   } catch(err){

lib/uploading/ffmpeg.js

@@ -79,7 +79,7 @@ function setRedisClient({ currentSeconds, uniqueTag, progress, force }){
 
 // setRedisClient();
 
-function convertVideo({ uploadedPath, title, bitrate, savePath, uniqueTag }){
+function convertVideo({ uploadedPath, title, quality, bitrate, savePath, uniqueTag }){
   return new Promise(function(resolve, reject) {
 
     let command;
@@ -88,9 +88,12 @@ function convertVideo({ uploadedPath, title, bitrate, savePath, uniqueTag }){
       command = ffmpeg(uploadedPath).videoCodec('libx264').audioCodec('aac').format('mp4')
         .outputOptions([ '-preset faster', '-b:v 2500k' ]);
 
-    } else {
+    } else if(!quality){
       command = ffmpeg(uploadedPath).videoCodec('libx264').audioCodec('aac').format('mp4')
 
+    } else{
+      command = ffmpeg(uploadedPath).videoCodec('libx264').audioCodec('aac').format('mp4')
+          .outputOptions([ '-preset faster', '-b:v ' + bitrate + 'k', '-vf scale=-2:' + quality ]);
     }
 
     let secondCounter = 0;

lib/uploading/helpers.js

@@ -18,6 +18,21 @@ async function markUploadAsComplete(uniqueTag, channelUrl, user, res){
   return 'success'
 }
 
+async function markConvertAsComplete(uniqueTag, channelUrl, user, res){
+  // upload = await Upload.findOne({ uniqueTag });
+  // upload.status = 'completed';
+
+  // upload.processingCompletedAt = new Date();
+
+  // await upload.save();
+  console.log("quality converted")
+
+  // user.uploads.push(upload._id);
+  // await user.save();
+
+  return 'success'
+}
+
 async function updateUsersUnreadSubscriptions(user){
   const subscriptions = await Subscription.find({ subscribedToUser: user._id, active: true });
 
@@ -84,6 +99,7 @@ const bytesToGb = (bytes, decimalPlaces = 4) => {
 
 module.exports = {
   markUploadAsComplete,
+  markConvertAsComplete,
   updateUsersUnreadSubscriptions,
   runTimeoutFunction,
   userCanUploadContentOfThisRating,

models/Upload.js

@@ -39,6 +39,15 @@ const uploadSchema = new mongoose.Schema({
   // pretty sure this is in bytes
   fileSize: Number,  // TODO: should support highQualityFileSize as well for compressions
 
+  videoQualities: [
+    {
+      quality: 'String',
+      fileSizeInMb: Number,
+      bitrate: Number,
+      status: {type: String, enum: ['pending', 'converting', 'complete'], default: 'pending'}
+    }
+  ],
+
   bitrateInKbps: Number,
   dimensions: {
     height: String,