libavcodec/avs2_parser.c

   1 /*
   2  * AVS2-P2/IEEE1857.4 video parser.
   3  * Copyright (c) 2018  Huiwen Ren <hwrenx@gmail.com>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/avutil.h"
  23 #include "avs2.h"
  24 #include "get_bits.h"
  25 #include "parser.h"
  26
  27 static int avs2_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
  28 {
  29     int pic_found  = pc->frame_start_found;
  30     uint32_t state = pc->state;
  31     int cur = 0;
  32
  33     if (!pic_found) {
  34         for (; cur < buf_size; ++cur) {
  35             state = (state << 8) | buf[cur];
  36             if ((state & 0xFFFFFF00) == 0x100 && AVS2_ISPIC(buf[cur])) {
  37                 cur++;
  38                 pic_found = 1;
  39                 break;
  40             }
  41         }
  42     }
  43
  44     if (pic_found) {
  45         if (!buf_size)
  46             return END_NOT_FOUND;
  47         for (; cur < buf_size; cur++) {
  48             state = (state << 8) | buf[cur];
  49             if ((state & 0xFFFFFF00) == 0x100 && AVS2_ISUNIT(buf[cur])) {
  50                 pc->frame_start_found = 0;
  51                 pc->state = -1;
  52                 return cur - 3;
  53             }
  54         }
  55     }
  56
  57     pc->frame_start_found = pic_found;
  58     pc->state = state;
  59
  60     return END_NOT_FOUND;
  61 }
  62
  63 static void parse_avs2_seq_header(AVCodecParserContext *s, const uint8_t *buf,
  64                                  int buf_size, AVCodecContext *avctx)
  65 {
  66     GetBitContext gb;
  67     int profile, level;
  68     int width, height;
  69     int chroma, sample_precision, encoding_precision = 1;
  70     // sample_precision and encoding_precision is 3 bits
  71     static const uint8_t precision[8] = { 0, 8, 10 };
  72     unsigned aspect_ratio;
  73     unsigned frame_rate_code;
  74     int low_delay;
  75     // update buf_size_min if parse more deeper
  76     const int buf_size_min = 15;
  77
  78     if (buf_size < buf_size_min)
  79         return;
  80
  81     init_get_bits8(&gb, buf, buf_size_min);
  82
  83     s->key_frame = 1;
  84     s->pict_type = AV_PICTURE_TYPE_I;
  85
  86     profile = get_bits(&gb, 8);
  87     level = get_bits(&gb, 8);
  88
  89     // progressive_sequence     u(1)
  90     // field_coded_sequence     u(1)
  91     skip_bits(&gb, 2);
  92
  93     width = get_bits(&gb, 14);
  94     height = get_bits(&gb, 14);
  95
  96     chroma = get_bits(&gb, 2);
  97     sample_precision = get_bits(&gb, 3);
  98     if (profile == AVS2_PROFILE_MAIN10)
  99         encoding_precision = get_bits(&gb, 3);
 100
 101     aspect_ratio = get_bits(&gb, 4);
 102     frame_rate_code = get_bits(&gb, 4);
 103
 104     // bit_rate_lower       u(18)
 105     // marker_bit           f(1)
 106     // bit_rate_upper       u(12)
 107     skip_bits(&gb, 31);
 108
 109     low_delay = get_bits(&gb, 1);
 110
 111     s->width = width;
 112     s->height = height;
 113     s->coded_width = FFALIGN(width, 8);
 114     s->coded_height = FFALIGN(height, 8);
 115     avctx->framerate.num =
 116         ff_avs2_frame_rate_tab[frame_rate_code].num;
 117     avctx->framerate.den =
 118         ff_avs2_frame_rate_tab[frame_rate_code].den;
 119     avctx->has_b_frames = FFMAX(avctx->has_b_frames, !low_delay);
 120
 121     av_log(avctx, AV_LOG_DEBUG,
 122            "AVS2 parse seq HDR: profile %x, level %x, "
 123            "width %d, height %d, "
 124            "chroma %d, sample_precision %d bits, encoding_precision %d bits, "
 125            "aspect_ratio 0x%x, framerate %d/%d, low_delay %d\n",
 126            profile, level,
 127            width, height,
 128            chroma, precision[sample_precision], precision[encoding_precision],
 129            aspect_ratio, avctx->framerate.num, avctx->framerate.den, low_delay);
 130 }
 131
 132 static void parse_avs2_units(AVCodecParserContext *s, const uint8_t *buf,
 133                              int buf_size, AVCodecContext *avctx)
 134 {
 135     if (buf_size < 5)
 136         return;
 137
 138     if (!(buf[0] == 0x0 && buf[1] == 0x0 && buf[2] == 0x1))
 139         return;
 140
 141     switch (buf[3]) {
 142     case AVS2_SEQ_START_CODE:
 143         parse_avs2_seq_header(s, buf + 4, buf_size - 4, avctx);
 144         return;
 145     case AVS2_INTRA_PIC_START_CODE:
 146         s->key_frame = 1;
 147         s->pict_type = AV_PICTURE_TYPE_I;
 148         return;
 149     case AVS2_INTER_PIC_START_CODE:
 150         s->key_frame = 0;
 151         if (buf_size > 9) {
 152             int pic_code_type = buf[8] & 0x3;
 153             if (pic_code_type == 1)
 154                 s->pict_type = AV_PICTURE_TYPE_P;
 155             else if (pic_code_type == 3)
 156                 s->pict_type = AV_PICTURE_TYPE_S;
 157             else
 158                 s->pict_type = AV_PICTURE_TYPE_B;
 159         }
 160         return;
 161     }
 162 }
 163
 164 static int avs2_parse(AVCodecParserContext *s, AVCodecContext *avctx,
 165                       const uint8_t **poutbuf, int *poutbuf_size,
 166                       const uint8_t *buf, int buf_size)
 167 {
 168     ParseContext *pc = s->priv_data;
 169     int next;
 170
 171     if (s->flags & PARSER_FLAG_COMPLETE_FRAMES)  {
 172         next = buf_size;
 173     } else {
 174         next = avs2_find_frame_end(pc, buf, buf_size);
 175         if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
 176             *poutbuf = NULL;
 177             *poutbuf_size = 0;
 178             return buf_size;
 179         }
 180     }
 181
 182     parse_avs2_units(s, buf, buf_size, avctx);
 183
 184     *poutbuf = buf;
 185     *poutbuf_size = buf_size;
 186
 187     return next;
 188 }
 189
 190 const AVCodecParser ff_avs2_parser = {
 191     .codec_ids      = { AV_CODEC_ID_AVS2 },
 192     .priv_data_size = sizeof(ParseContext),
 193     .parser_parse   = avs2_parse,
 194     .parser_close   = ff_parse_close,
 195 };