FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/bitpacked_dec.c
Date: 2024-05-26 22:00:00
Exec Total Coverage
Lines: 0 53 0.0%
Functions: 0 4 0.0%
Branches: 0 32 0.0%

Line Branch Exec Source
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 "codec_internal.h"
31 #include "libavutil/imgutils.h"
32 #include "thread.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 if (!frame->buf[0]) {
49 return AVERROR(ENOMEM);
50 }
51
52 ret = av_image_fill_arrays(frame->data, frame->linesize, avpkt->data,
53 avctx->pix_fmt, avctx->width, avctx->height, 1);
54 if (ret < 0) {
55 av_buffer_unref(&frame->buf[0]);
56 return ret;
57 }
58
59 return 0;
60 }
61
62 static int bitpacked_decode_yuv422p10(AVCodecContext *avctx, AVFrame *frame,
63 const AVPacket *avpkt)
64 {
65 uint64_t frame_size = (uint64_t)avctx->width * (uint64_t)avctx->height * 20;
66 uint64_t packet_size = (uint64_t)avpkt->size * 8;
67 uint8_t *src;
68 uint16_t *y, *u, *v;
69 int ret, i, j;
70
71 ret = ff_thread_get_buffer(avctx, frame, 0);
72 if (ret < 0)
73 return ret;
74
75 if (frame_size > packet_size)
76 return AVERROR_INVALIDDATA;
77
78 if (avctx->width % 2)
79 return AVERROR_PATCHWELCOME;
80
81 src = avpkt->data;
82 for (i = 0; i < avctx->height; i++) {
83 y = (uint16_t*)(frame->data[0] + i * frame->linesize[0]);
84 u = (uint16_t*)(frame->data[1] + i * frame->linesize[1]);
85 v = (uint16_t*)(frame->data[2] + i * frame->linesize[2]);
86
87 for (j = 0; j < avctx->width; j += 2) {
88 *u++ = (src[0] << 2) | (src[1] >> 6);
89 *v++ = ((src[2] << 6) | (src[3] >> 2)) & 0x3ff;
90 *y++ = ((src[1] << 4) | (src[2] >> 4)) & 0x3ff;
91 *y++ = ((src[3] << 8) | (src[4])) & 0x3ff;
92 src += 5;
93 }
94 }
95
96 return 0;
97 }
98
99 static av_cold int bitpacked_init_decoder(AVCodecContext *avctx)
100 {
101 struct BitpackedContext *bc = avctx->priv_data;
102
103 if (!avctx->codec_tag || !avctx->width || !avctx->height)
104 return AVERROR_INVALIDDATA;
105
106 if (avctx->codec_tag == MKTAG('U', 'Y', 'V', 'Y')) {
107 if (avctx->bits_per_coded_sample == 16 &&
108 avctx->pix_fmt == AV_PIX_FMT_UYVY422)
109 bc->decode = bitpacked_decode_uyvy422;
110 else if (avctx->bits_per_coded_sample == 20 &&
111 avctx->pix_fmt == AV_PIX_FMT_YUV422P10)
112 bc->decode = bitpacked_decode_yuv422p10;
113 else
114 return AVERROR_INVALIDDATA;
115 } else {
116 return AVERROR_INVALIDDATA;
117 }
118
119 return 0;
120 }
121
122 static int bitpacked_decode(AVCodecContext *avctx, AVFrame *frame,
123 int *got_frame, AVPacket *avpkt)
124 {
125 struct BitpackedContext *bc = avctx->priv_data;
126 int buf_size = avpkt->size;
127 int res;
128
129 res = bc->decode(avctx, frame, avpkt);
130 if (res)
131 return res;
132
133 *got_frame = 1;
134 return buf_size;
135
136 }
137
138 const FFCodec ff_bitpacked_decoder = {
139 .p.name = "bitpacked",
140 CODEC_LONG_NAME("Bitpacked"),
141 .p.type = AVMEDIA_TYPE_VIDEO,
142 .p.id = AV_CODEC_ID_BITPACKED,
143 .p.capabilities = AV_CODEC_CAP_FRAME_THREADS,
144 .priv_data_size = sizeof(struct BitpackedContext),
145 .init = bitpacked_init_decoder,
146 FF_CODEC_DECODE_CB(bitpacked_decode),
147 .codec_tags = (const uint32_t []){
148 MKTAG('U', 'Y', 'V', 'Y'),
149 FF_CODEC_TAGS_END,
150 },
151 };
152