vda: Check the correct pointer for buffer allocation
[ffmpeg.git] / libavcodec / hq_hqa.c
1 /*
2  * Canopus HQ/HQA decoder
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <stdint.h>
22
23 #include "libavutil/attributes.h"
24 #include "libavutil/intreadwrite.h"
25
26 #include "avcodec.h"
27 #include "canopus.h"
28 #include "internal.h"
29
30 #include "hq_hqa.h"
31 #include "hq_hqadsp.h"
32
33 /* HQ/HQA slices are a set of macroblocks belonging to a frame, and
34  * they usually form a pseudorandom pattern (probably because it is
35  * nicer to display on partial decode).
36  *
37  * For HQA it just happens that each slice is on every 8th macroblock,
38  * but they can be on any frame width like
39  *   X.......X.
40  *   ......X...
41  *   ....X.....
42  *   ..X.......
43  * etc.
44  *
45  * The original decoder has special handling for edge macroblocks,
46  * while lavc simply aligns coded_width and coded_height.
47  */
48
49 static inline void put_blocks(HQContext *c, AVFrame *pic,
50                               int plane, int x, int y, int ilace,
51                               int16_t *block0, int16_t *block1)
52 {
53     uint8_t *p = pic->data[plane] + x;
54
55     c->hqhqadsp.idct_put(p + y * pic->linesize[plane],
56                          pic->linesize[plane] << ilace, block0);
57     c->hqhqadsp.idct_put(p + (y + (ilace ? 1 : 8)) * pic->linesize[plane],
58                          pic->linesize[plane] << ilace, block1);
59 }
60
61 static int hq_decode_block(HQContext *c, GetBitContext *gb, int16_t block[64],
62                            int qsel, int is_chroma, int is_hqa)
63 {
64     const int32_t *q;
65     int val, pos = 1;
66
67     memset(block, 0, 64 * sizeof(*block));
68
69     if (!is_hqa) {
70         block[0] = get_sbits(gb, 9) << 6;
71         q = ff_hq_quants[qsel][is_chroma][get_bits(gb, 2)];
72     } else {
73         q = ff_hq_quants[qsel][is_chroma][get_bits(gb, 2)];
74         block[0] = get_sbits(gb, 9) << 6;
75     }
76
77     for (;;) {
78         val = get_vlc2(gb, c->hq_ac_vlc.table, 9, 2);
79         if (val < 0)
80             return AVERROR_INVALIDDATA;
81
82         pos += ff_hq_ac_skips[val];
83         if (pos >= 64)
84             break;
85         block[ff_zigzag_direct[pos]] = (ff_hq_ac_syms[val] * q[pos]) >> 12;
86         pos++;
87     }
88
89     return 0;
90 }
91
92 static int hq_decode_mb(HQContext *c, AVFrame *pic,
93                         GetBitContext *gb, int x, int y)
94 {
95     int qgroup, flag;
96     int i, ret;
97
98     qgroup = get_bits(gb, 4);
99     flag = get_bits1(gb);
100
101     for (i = 0; i < 8; i++) {
102         ret = hq_decode_block(c, gb, c->block[i], qgroup, i >= 4, 0);
103         if (ret < 0)
104             return ret;
105     }
106
107     put_blocks(c, pic, 0, x,      y, flag, c->block[0], c->block[2]);
108     put_blocks(c, pic, 0, x + 8,  y, flag, c->block[1], c->block[3]);
109     put_blocks(c, pic, 2, x >> 1, y, flag, c->block[4], c->block[5]);
110     put_blocks(c, pic, 1, x >> 1, y, flag, c->block[6], c->block[7]);
111
112     return 0;
113 }
114
115 static int hq_decode_frame(HQContext *ctx, AVFrame *pic,
116                            int prof_num, size_t data_size)
117 {
118     const HQProfile *profile;
119     GetBitContext gb;
120     const uint8_t *perm, *src = ctx->gbc.buffer;
121     uint32_t slice_off[21];
122     int slice, start_off, next_off, i, ret;
123
124     if (prof_num >= NUM_HQ_PROFILES) {
125         profile = &ff_hq_profile[0];
126         avpriv_request_sample(ctx->avctx, "HQ Profile %d", prof_num);
127     } else {
128         profile = &ff_hq_profile[prof_num];
129         av_log(ctx->avctx, AV_LOG_VERBOSE, "HQ Profile %d\n", prof_num);
130     }
131
132     ctx->avctx->coded_width         = FFALIGN(profile->width,  16);
133     ctx->avctx->coded_height        = FFALIGN(profile->height, 16);
134     ctx->avctx->width               = profile->width;
135     ctx->avctx->height              = profile->height;
136     ctx->avctx->bits_per_raw_sample = 8;
137     ctx->avctx->pix_fmt             = AV_PIX_FMT_YUV422P;
138
139     ret = ff_get_buffer(ctx->avctx, pic, 0);
140     if (ret < 0) {
141         av_log(ctx->avctx, AV_LOG_ERROR, "Could not allocate buffer.\n");
142         return ret;
143     }
144
145     /* Offsets are stored from CUV position, so adjust them accordingly. */
146     for (i = 0; i < profile->num_slices + 1; i++)
147         slice_off[i] = bytestream2_get_be24(&ctx->gbc) - 4;
148
149     next_off = 0;
150     for (slice = 0; slice < profile->num_slices; slice++) {
151         start_off = next_off;
152         next_off  = profile->tab_h * (slice + 1) / profile->num_slices;
153         perm = profile->perm_tab + start_off * profile->tab_w * 2;
154
155         if (slice_off[slice] < (profile->num_slices + 1) * 3 ||
156             slice_off[slice] >= slice_off[slice + 1] ||
157             slice_off[slice + 1] > data_size) {
158             av_log(ctx->avctx, AV_LOG_ERROR,
159                    "Invalid slice size %zu.\n", data_size);
160             break;
161         }
162         init_get_bits(&gb, src + slice_off[slice],
163                       (slice_off[slice + 1] - slice_off[slice]) * 8);
164
165         for (i = 0; i < (next_off - start_off) * profile->tab_w; i++) {
166             ret = hq_decode_mb(ctx, pic, &gb, perm[0] * 16, perm[1] * 16);
167             if (ret < 0) {
168                 av_log(ctx->avctx, AV_LOG_ERROR,
169                        "Error decoding macroblock %d at slice %d.\n", i, slice);
170                 return ret;
171             }
172             perm += 2;
173         }
174     }
175
176     return 0;
177 }
178
179 static int hqa_decode_mb(HQContext *c, AVFrame *pic, int qgroup,
180                          GetBitContext *gb, int x, int y)
181 {
182     int flag = 0;
183     int i, ret, cbp;
184
185     cbp = get_vlc2(gb, c->hqa_cbp_vlc.table, 5, 1);
186
187     for (i = 0; i < 12; i++)
188         memset(c->block[i], 0, sizeof(*c->block));
189     for (i = 0; i < 12; i++)
190         c->block[i][0] = -128 * (1 << 6);
191
192     if (cbp) {
193         flag = get_bits1(gb);
194
195         cbp |= cbp << 4;
196         if (cbp & 0x3)
197             cbp |= 0x500;
198         if (cbp & 0xC)
199             cbp |= 0xA00;
200         for (i = 0; i < 12; i++) {
201             if (!(cbp & (1 << i)))
202                 continue;
203             ret = hq_decode_block(c, gb, c->block[i], qgroup, i >= 8, 1);
204             if (ret < 0)
205                 return ret;
206         }
207     }
208
209     put_blocks(c, pic, 3, x,      y, flag, c->block[ 0], c->block[ 2]);
210     put_blocks(c, pic, 3, x + 8,  y, flag, c->block[ 1], c->block[ 3]);
211     put_blocks(c, pic, 0, x,      y, flag, c->block[ 4], c->block[ 6]);
212     put_blocks(c, pic, 0, x + 8,  y, flag, c->block[ 5], c->block[ 7]);
213     put_blocks(c, pic, 2, x >> 1, y, flag, c->block[ 8], c->block[ 9]);
214     put_blocks(c, pic, 1, x >> 1, y, flag, c->block[10], c->block[11]);
215
216     return 0;
217 }
218
219 static int hqa_decode_slice(HQContext *ctx, AVFrame *pic, GetBitContext *gb,
220                             int quant, int slice_no, int w, int h)
221 {
222     int i, j, off;
223     int ret;
224
225     for (i = 0; i < h; i += 16) {
226         off = (slice_no * 16 + i * 3) & 0x70;
227         for (j = off; j < w; j += 128) {
228             ret = hqa_decode_mb(ctx, pic, quant, gb, j, i);
229             if (ret < 0) {
230                 av_log(ctx->avctx, AV_LOG_ERROR,
231                        "Error decoding macroblock at %dx%d.\n", i, j);
232                 return ret;
233             }
234         }
235     }
236
237     return 0;
238 }
239
240 static int hqa_decode_frame(HQContext *ctx, AVFrame *pic, size_t data_size)
241 {
242     GetBitContext gb;
243     const int num_slices = 8;
244     uint32_t slice_off[9];
245     int i, slice, ret;
246     int width, height, quant;
247     const uint8_t *src = ctx->gbc.buffer;
248
249     width  = bytestream2_get_be16(&ctx->gbc);
250     height = bytestream2_get_be16(&ctx->gbc);
251
252     ctx->avctx->coded_width         = FFALIGN(width,  16);
253     ctx->avctx->coded_height        = FFALIGN(height, 16);
254     ctx->avctx->width               = width;
255     ctx->avctx->height              = height;
256     ctx->avctx->bits_per_raw_sample = 8;
257     ctx->avctx->pix_fmt             = AV_PIX_FMT_YUVA422P;
258
259     av_log(ctx->avctx, AV_LOG_VERBOSE, "HQA Profile\n");
260
261     quant = bytestream2_get_byte(&ctx->gbc);
262     bytestream2_skip(&ctx->gbc, 3);
263     if (quant >= NUM_HQ_QUANTS) {
264         av_log(ctx->avctx, AV_LOG_ERROR,
265                "Invalid quantization matrix %d.\n", quant);
266         return AVERROR_INVALIDDATA;
267     }
268
269     ret = ff_get_buffer(ctx->avctx, pic, 0);
270     if (ret < 0) {
271         av_log(ctx->avctx, AV_LOG_ERROR, "Could not allocate buffer.\n");
272         return ret;
273     }
274
275     /* Offsets are stored from HQA1 position, so adjust them accordingly. */
276     for (i = 0; i < num_slices + 1; i++)
277         slice_off[i] = bytestream2_get_be32(&ctx->gbc) - 4;
278
279     for (slice = 0; slice < num_slices; slice++) {
280         if (slice_off[slice] < (num_slices + 1) * 3 ||
281             slice_off[slice] >= slice_off[slice + 1] ||
282             slice_off[slice + 1] > data_size) {
283             av_log(ctx->avctx, AV_LOG_ERROR,
284                    "Invalid slice size %zu.\n", data_size);
285             break;
286         }
287         init_get_bits(&gb, src + slice_off[slice],
288                       (slice_off[slice + 1] - slice_off[slice]) * 8);
289
290         ret = hqa_decode_slice(ctx, pic, &gb, quant, slice, width, height);
291         if (ret < 0)
292             return ret;
293     }
294
295     return 0;
296 }
297
298 static int hq_hqa_decode_frame(AVCodecContext *avctx, void *data,
299                                int *got_frame, AVPacket *avpkt)
300 {
301     HQContext *ctx = avctx->priv_data;
302     AVFrame *pic = data;
303     uint32_t info_tag;
304     unsigned int data_size;
305     int tag, ret;
306
307     bytestream2_init(&ctx->gbc, avpkt->data, avpkt->size);
308     if (bytestream2_get_bytes_left(&ctx->gbc) < 4 + 4) {
309         av_log(avctx, AV_LOG_ERROR, "Frame is too small (%d).\n", avpkt->size);
310         return AVERROR_INVALIDDATA;
311     }
312
313     info_tag = bytestream2_get_le32(&ctx->gbc);
314     if (info_tag == MKTAG('I', 'N', 'F', 'O')) {
315         int info_size = bytestream2_get_le32(&ctx->gbc);
316         if (bytestream2_get_bytes_left(&ctx->gbc) < info_size) {
317             av_log(avctx, AV_LOG_ERROR, "Invalid INFO size (%d).\n", info_size);
318             return AVERROR_INVALIDDATA;
319         }
320         ff_canopus_parse_info_tag(avctx, ctx->gbc.buffer, info_size);
321
322         bytestream2_skip(&ctx->gbc, info_size);
323     }
324
325     data_size = bytestream2_get_bytes_left(&ctx->gbc);
326     if (data_size < 4) {
327         av_log(avctx, AV_LOG_ERROR, "Frame is too small (%d).\n", data_size);
328         return AVERROR_INVALIDDATA;
329     }
330
331     /* HQ defines dimensions and number of slices, and thus slice traversal
332      * order. HQA has no size constraint and a fixed number of slices, so it
333      * needs a separate scheme for it. */
334     tag = bytestream2_get_le32(&ctx->gbc);
335     if ((tag & 0x00FFFFFF) == (MKTAG('U', 'V', 'C', ' ') & 0x00FFFFFF)) {
336         ret = hq_decode_frame(ctx, pic, tag >> 24, data_size);
337     } else if (tag == MKTAG('H', 'Q', 'A', '1')) {
338         ret = hqa_decode_frame(ctx, pic, data_size);
339     } else {
340         av_log(avctx, AV_LOG_ERROR, "Not a HQ/HQA frame.\n");
341         return AVERROR_INVALIDDATA;
342     }
343     if (ret < 0) {
344         av_log(avctx, AV_LOG_ERROR, "Error decoding frame.\n");
345         return ret;
346     }
347
348     pic->key_frame = 1;
349     pic->pict_type = AV_PICTURE_TYPE_I;
350
351     *got_frame = 1;
352
353     return avpkt->size;
354 }
355
356 static av_cold int hq_hqa_decode_init(AVCodecContext *avctx)
357 {
358     HQContext *ctx = avctx->priv_data;
359     ctx->avctx = avctx;
360
361     ff_hqdsp_init(&ctx->hqhqadsp);
362
363     return ff_hq_init_vlcs(ctx);
364 }
365
366 static av_cold int hq_hqa_decode_close(AVCodecContext *avctx)
367 {
368     HQContext *ctx = avctx->priv_data;
369
370     ff_free_vlc(&ctx->hq_ac_vlc);
371     ff_free_vlc(&ctx->hqa_cbp_vlc);
372
373     return 0;
374 }
375
376 AVCodec ff_hq_hqa_decoder = {
377     .name           = "hq_hqa",
378     .long_name      = NULL_IF_CONFIG_SMALL("Canopus HQ/HQA"),
379     .type           = AVMEDIA_TYPE_VIDEO,
380     .id             = AV_CODEC_ID_HQ_HQA,
381     .priv_data_size = sizeof(HQContext),
382     .init           = hq_hqa_decode_init,
383     .decode         = hq_hqa_decode_frame,
384     .close          = hq_hqa_decode_close,
385     .capabilities   = CODEC_CAP_DR1,
386     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
387                       FF_CODEC_CAP_INIT_CLEANUP,
388 };