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

   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                   const AVPacket *pkt);
  37 };
  38
  39 /* For this format, it's a simple passthrough */
  40 static int bitpacked_decode_uyvy422(AVCodecContext *avctx, AVFrame *frame,
  41                                     const 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     frame->buf[0] = av_buffer_ref(avpkt->buf);
  48     ret = av_image_fill_arrays(frame->data, frame->linesize, avpkt->data,
  49                                avctx->pix_fmt, avctx->width, avctx->height, 1);
  50     if (ret < 0) {
  51         av_buffer_unref(&frame->buf[0]);
  52         return ret;
  53     }
  54
  55     return 0;
  56 }
  57
  58 static int bitpacked_decode_yuv422p10(AVCodecContext *avctx, AVFrame *frame,
  59                                       const AVPacket *avpkt)
  60 {
  61     uint64_t frame_size = (uint64_t)avctx->width * (uint64_t)avctx->height * 20;
  62     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     ret = ff_get_buffer(avctx, frame, 0);
  68     if (ret < 0)
  69         return ret;
  70
  71     if (frame_size > packet_size)
  72         return AVERROR_INVALIDDATA;
  73
  74     if (avctx->width % 2)
  75         return AVERROR_PATCHWELCOME;
  76
  77     ret = init_get_bits(&bc, avpkt->data, avctx->width * avctx->height * 20);
  78     if (ret)
  79         return ret;
  80
  81     for (i = 0; i < avctx->height; i++) {
  82         y = (uint16_t*)(frame->data[0] + i * frame->linesize[0]);
  83         u = (uint16_t*)(frame->data[1] + i * frame->linesize[1]);
  84         v = (uint16_t*)(frame->data[2] + i * frame->linesize[2]);
  85
  86         for (j = 0; j < avctx->width; j += 2) {
  87             *u++ = get_bits(&bc, 10);
  88             *y++ = get_bits(&bc, 10);
  89             *v++ = get_bits(&bc, 10);
  90             *y++ = get_bits(&bc, 10);
  91         }
  92     }
  93
  94     return 0;
  95 }
  96
  97 static av_cold int bitpacked_init_decoder(AVCodecContext *avctx)
  98 {
  99     struct BitpackedContext *bc = avctx->priv_data;
 100
 101     if (!avctx->codec_tag || !avctx->width || !avctx->height)
 102         return AVERROR_INVALIDDATA;
 103
 104     if (avctx->codec_tag == MKTAG('U', 'Y', 'V', 'Y')) {
 105         if (avctx->bits_per_coded_sample == 16 &&
 106             avctx->pix_fmt == AV_PIX_FMT_UYVY422)
 107             bc->decode = bitpacked_decode_uyvy422;
 108         else if (avctx->bits_per_coded_sample == 20 &&
 109                  avctx->pix_fmt == AV_PIX_FMT_YUV422P10)
 110             bc->decode = bitpacked_decode_yuv422p10;
 111         else
 112             return AVERROR_INVALIDDATA;
 113     } else {
 114         return AVERROR_INVALIDDATA;
 115     }
 116
 117     return 0;
 118 }
 119
 120 static int bitpacked_decode(AVCodecContext *avctx, void *data, int *got_frame,
 121                             AVPacket *avpkt)
 122 {
 123     struct BitpackedContext *bc = avctx->priv_data;
 124     int buf_size = avpkt->size;
 125     AVFrame *frame = data;
 126     int res;
 127
 128     frame->pict_type = AV_PICTURE_TYPE_I;
 129     frame->key_frame = 1;
 130
 131     res = bc->decode(avctx, frame, avpkt);
 132     if (res)
 133         return res;
 134
 135     *got_frame = 1;
 136     return buf_size;
 137
 138 }
 139
 140 const 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     .codec_tags     = (const uint32_t []){
 150         MKTAG('U', 'Y', 'V', 'Y'),
 151         FF_CODEC_TAGS_END,
 152     },
 153 };