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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
}; |