fftools/ffmpeg_sched: make sure to always run task cleanup

Even in cases where sch_start() failed. This ensures all links are properly closed and no tasks are left hanging. Fixes #10916.

Anton Khirnov committed 2 years ago

Commit 24b9f291 parent af817881 file · +44 −24Browse files

Unified · Split

fftools/ffmpeg_sched.c+44−24

     int                 task_exited;
 } SchFilterGraph;
+enum SchedulerState {
+    SCH_STATE_UNINIT,
+    SCH_STATE_STARTED,
+    SCH_STATE_STOPPED,
+};
 struct Scheduler {
     const AVClass      *class;
     char               *sdp_filename;
     int                 sdp_auto;
-    int                 transcode_started;
+    enum SchedulerState state;
     atomic_int          terminate;
     atomic_int          task_failed;
     // this may be called during initialization - do not start
     // threads before sch_start() is called
-    if (++mux->nb_streams_ready == mux->nb_streams && sch->transcode_started)
+    if (++mux->nb_streams_ready == mux->nb_streams &&
+        sch->state >= SCH_STATE_STARTED)
         ret = mux_init(sch, mux);
     pthread_mutex_unlock(&sch->mux_ready_lock);
     if (ret < 0)
         return ret;
-    sch->transcode_started = 1;
+    av_assert0(sch->state == SCH_STATE_UNINIT);
+    sch->state = SCH_STATE_STARTED;
     for (unsigned i = 0; i < sch->nb_mux; i++) {
         SchMux *mux = &sch->mux[i];
         if (mux->nb_streams_ready == mux->nb_streams) {
             ret = mux_init(sch, mux);
             if (ret < 0)
-                return ret;
+                goto fail;
         }
     }
         ret = task_start(&enc->task);
         if (ret < 0)
-            return ret;
+            goto fail;
     }
     for (unsigned i = 0; i < sch->nb_filters; i++) {
         ret = task_start(&fg->task);
         if (ret < 0)
-            return ret;
+            goto fail;
     }
     for (unsigned i = 0; i < sch->nb_dec; i++) {
         ret = task_start(&dec->task);
         if (ret < 0)
-            return ret;
+            goto fail;
     }
     for (unsigned i = 0; i < sch->nb_demux; i++) {
         ret = task_start(&d->task);
         if (ret < 0)
-            return ret;
+            goto fail;
     }
     pthread_mutex_lock(&sch->schedule_lock);
     pthread_mutex_unlock(&sch->schedule_lock);
     return 0;
+fail:
+    sch_stop(sch, NULL);
+    return ret;
 }
 int sch_wait(Scheduler *sch, uint64_t timeout_us, int64_t *transcode_ts)
     return send_to_filter(sch, fg, fg->nb_inputs, frame);
 }
+static int task_cleanup(Scheduler *sch, SchedulerNode node)
+{
+    switch (node.type) {
+    case SCH_NODE_TYPE_DEMUX:       return demux_done (sch, node.idx);
+    case SCH_NODE_TYPE_MUX:         return mux_done   (sch, node.idx);
+    case SCH_NODE_TYPE_DEC:         return dec_done   (sch, node.idx);
+    case SCH_NODE_TYPE_ENC:         return enc_done   (sch, node.idx);
+    case SCH_NODE_TYPE_FILTER_IN:   return filter_done(sch, node.idx);
+    default: av_assert0(0);
+    }
+}
 static void *task_wrapper(void *arg)
 {
     SchTask  *task = arg;
         av_log(task->func_arg, AV_LOG_ERROR,
                "Task finished with error code: %d (%s)\n", ret, av_err2str(ret));
-    switch (task->node.type) {
+    err = task_cleanup(sch, task->node);
-    case SCH_NODE_TYPE_DEMUX:       err = demux_done (sch, task->node.idx); break;
-    case SCH_NODE_TYPE_MUX:         err = mux_done   (sch, task->node.idx); break;
-    case SCH_NODE_TYPE_DEC:         err = dec_done   (sch, task->node.idx); break;
-    case SCH_NODE_TYPE_ENC:         err = enc_done   (sch, task->node.idx); break;
-    case SCH_NODE_TYPE_FILTER_IN:   err = filter_done(sch, task->node.idx); break;
-    default: av_assert0(0);
-    }
     ret = err_merge(ret, err);
     // EOF is considered normal termination
     return (void*)(intptr_t)ret;
 }
-static int task_stop(SchTask *task)
+static int task_stop(Scheduler *sch, SchTask *task)
 {
     int ret;
     void *thread_ret;
     if (!task->thread_running)
-        return 0;
+        return task_cleanup(sch, task->node);
     ret = pthread_join(task->thread, &thread_ret);
     av_assert0(ret == 0);
 {
     int ret = 0, err;
+    if (sch->state != SCH_STATE_STARTED)
+        return 0;
     atomic_store(&sch->terminate, 1);
     for (unsigned type = 0; type < 2; type++)
     for (unsigned i = 0; i < sch->nb_demux; i++) {
         SchDemux *d = &sch->demux[i];
-        err = task_stop(&d->task);
+        err = task_stop(sch, &d->task);
         ret = err_merge(ret, err);
     }
     for (unsigned i = 0; i < sch->nb_dec; i++) {
         SchDec *dec = &sch->dec[i];
-        err = task_stop(&dec->task);
+        err = task_stop(sch, &dec->task);
         ret = err_merge(ret, err);
     }
     for (unsigned i = 0; i < sch->nb_filters; i++) {
         SchFilterGraph *fg = &sch->filters[i];
-        err = task_stop(&fg->task);
+        err = task_stop(sch, &fg->task);
         ret = err_merge(ret, err);
     }
     for (unsigned i = 0; i < sch->nb_enc; i++) {
         SchEnc *enc = &sch->enc[i];
-        err = task_stop(&enc->task);
+        err = task_stop(sch, &enc->task);
         ret = err_merge(ret, err);
     }
     for (unsigned i = 0; i < sch->nb_mux; i++) {
         SchMux *mux = &sch->mux[i];
-        err = task_stop(&mux->task);
+        err = task_stop(sch, &mux->task);
         ret = err_merge(ret, err);
     }
     if (finish_ts)
         *finish_ts = trailing_dts(sch, 1);
+    sch->state = SCH_STATE_STOPPED;
     return ret;
 }

fftools/ffmpeg_sched: make sure to always run task cleanup

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code