LCOV - code coverage report
Current view: top level - libavcodec - vp9_superframe_bsf.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 37 103 35.9 %
Date: 2017-12-11 04:34:20 Functions: 3 5 60.0 %

          Line data    Source code
       1             : /*
       2             :  * Vp9 invisible (alt-ref) frame to superframe merge bitstream filter
       3             :  * Copyright (c) 2016 Ronald S. Bultje <rsbultje@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/avassert.h"
      23             : #include "avcodec.h"
      24             : #include "bsf.h"
      25             : #include "get_bits.h"
      26             : 
      27             : #define MAX_CACHE 8
      28             : typedef struct VP9BSFContext {
      29             :     int n_cache;
      30             :     AVPacket *cache[MAX_CACHE];
      31             : } VP9BSFContext;
      32             : 
      33           0 : static void stats(AVPacket * const *in, int n_in,
      34             :                   unsigned *_max, unsigned *_sum)
      35             : {
      36             :     int n;
      37           0 :     unsigned max = 0, sum = 0;
      38             : 
      39           0 :     for (n = 0; n < n_in; n++) {
      40           0 :         unsigned sz = in[n]->size;
      41             : 
      42           0 :         if (sz > max)
      43           0 :             max = sz;
      44           0 :         sum += sz;
      45             :     }
      46             : 
      47           0 :     *_max = max;
      48           0 :     *_sum = sum;
      49           0 : }
      50             : 
      51           0 : static int merge_superframe(AVPacket * const *in, int n_in, AVPacket *out)
      52             : {
      53             :     unsigned max, sum, mag, marker, n, sz;
      54             :     uint8_t *ptr;
      55             :     int res;
      56             : 
      57           0 :     stats(in, n_in, &max, &sum);
      58           0 :     mag = av_log2(max) >> 3;
      59           0 :     marker = 0xC0 + (mag << 3) + (n_in - 1);
      60           0 :     sz = sum + 2 + (mag + 1) * n_in;
      61           0 :     res = av_new_packet(out, sz);
      62           0 :     if (res < 0)
      63           0 :         return res;
      64           0 :     ptr = out->data;
      65           0 :     for (n = 0; n < n_in; n++) {
      66           0 :         memcpy(ptr, in[n]->data, in[n]->size);
      67           0 :         ptr += in[n]->size;
      68             :     }
      69             : 
      70             : #define wloop(mag, wr) \
      71             :     do { \
      72             :         for (n = 0; n < n_in; n++) { \
      73             :             wr; \
      74             :             ptr += mag + 1; \
      75             :         } \
      76             :     } while (0)
      77             : 
      78             :     // write superframe with marker 110[mag:2][nframes:3]
      79           0 :     *ptr++ = marker;
      80           0 :     switch (mag) {
      81           0 :     case 0:
      82           0 :         wloop(mag, *ptr = in[n]->size);
      83           0 :         break;
      84           0 :     case 1:
      85           0 :         wloop(mag, AV_WL16(ptr, in[n]->size));
      86           0 :         break;
      87           0 :     case 2:
      88           0 :         wloop(mag, AV_WL24(ptr, in[n]->size));
      89           0 :         break;
      90           0 :     case 3:
      91           0 :         wloop(mag, AV_WL32(ptr, in[n]->size));
      92           0 :         break;
      93             :     }
      94           0 :     *ptr++ = marker;
      95           0 :     av_assert0(ptr == &out->data[out->size]);
      96             : 
      97           0 :     return 0;
      98             : }
      99             : 
     100          50 : static int vp9_superframe_filter(AVBSFContext *ctx, AVPacket *out)
     101             : {
     102             :     GetBitContext gb;
     103          50 :     VP9BSFContext *s = ctx->priv_data;
     104             :     AVPacket *in;
     105          50 :     int res, invisible, profile, marker, uses_superframe_syntax = 0, n;
     106             : 
     107          50 :     res = ff_bsf_get_packet(ctx, &in);
     108          50 :     if (res < 0)
     109           0 :         return res;
     110             : 
     111          50 :     marker = in->data[in->size - 1];
     112          50 :     if ((marker & 0xe0) == 0xc0) {
     113           3 :         int nbytes = 1 + ((marker >> 3) & 0x3);
     114           3 :         int n_frames = 1 + (marker & 0x7), idx_sz = 2 + n_frames * nbytes;
     115             : 
     116           3 :         uses_superframe_syntax = in->size >= idx_sz && in->data[in->size - idx_sz] == marker;
     117             :     }
     118             : 
     119          50 :     if ((res = init_get_bits8(&gb, in->data, in->size)) < 0)
     120           0 :         goto done;
     121             : 
     122          50 :     get_bits(&gb, 2); // frame marker
     123          50 :     profile  = get_bits1(&gb);
     124          50 :     profile |= get_bits1(&gb) << 1;
     125          50 :     if (profile == 3) profile += get_bits1(&gb);
     126             : 
     127          50 :     if (get_bits1(&gb)) {
     128           0 :         invisible = 0;
     129             :     } else {
     130          50 :         get_bits1(&gb); // keyframe
     131          50 :         invisible = !get_bits1(&gb);
     132             :     }
     133             : 
     134          50 :     if (uses_superframe_syntax && s->n_cache > 0) {
     135           0 :         av_log(ctx, AV_LOG_ERROR,
     136             :                "Mixing of superframe syntax and naked VP9 frames not supported");
     137           0 :         res = AVERROR(ENOSYS);
     138           0 :         goto done;
     139          50 :     } else if ((!invisible || uses_superframe_syntax) && !s->n_cache) {
     140             :         // passthrough
     141          50 :         av_packet_move_ref(out, in);
     142          50 :         goto done;
     143           0 :     } else if (s->n_cache + 1 >= MAX_CACHE) {
     144           0 :         av_log(ctx, AV_LOG_ERROR,
     145             :                "Too many invisible frames");
     146           0 :         res = AVERROR_INVALIDDATA;
     147           0 :         goto done;
     148             :     }
     149             : 
     150           0 :     res = av_packet_ref(s->cache[s->n_cache++], in);
     151           0 :     if (res < 0)
     152           0 :         goto done;
     153             : 
     154           0 :     if (invisible) {
     155           0 :         res = AVERROR(EAGAIN);
     156           0 :         goto done;
     157             :     }
     158           0 :     av_assert0(s->n_cache > 0);
     159             : 
     160             :     // build superframe
     161           0 :     if ((res = merge_superframe(s->cache, s->n_cache, out)) < 0)
     162           0 :         goto done;
     163             : 
     164           0 :     res = av_packet_copy_props(out, s->cache[s->n_cache - 1]);
     165           0 :     if (res < 0)
     166           0 :         goto done;
     167             : 
     168           0 :     for (n = 0; n < s->n_cache; n++)
     169           0 :         av_packet_unref(s->cache[n]);
     170           0 :     s->n_cache = 0;
     171             : 
     172          50 : done:
     173          50 :     if (res < 0)
     174           0 :         av_packet_unref(out);
     175          50 :     av_packet_free(&in);
     176          50 :     return res;
     177             : }
     178             : 
     179           1 : static int vp9_superframe_init(AVBSFContext *ctx)
     180             : {
     181           1 :     VP9BSFContext *s = ctx->priv_data;
     182             :     int n;
     183             : 
     184             :     // alloc cache packets
     185           9 :     for (n = 0; n < MAX_CACHE; n++) {
     186           8 :         s->cache[n] = av_packet_alloc();
     187           8 :         if (!s->cache[n])
     188           0 :             return AVERROR(ENOMEM);
     189             :     }
     190             : 
     191           1 :     return 0;
     192             : }
     193             : 
     194           1 : static void vp9_superframe_close(AVBSFContext *ctx)
     195             : {
     196           1 :     VP9BSFContext *s = ctx->priv_data;
     197             :     int n;
     198             : 
     199             :     // free cached data
     200           9 :     for (n = 0; n < MAX_CACHE; n++)
     201           8 :         av_packet_free(&s->cache[n]);
     202           1 : }
     203             : 
     204             : static const enum AVCodecID codec_ids[] = {
     205             :     AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
     206             : };
     207             : 
     208             : const AVBitStreamFilter ff_vp9_superframe_bsf = {
     209             :     .name           = "vp9_superframe",
     210             :     .priv_data_size = sizeof(VP9BSFContext),
     211             :     .filter         = vp9_superframe_filter,
     212             :     .init           = vp9_superframe_init,
     213             :     .close          = vp9_superframe_close,
     214             :     .codec_ids      = codec_ids,
     215             : };

Generated by: LCOV version 1.13