git.sesse.net Git - ffmpeg/blob - libavcodec/libuavs3d.c

   1 /*
   2  * RAW AVS3-P2/IEEE1857.10 video demuxer
   3  * Copyright (c) 2020 Zhenyu Wang <wangzhenyu@pkusz.edu.cn>
   4  *                    Bingjie Han <hanbj@pkusz.edu.cn>
   5  *                    Huiwen Ren  <hwrenx@gmail.com>
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include "libavutil/avassert.h"
  25 #include "libavutil/avutil.h"
  26 #include "libavutil/common.h"
  27 #include "libavutil/imgutils.h"
  28 #include "libavutil/intreadwrite.h"
  29 #include "libavutil/opt.h"
  30 #include "avcodec.h"
  31 #include "avs3.h"
  32 #include "internal.h"
  33 #include "uavs3d.h"
  34
  35 typedef struct uavs3d_context {
  36     AVCodecContext  *avctx;
  37     void            *dec_handle;
  38     int              frame_threads;
  39     int              got_seqhdr;
  40     uavs3d_io_frm_t  dec_frame;
  41 } uavs3d_context;
  42
  43 #define UAVS3D_CHECK_START_CODE(data_ptr, PIC_START_CODE) \
  44         (AV_RL32(data_ptr) != (PIC_START_CODE << 24) + AVS3_NAL_START_CODE)
  45 static int uavs3d_find_next_start_code(const unsigned char *bs_data, int bs_len, int *left)
  46 {
  47     const unsigned char *data_ptr = bs_data + 4;
  48     int count = bs_len - 4;
  49
  50     while (count >= 4 &&
  51            UAVS3D_CHECK_START_CODE(data_ptr, AVS3_INTER_PIC_START_CODE) &&
  52            UAVS3D_CHECK_START_CODE(data_ptr, AVS3_INTRA_PIC_START_CODE) &&
  53            UAVS3D_CHECK_START_CODE(data_ptr, AVS3_SEQ_START_CODE) &&
  54            UAVS3D_CHECK_START_CODE(data_ptr, AVS3_FIRST_SLICE_START_CODE) &&
  55            UAVS3D_CHECK_START_CODE(data_ptr, AVS3_SEQ_END_CODE)) {
  56         data_ptr++;
  57         count--;
  58     }
  59
  60     if (count >= 4) {
  61         *left = count;
  62         return 1;
  63     }
  64
  65     return 0;
  66 }
  67
  68 static void uavs3d_output_callback(uavs3d_io_frm_t *dec_frame) {
  69     uavs3d_io_frm_t frm_out;
  70     AVFrame *frm = (AVFrame *)dec_frame->priv;
  71     int i;
  72
  73     if (!frm || !frm->data[0]) {
  74         dec_frame->got_pic = 0;
  75         av_log(NULL, AV_LOG_ERROR, "Invalid AVFrame in uavs3d output.\n");
  76         return;
  77     }
  78
  79     frm->pts       = dec_frame->pts;
  80     frm->pkt_dts   = dec_frame->dts;
  81     frm->pkt_pos   = dec_frame->pkt_pos;
  82     frm->pkt_size  = dec_frame->pkt_size;
  83     frm->coded_picture_number   = dec_frame->dtr;
  84     frm->display_picture_number = dec_frame->ptr;
  85
  86     if (dec_frame->type < 0 || dec_frame->type >= 4) {
  87         av_log(NULL, AV_LOG_WARNING, "Error frame type in uavs3d: %d.\n", dec_frame->type);
  88     }
  89
  90     frm->pict_type = ff_avs3_image_type[dec_frame->type];
  91     frm->key_frame = (frm->pict_type == AV_PICTURE_TYPE_I);
  92
  93     for (i = 0; i < 3; i++) {
  94         frm_out.width [i] = dec_frame->width[i];
  95         frm_out.height[i] = dec_frame->height[i];
  96         frm_out.stride[i] = frm->linesize[i];
  97         frm_out.buffer[i] = frm->data[i];
  98     }
  99
 100     uavs3d_img_cpy_cvt(&frm_out, dec_frame, dec_frame->bit_depth);
 101 }
 102
 103 static av_cold int libuavs3d_init(AVCodecContext *avctx)
 104 {
 105     uavs3d_context *h = avctx->priv_data;
 106     uavs3d_cfg_t cdsc;
 107
 108     cdsc.frm_threads = avctx->thread_count > 0 ? avctx->thread_count : av_cpu_count();
 109     cdsc.check_md5 = 0;
 110     h->dec_handle = uavs3d_create(&cdsc, uavs3d_output_callback, NULL);
 111     h->got_seqhdr = 0;
 112
 113     if (!h->dec_handle) {
 114         return AVERROR(ENOMEM);
 115     }
 116
 117     return 0;
 118 }
 119
 120 static av_cold int libuavs3d_end(AVCodecContext *avctx)
 121 {
 122     uavs3d_context *h = avctx->priv_data;
 123
 124     if (h->dec_handle) {
 125         uavs3d_flush(h->dec_handle, NULL);
 126         uavs3d_delete(h->dec_handle);
 127         h->dec_handle = NULL;
 128     }
 129     h->got_seqhdr = 0;
 130
 131     return 0;
 132 }
 133
 134 static void libuavs3d_flush(AVCodecContext * avctx)
 135 {
 136     uavs3d_context *h = avctx->priv_data;
 137
 138     if (h->dec_handle) {
 139         uavs3d_reset(h->dec_handle);
 140     }
 141 }
 142
 143 #define UAVS3D_CHECK_INVALID_RANGE(v, l, r) ((v)<(l)||(v)>(r))
 144 static int libuavs3d_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
 145 {
 146     uavs3d_context *h = avctx->priv_data;
 147     const uint8_t *buf = avpkt->data;
 148     int buf_size = avpkt->size;
 149     const uint8_t *buf_end;
 150     const uint8_t *buf_ptr;
 151     AVFrame *frm = data;
 152     int left_bytes;
 153     int ret, finish = 0;
 154
 155     *got_frame = 0;
 156     frm->pts = -1;
 157     frm->pict_type = AV_PICTURE_TYPE_NONE;
 158
 159     if (!buf_size) {
 160         if (h->got_seqhdr) {
 161             if (!frm->data[0] && (ret = ff_get_buffer(avctx, frm, 0)) < 0) {
 162                 return ret;
 163             }
 164             h->dec_frame.priv = data;   // AVFrame
 165         }
 166         do {
 167             ret = uavs3d_flush(h->dec_handle, &h->dec_frame);
 168         } while (ret > 0 && !h->dec_frame.got_pic);
 169     } else {
 170         uavs3d_io_frm_t *frm_dec = &h->dec_frame;
 171
 172         buf_ptr = buf;
 173         buf_end = buf + buf_size;
 174         frm_dec->pkt_pos  = avpkt->pos;
 175         frm_dec->pkt_size = avpkt->size;
 176
 177         while (!finish) {
 178             int bs_len;
 179
 180             if (h->got_seqhdr) {
 181                 if (!frm->data[0] && (ret = ff_get_buffer(avctx, frm, 0)) < 0) {
 182                     return ret;
 183                 }
 184                 h->dec_frame.priv = data;   // AVFrame
 185             }
 186
 187             if (uavs3d_find_next_start_code(buf_ptr, buf_end - buf_ptr, &left_bytes)) {
 188                 bs_len = buf_end - buf_ptr - left_bytes;
 189             } else {
 190                 bs_len = buf_end - buf_ptr;
 191                 finish = 1;
 192             }
 193             frm_dec->bs = (unsigned char *)buf_ptr;
 194             frm_dec->bs_len = bs_len;
 195             frm_dec->pts = avpkt->pts;
 196             frm_dec->dts = avpkt->dts;
 197             uavs3d_decode(h->dec_handle, frm_dec);
 198             buf_ptr += bs_len;
 199
 200             if (frm_dec->nal_type == NAL_SEQ_HEADER) {
 201                 struct uavs3d_com_seqh_t *seqh = frm_dec->seqhdr;
 202                 if (UAVS3D_CHECK_INVALID_RANGE(seqh->frame_rate_code, 0, 15)) {
 203                     av_log(avctx, AV_LOG_ERROR, "Invalid frame rate code: %d.\n", seqh->frame_rate_code);
 204                     seqh->frame_rate_code = 3; // default 25 fps
 205                 } else {
 206                     avctx->framerate.num = ff_avs3_frame_rate_tab[seqh->frame_rate_code].num;
 207                     avctx->framerate.den = ff_avs3_frame_rate_tab[seqh->frame_rate_code].den;
 208                 }
 209                 avctx->has_b_frames  = !seqh->low_delay;
 210                 avctx->pix_fmt = seqh->bit_depth_internal == 8 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUV420P10LE;
 211                 ff_set_dimensions(avctx, seqh->horizontal_size, seqh->vertical_size);
 212                 h->got_seqhdr = 1;
 213
 214                 if (seqh->colour_description) {
 215                     if (UAVS3D_CHECK_INVALID_RANGE(seqh->colour_primaries, 0, 9) ||
 216                         UAVS3D_CHECK_INVALID_RANGE(seqh->transfer_characteristics, 0, 14) ||
 217                         UAVS3D_CHECK_INVALID_RANGE(seqh->matrix_coefficients, 0, 11)) {
 218                         av_log(avctx, AV_LOG_ERROR,
 219                                "Invalid colour description: primaries: %d"
 220                                "transfer characteristics: %d"
 221                                "matrix coefficients: %d.\n",
 222                                seqh->colour_primaries,
 223                                seqh->transfer_characteristics,
 224                                seqh->matrix_coefficients);
 225                     } else {
 226                         avctx->color_primaries = ff_avs3_color_primaries_tab[seqh->colour_primaries];
 227                         avctx->color_trc       = ff_avs3_color_transfer_tab [seqh->transfer_characteristics];
 228                         avctx->colorspace      = ff_avs3_color_matrix_tab   [seqh->matrix_coefficients];
 229                     }
 230                 }
 231             }
 232             if (frm_dec->got_pic) {
 233                 break;
 234             }
 235         }
 236     }
 237
 238     *got_frame = h->dec_frame.got_pic;
 239
 240     if (!(*got_frame)) {
 241         av_frame_unref(frm);
 242     }
 243
 244     return buf_ptr - buf;
 245 }
 246
 247 AVCodec ff_libuavs3d_decoder = {
 248     .name           = "libuavs3d",
 249     .long_name      = NULL_IF_CONFIG_SMALL("libuavs3d AVS3-P2/IEEE1857.10"),
 250     .type           = AVMEDIA_TYPE_VIDEO,
 251     .id             = AV_CODEC_ID_AVS3,
 252     .priv_data_size = sizeof(uavs3d_context),
 253     .init           = libuavs3d_init,
 254     .close          = libuavs3d_end,
 255     .decode         = libuavs3d_decode_frame,
 256     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS,
 257     .caps_internal  = FF_CODEC_CAP_AUTO_THREADS,
 258     .flush          = libuavs3d_flush,
 259     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
 260                                                      AV_PIX_FMT_YUV420P10LE,
 261                                                      AV_PIX_FMT_NONE },
 262     .wrapper_name   = "libuavs3d",
 263 };