third_party/libdav1d/src/thread_task.c

/*
 * Copyright © 2018, VideoLAN and dav1d authors
 * Copyright © 2018, Two Orioles, LLC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"

#include "src/thread_task.h"

void *dav1d_frame_task(void *const data) {
    Dav1dFrameContext *const f = data;

    dav1d_set_thread_name("dav1d-frame");
    dav1d_pthread_mutex_lock(&f->frame_thread.td.lock);
    for (;;) {
        while (!f->n_tile_data && !f->frame_thread.die) {
            dav1d_pthread_cond_wait(&f->frame_thread.td.cond,
                              &f->frame_thread.td.lock);
        }
        if (f->frame_thread.die) break;
        dav1d_pthread_mutex_unlock(&f->frame_thread.td.lock);

        const int res = dav1d_decode_frame(f);
        if (res)
            memset(f->frame_thread.cf, 0,
                   (size_t)f->frame_thread.cf_sz * 128 * 128 / 2);

        dav1d_pthread_mutex_lock(&f->frame_thread.td.lock);
        f->n_tile_data = 0;
        dav1d_pthread_cond_signal(&f->frame_thread.td.cond);
    }
    dav1d_pthread_mutex_unlock(&f->frame_thread.td.lock);

    return NULL;
}

void *dav1d_tile_task(void *const data) {
    Dav1dTileContext *const t = data;
    struct FrameTileThreadData *const fttd = t->tile_thread.fttd;
    const Dav1dFrameContext *const f = t->f;
    const int tile_thread_idx = (int) (t - f->tc);
    const uint64_t mask = 1ULL << tile_thread_idx;

    dav1d_set_thread_name("dav1d-tile");

    for (;;) {
        dav1d_pthread_mutex_lock(&fttd->lock);
        fttd->available |= mask;
        int did_signal = 0;
        while (!fttd->tasks_left && !t->tile_thread.die) {
            if (!did_signal) {
                did_signal = 1;
                dav1d_pthread_cond_signal(&fttd->icond);
            }
            dav1d_pthread_cond_wait(&fttd->cond, &fttd->lock);
        }
        if (t->tile_thread.die) {
            dav1d_pthread_cond_signal(&fttd->icond);
            dav1d_pthread_mutex_unlock(&fttd->lock);
            break;
        }
        fttd->available &= ~mask;
        const int task_idx = fttd->num_tasks - fttd->tasks_left--;
        dav1d_pthread_mutex_unlock(&fttd->lock);

        if (f->frame_thread.pass == 1 || f->n_tc >= f->frame_hdr->tiling.cols) {
            // we can (or in fact, if >, we need to) do full tile decoding.
            // loopfilter happens in the main thread
            Dav1dTileState *const ts = t->ts = &f->ts[task_idx];
            for (t->by = ts->tiling.row_start; t->by < ts->tiling.row_end;
                 t->by += f->sb_step)
            {
                int error = dav1d_decode_tile_sbrow(t);
                int progress = error ? TILE_ERROR : 1 + (t->by >> f->sb_shift);

                // signal progress
                dav1d_pthread_mutex_lock(&ts->tile_thread.lock);
                atomic_store(&ts->progress, progress);
                dav1d_pthread_cond_signal(&ts->tile_thread.cond);
                dav1d_pthread_mutex_unlock(&ts->tile_thread.lock);
                if (error) break;
            }
        } else {
            const int sby = f->tile_thread.task_idx_to_sby_and_tile_idx[task_idx][0];
            const int tile_idx = f->tile_thread.task_idx_to_sby_and_tile_idx[task_idx][1];
            Dav1dTileState *const ts = &f->ts[tile_idx];
            int progress;

            // the interleaved decoding can sometimes cause dependency issues
            // if one part of the frame decodes signifcantly faster than others.
            // Ideally, we'd "skip" tile_sbrows where dependencies are missing,
            // and resume them later as dependencies are met. This also would
            // solve the broadcast() below and allow us to use signal(). However,
            // for now, we use linear dependency tracking because it's simpler.
            if ((progress = atomic_load(&ts->progress)) < sby) {
                dav1d_pthread_mutex_lock(&ts->tile_thread.lock);
                while ((progress = atomic_load(&ts->progress)) < sby)
                    dav1d_pthread_cond_wait(&ts->tile_thread.cond,
                                      &ts->tile_thread.lock);
                dav1d_pthread_mutex_unlock(&ts->tile_thread.lock);
            }
            if (progress == TILE_ERROR) continue;

            // we need to interleave sbrow decoding for all tile cols in a
            // tile row, since otherwise subsequent threads will be blocked
            // waiting for the post-filter to complete
            t->ts = ts;
            t->by = sby << f->sb_shift;
            int error = dav1d_decode_tile_sbrow(t);
            progress = error ? TILE_ERROR : 1 + sby;

            // signal progress
            dav1d_pthread_mutex_lock(&ts->tile_thread.lock);
            atomic_store(&ts->progress, progress);
            dav1d_pthread_cond_broadcast(&ts->tile_thread.cond);
            dav1d_pthread_mutex_unlock(&ts->tile_thread.lock);
        }
    }

    return NULL;
}