LCOV - code coverage report
Current view: top level - libavcodec - bitpacked.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 55 0.0 %
Date: 2017-12-17 11:58:42 Functions: 0 4 0.0 %

          Line data    Source code
       1             : /*
       2             :  * Unpack bit-packed streams to formats supported by FFmpeg
       3             :  * Copyright (c) 2017 Savoir-faire Linux, Inc
       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             : /* Development sponsored by CBC/Radio-Canada */
      23             : 
      24             : /**
      25             :  * @file
      26             :  * Bitpacked
      27             :  */
      28             : 
      29             : #include "avcodec.h"
      30             : #include "internal.h"
      31             : #include "get_bits.h"
      32             : #include "libavutil/imgutils.h"
      33             : 
      34             : struct BitpackedContext {
      35             :     int (*decode)(AVCodecContext *avctx, AVFrame *frame,
      36             :                   AVPacket *pkt);
      37             : };
      38             : 
      39             : /* For this format, it's a simple passthrough */
      40           0 : static int bitpacked_decode_uyvy422(AVCodecContext *avctx, AVFrame *frame,
      41             :                                     AVPacket *avpkt)
      42             : {
      43             :     int ret;
      44             : 
      45             :     /* there is no need to copy as the data already match
      46             :      * a known pixel format */
      47           0 :     frame->buf[0] = av_buffer_ref(avpkt->buf);
      48           0 :     ret = av_image_fill_arrays(frame->data, frame->linesize, avpkt->data,
      49             :                                avctx->pix_fmt, avctx->width, avctx->height, 1);
      50           0 :     if (ret < 0) {
      51           0 :         av_buffer_unref(&frame->buf[0]);
      52           0 :         return ret;
      53             :     }
      54             : 
      55           0 :     return 0;
      56             : }
      57             : 
      58           0 : static int bitpacked_decode_yuv422p10(AVCodecContext *avctx, AVFrame *frame,
      59             :                                       AVPacket *avpkt)
      60             : {
      61           0 :     uint64_t frame_size = (uint64_t)avctx->width * (uint64_t)avctx->height * 20;
      62           0 :     uint64_t packet_size = (uint64_t)avpkt->size * 8;
      63             :     GetBitContext bc;
      64             :     uint16_t *y, *u, *v;
      65             :     int ret, i, j;
      66             : 
      67           0 :     ret = ff_get_buffer(avctx, frame, 0);
      68           0 :     if (ret < 0)
      69           0 :         return ret;
      70             : 
      71           0 :     if (frame_size > packet_size)
      72           0 :         return AVERROR_INVALIDDATA;
      73             : 
      74           0 :     if (avctx->width % 2)
      75           0 :         return AVERROR_PATCHWELCOME;
      76             : 
      77           0 :     ret = init_get_bits(&bc, avpkt->data, avctx->width * avctx->height * 20);
      78           0 :     if (ret)
      79           0 :         return ret;
      80             : 
      81           0 :     for (i = 0; i < avctx->height; i++) {
      82           0 :         y = (uint16_t*)(frame->data[0] + i * frame->linesize[0]);
      83           0 :         u = (uint16_t*)(frame->data[1] + i * frame->linesize[1]);
      84           0 :         v = (uint16_t*)(frame->data[2] + i * frame->linesize[2]);
      85             : 
      86           0 :         for (j = 0; j < avctx->width; j += 2) {
      87           0 :             *u++ = get_bits(&bc, 10);
      88           0 :             *y++ = get_bits(&bc, 10);
      89           0 :             *v++ = get_bits(&bc, 10);
      90           0 :             *y++ = get_bits(&bc, 10);
      91             :         }
      92             :     }
      93             : 
      94           0 :     return 0;
      95             : }
      96             : 
      97           0 : static av_cold int bitpacked_init_decoder(AVCodecContext *avctx)
      98             : {
      99           0 :     struct BitpackedContext *bc = avctx->priv_data;
     100             : 
     101           0 :     if (!avctx->codec_tag || !avctx->width || !avctx->height)
     102           0 :         return AVERROR_INVALIDDATA;
     103             : 
     104           0 :     if (avctx->codec_tag == MKTAG('U', 'Y', 'V', 'Y')) {
     105           0 :         if (avctx->bits_per_coded_sample == 16 &&
     106           0 :             avctx->pix_fmt == AV_PIX_FMT_UYVY422)
     107           0 :             bc->decode = bitpacked_decode_uyvy422;
     108           0 :         else if (avctx->bits_per_coded_sample == 20 &&
     109           0 :                  avctx->pix_fmt == AV_PIX_FMT_YUV422P10)
     110           0 :             bc->decode = bitpacked_decode_yuv422p10;
     111             :         else
     112           0 :             return AVERROR_INVALIDDATA;
     113             :     } else {
     114           0 :         return AVERROR_INVALIDDATA;
     115             :     }
     116             : 
     117           0 :     return 0;
     118             : }
     119             : 
     120           0 : static int bitpacked_decode(AVCodecContext *avctx, void *data, int *got_frame,
     121             :                             AVPacket *avpkt)
     122             : {
     123           0 :     struct BitpackedContext *bc = avctx->priv_data;
     124           0 :     int buf_size = avpkt->size;
     125           0 :     AVFrame *frame = data;
     126             :     int res;
     127             : 
     128           0 :     frame->pict_type = AV_PICTURE_TYPE_I;
     129           0 :     frame->key_frame = 1;
     130             : 
     131           0 :     res = bc->decode(avctx, frame, avpkt);
     132           0 :     if (res)
     133           0 :         return res;
     134             : 
     135           0 :     *got_frame = 1;
     136           0 :     return buf_size;
     137             : 
     138             : }
     139             : 
     140             : AVCodec ff_bitpacked_decoder = {
     141             :     .name   = "bitpacked",
     142             :     .long_name = NULL_IF_CONFIG_SMALL("Bitpacked"),
     143             :     .type = AVMEDIA_TYPE_VIDEO,
     144             :     .id = AV_CODEC_ID_BITPACKED,
     145             :     .priv_data_size        = sizeof(struct BitpackedContext),
     146             :     .init = bitpacked_init_decoder,
     147             :     .decode = bitpacked_decode,
     148             :     .capabilities = AV_CODEC_CAP_EXPERIMENTAL,
     149             : };

Generated by: LCOV version 1.13