avcodec/cavsdec: Propagate error codes inside decode_mb_i()
[ffmpeg.git] / libavcodec / cbs_vp9.c
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #include "libavutil/avassert.h"
20
21 #include "cbs.h"
22 #include "cbs_internal.h"
23 #include "cbs_vp9.h"
24 #include "internal.h"
25
26
27 static int cbs_vp9_read_s(CodedBitstreamContext *ctx, GetBitContext *gbc,
28                           int width, const char *name,
29                           const int *subscripts, int32_t *write_to)
30 {
31     uint32_t magnitude;
32     int position, sign;
33     int32_t value;
34
35     if (ctx->trace_enable)
36         position = get_bits_count(gbc);
37
38     if (get_bits_left(gbc) < width + 1) {
39         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid signed value at "
40                "%s: bitstream ended.\n", name);
41         return AVERROR_INVALIDDATA;
42     }
43
44     magnitude = get_bits(gbc, width);
45     sign      = get_bits1(gbc);
46     value     = sign ? -(int32_t)magnitude : magnitude;
47
48     if (ctx->trace_enable) {
49         char bits[33];
50         int i;
51         for (i = 0; i < width; i++)
52             bits[i] = magnitude >> (width - i - 1) & 1 ? '1' : '0';
53         bits[i] = sign ? '1' : '0';
54         bits[i + 1] = 0;
55
56         ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
57                                     bits, value);
58     }
59
60     *write_to = value;
61     return 0;
62 }
63
64 static int cbs_vp9_write_s(CodedBitstreamContext *ctx, PutBitContext *pbc,
65                            int width, const char *name,
66                            const int *subscripts, int32_t value)
67 {
68     uint32_t magnitude;
69     int sign;
70
71     if (put_bits_left(pbc) < width + 1)
72         return AVERROR(ENOSPC);
73
74     sign      = value < 0;
75     magnitude = sign ? -value : value;
76
77     if (ctx->trace_enable) {
78         char bits[33];
79         int i;
80         for (i = 0; i < width; i++)
81             bits[i] = magnitude >> (width - i - 1) & 1 ? '1' : '0';
82         bits[i] = sign ? '1' : '0';
83         bits[i + 1] = 0;
84
85         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
86                                     name, subscripts, bits, value);
87     }
88
89     put_bits(pbc, width, magnitude);
90     put_bits(pbc, 1, sign);
91
92     return 0;
93 }
94
95 static int cbs_vp9_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc,
96                                   uint32_t range_min, uint32_t range_max,
97                                   const char *name, uint32_t *write_to)
98 {
99     uint32_t value;
100     int position, i;
101     char bits[8];
102
103     av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
104     if (ctx->trace_enable)
105         position = get_bits_count(gbc);
106
107     for (i = 0, value = range_min; value < range_max;) {
108         if (get_bits_left(gbc) < 1) {
109             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid increment value at "
110                    "%s: bitstream ended.\n", name);
111             return AVERROR_INVALIDDATA;
112         }
113         if (get_bits1(gbc)) {
114             bits[i++] = '1';
115             ++value;
116         } else {
117             bits[i++] = '0';
118             break;
119         }
120     }
121
122     if (ctx->trace_enable) {
123         bits[i] = 0;
124         ff_cbs_trace_syntax_element(ctx, position, name, NULL, bits, value);
125     }
126
127     *write_to = value;
128     return 0;
129 }
130
131 static int cbs_vp9_write_increment(CodedBitstreamContext *ctx, PutBitContext *pbc,
132                                    uint32_t range_min, uint32_t range_max,
133                                    const char *name, uint32_t value)
134 {
135     int len;
136
137     av_assert0(range_min <= range_max && range_max - range_min < 8);
138     if (value < range_min || value > range_max) {
139         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
140                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
141                name, value, range_min, range_max);
142         return AVERROR_INVALIDDATA;
143     }
144
145     if (value == range_max)
146         len = range_max - range_min;
147     else
148         len = value - range_min + 1;
149     if (put_bits_left(pbc) < len)
150         return AVERROR(ENOSPC);
151
152     if (ctx->trace_enable) {
153         char bits[8];
154         int i;
155         for (i = 0; i < len; i++) {
156             if (range_min + i == value)
157                 bits[i] = '0';
158             else
159                 bits[i] = '1';
160         }
161         bits[i] = 0;
162         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
163                                     name, NULL, bits, value);
164     }
165
166     if (len > 0)
167         put_bits(pbc, len, (1 << len) - 1 - (value != range_max));
168
169     return 0;
170 }
171
172 static int cbs_vp9_read_le(CodedBitstreamContext *ctx, GetBitContext *gbc,
173                            int width, const char *name,
174                            const int *subscripts, uint32_t *write_to)
175 {
176     uint32_t value;
177     int position, b;
178
179     av_assert0(width % 8 == 0);
180
181     if (ctx->trace_enable)
182         position = get_bits_count(gbc);
183
184     if (get_bits_left(gbc) < width) {
185         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid le value at "
186                "%s: bitstream ended.\n", name);
187         return AVERROR_INVALIDDATA;
188     }
189
190     value = 0;
191     for (b = 0; b < width; b += 8)
192         value |= get_bits(gbc, 8) << b;
193
194     if (ctx->trace_enable) {
195         char bits[33];
196         int i;
197         for (b = 0; b < width; b += 8)
198             for (i = 0; i < 8; i++)
199                 bits[b + i] = value >> (b + i) & 1 ? '1' : '0';
200         bits[b] = 0;
201
202         ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
203                                     bits, value);
204     }
205
206     *write_to = value;
207     return 0;
208 }
209
210 static int cbs_vp9_write_le(CodedBitstreamContext *ctx, PutBitContext *pbc,
211                             int width, const char *name,
212                             const int *subscripts, uint32_t value)
213 {
214     int b;
215
216     av_assert0(width % 8 == 0);
217
218     if (put_bits_left(pbc) < width)
219         return AVERROR(ENOSPC);
220
221     if (ctx->trace_enable) {
222         char bits[33];
223         int i;
224         for (b = 0; b < width; b += 8)
225             for (i = 0; i < 8; i++)
226                 bits[b + i] = value >> (b + i) & 1 ? '1' : '0';
227         bits[b] = 0;
228
229         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
230                                     name, subscripts, bits, value);
231     }
232
233     for (b = 0; b < width; b += 8)
234         put_bits(pbc, 8, value >> b & 0xff);
235
236     return 0;
237 }
238
239 #define HEADER(name) do { \
240         ff_cbs_trace_header(ctx, name); \
241     } while (0)
242
243 #define CHECK(call) do { \
244         err = (call); \
245         if (err < 0) \
246             return err; \
247     } while (0)
248
249 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
250 #define FUNC_VP9(rw, name) FUNC_NAME(rw, vp9, name)
251 #define FUNC(name) FUNC_VP9(READWRITE, name)
252
253 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
254
255 #define f(width, name) \
256         xf(width, name, current->name, 0)
257 #define s(width, name) \
258         xs(width, name, current->name, 0)
259 #define fs(width, name, subs, ...) \
260         xf(width, name, current->name, subs, __VA_ARGS__)
261 #define ss(width, name, subs, ...) \
262         xs(width, name, current->name, subs, __VA_ARGS__)
263
264
265 #define READ
266 #define READWRITE read
267 #define RWContext GetBitContext
268
269 #define xf(width, name, var, subs, ...) do { \
270         uint32_t value = 0; \
271         CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
272                                    SUBSCRIPTS(subs, __VA_ARGS__), \
273                                    &value, 0, (1 << width) - 1)); \
274         var = value; \
275     } while (0)
276 #define xs(width, name, var, subs, ...) do { \
277         int32_t value = 0; \
278         CHECK(cbs_vp9_read_s(ctx, rw, width, #name, \
279                              SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
280         var = value; \
281     } while (0)
282
283
284 #define increment(name, min, max) do { \
285         uint32_t value = 0; \
286         CHECK(cbs_vp9_read_increment(ctx, rw, min, max, #name, &value)); \
287         current->name = value; \
288     } while (0)
289
290 #define fle(width, name, subs, ...) do { \
291         CHECK(cbs_vp9_read_le(ctx, rw, width, #name, \
292                               SUBSCRIPTS(subs, __VA_ARGS__), &current->name)); \
293     } while (0)
294
295 #define delta_q(name) do { \
296         uint8_t delta_coded; \
297         int8_t delta_q; \
298         xf(1, name.delta_coded, delta_coded, 0); \
299         if (delta_coded) \
300             xs(4, name.delta_q, delta_q, 0); \
301         else \
302             delta_q = 0; \
303         current->name = delta_q; \
304     } while (0)
305
306 #define prob(name, subs, ...) do { \
307         uint8_t prob_coded; \
308         int8_t prob; \
309         xf(1, name.prob_coded, prob_coded, subs, __VA_ARGS__); \
310         if (prob_coded) \
311             xf(8, name.prob, prob, subs, __VA_ARGS__); \
312         else \
313             prob = 255; \
314         current->name = prob; \
315     } while (0)
316
317 #define fixed(width, name, value) do { \
318         av_unused uint32_t fixed_value = value; \
319         CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
320                                    0, &fixed_value, value, value)); \
321     } while (0)
322
323 #define infer(name, value) do { \
324         current->name = value; \
325     } while (0)
326
327 #define byte_alignment(rw) (get_bits_count(rw) % 8)
328
329 #include "cbs_vp9_syntax_template.c"
330
331 #undef READ
332 #undef READWRITE
333 #undef RWContext
334 #undef xf
335 #undef xs
336 #undef increment
337 #undef fle
338 #undef delta_q
339 #undef prob
340 #undef fixed
341 #undef infer
342 #undef byte_alignment
343
344
345 #define WRITE
346 #define READWRITE write
347 #define RWContext PutBitContext
348
349 #define xf(width, name, var, subs, ...) do { \
350         CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
351                                     SUBSCRIPTS(subs, __VA_ARGS__), \
352                                     var, 0, (1 << width) - 1)); \
353     } while (0)
354 #define xs(width, name, var, subs, ...) do { \
355         CHECK(cbs_vp9_write_s(ctx, rw, width, #name, \
356                               SUBSCRIPTS(subs, __VA_ARGS__), var)); \
357     } while (0)
358
359 #define increment(name, min, max) do { \
360         CHECK(cbs_vp9_write_increment(ctx, rw, min, max, #name, current->name)); \
361     } while (0)
362
363 #define fle(width, name, subs, ...) do { \
364         CHECK(cbs_vp9_write_le(ctx, rw, width, #name, \
365                                SUBSCRIPTS(subs, __VA_ARGS__), current->name)); \
366     } while (0)
367
368 #define delta_q(name) do { \
369         xf(1, name.delta_coded, !!current->name, 0); \
370         if (current->name) \
371             xs(4, name.delta_q, current->name, 0); \
372     } while (0)
373
374 #define prob(name, subs, ...) do { \
375         xf(1, name.prob_coded, current->name != 255, subs, __VA_ARGS__); \
376         if (current->name != 255) \
377             xf(8, name.prob, current->name, subs, __VA_ARGS__); \
378     } while (0)
379
380 #define fixed(width, name, value) do { \
381         CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
382                                     0, value, value, value)); \
383     } while (0)
384
385 #define infer(name, value) do { \
386         if (current->name != (value)) { \
387             av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
388                    "%s does not match inferred value: " \
389                    "%"PRId64", but should be %"PRId64".\n", \
390                    #name, (int64_t)current->name, (int64_t)(value)); \
391         } \
392     } while (0)
393
394 #define byte_alignment(rw) (put_bits_count(rw) % 8)
395
396 #include "cbs_vp9_syntax_template.c"
397
398 #undef READ
399 #undef READWRITE
400 #undef RWContext
401 #undef xf
402 #undef xs
403 #undef increment
404 #undef fle
405 #undef delta_q
406 #undef prob
407 #undef fixed
408 #undef infer
409 #undef byte_alignment
410
411
412 static int cbs_vp9_split_fragment(CodedBitstreamContext *ctx,
413                                   CodedBitstreamFragment *frag,
414                                   int header)
415 {
416     uint8_t superframe_header;
417     int err;
418
419     // Last byte in the packet.
420     superframe_header = frag->data[frag->data_size - 1];
421
422     if ((superframe_header & 0xe0) == 0xc0) {
423         VP9RawSuperframeIndex sfi;
424         GetBitContext gbc;
425         size_t index_size, pos;
426         int i;
427
428         index_size = 2 + (((superframe_header & 0x18) >> 3) + 1) *
429                           ((superframe_header & 0x07) + 1);
430
431         err = init_get_bits(&gbc, frag->data + frag->data_size - index_size,
432                             8 * index_size);
433         if (err < 0)
434             return err;
435
436         err = cbs_vp9_read_superframe_index(ctx, &gbc, &sfi);
437         if (err < 0)
438             return err;
439
440         pos = 0;
441         for (i = 0; i <= sfi.frames_in_superframe_minus_1; i++) {
442             if (pos + sfi.frame_sizes[i] + index_size > frag->data_size) {
443                 av_log(ctx->log_ctx, AV_LOG_ERROR, "Frame %d too large "
444                        "in superframe: %"PRIu32" bytes.\n",
445                        i, sfi.frame_sizes[i]);
446                 return AVERROR_INVALIDDATA;
447             }
448
449             err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
450                                           frag->data + pos,
451                                           sfi.frame_sizes[i],
452                                           frag->data_ref);
453             if (err < 0)
454                 return err;
455
456             pos += sfi.frame_sizes[i];
457         }
458         if (pos + index_size != frag->data_size) {
459             av_log(ctx->log_ctx, AV_LOG_WARNING, "Extra padding at "
460                    "end of superframe: %zu bytes.\n",
461                    frag->data_size - (pos + index_size));
462         }
463
464         return 0;
465
466     } else {
467         err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
468                                       frag->data, frag->data_size,
469                                       frag->data_ref);
470         if (err < 0)
471             return err;
472     }
473
474     return 0;
475 }
476
477 static void cbs_vp9_free_frame(void *unit, uint8_t *content)
478 {
479     VP9RawFrame *frame = (VP9RawFrame*)content;
480     av_buffer_unref(&frame->data_ref);
481     av_freep(&frame);
482 }
483
484 static int cbs_vp9_read_unit(CodedBitstreamContext *ctx,
485                              CodedBitstreamUnit *unit)
486 {
487     VP9RawFrame *frame;
488     GetBitContext gbc;
489     int err, pos;
490
491     err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
492     if (err < 0)
493         return err;
494
495     err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*frame),
496                                     &cbs_vp9_free_frame);
497     if (err < 0)
498         return err;
499     frame = unit->content;
500
501     err = cbs_vp9_read_frame(ctx, &gbc, frame);
502     if (err < 0)
503         return err;
504
505     pos = get_bits_count(&gbc);
506     av_assert0(pos % 8 == 0);
507     pos /= 8;
508     av_assert0(pos <= unit->data_size);
509
510     if (pos == unit->data_size) {
511         // No data (e.g. a show-existing-frame frame).
512     } else {
513         frame->data_ref = av_buffer_ref(unit->data_ref);
514         if (!frame->data_ref)
515             return AVERROR(ENOMEM);
516
517         frame->data      = unit->data      + pos;
518         frame->data_size = unit->data_size - pos;
519     }
520
521     return 0;
522 }
523
524 static int cbs_vp9_write_unit(CodedBitstreamContext *ctx,
525                               CodedBitstreamUnit *unit)
526 {
527     CodedBitstreamVP9Context *priv = ctx->priv_data;
528     VP9RawFrame *frame = unit->content;
529     PutBitContext pbc;
530     int err;
531
532     if (!priv->write_buffer) {
533         // Initial write buffer size is 1MB.
534         priv->write_buffer_size = 1024 * 1024;
535
536     reallocate_and_try_again:
537         err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
538         if (err < 0) {
539             av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
540                    "sufficiently large write buffer (last attempt "
541                    "%zu bytes).\n", priv->write_buffer_size);
542             return err;
543         }
544     }
545
546     init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);
547
548     err = cbs_vp9_write_frame(ctx, &pbc, frame);
549     if (err == AVERROR(ENOSPC)) {
550         priv->write_buffer_size *= 2;
551         goto reallocate_and_try_again;
552     }
553     if (err < 0)
554         return err;
555
556     // Frame must be byte-aligned.
557     av_assert0(put_bits_count(&pbc) % 8 == 0);
558
559     unit->data_size        = put_bits_count(&pbc) / 8;
560     unit->data_bit_padding = 0;
561     flush_put_bits(&pbc);
562
563     if (frame->data) {
564         if (unit->data_size + frame->data_size >
565             priv->write_buffer_size) {
566             priv->write_buffer_size *= 2;
567             goto reallocate_and_try_again;
568         }
569
570         memcpy(priv->write_buffer + unit->data_size,
571                frame->data, frame->data_size);
572         unit->data_size += frame->data_size;
573     }
574
575     err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size);
576     if (err < 0)
577         return err;
578
579     memcpy(unit->data, priv->write_buffer, unit->data_size);
580
581     return 0;
582 }
583
584 static int cbs_vp9_assemble_fragment(CodedBitstreamContext *ctx,
585                                      CodedBitstreamFragment *frag)
586 {
587     int err;
588
589     if (frag->nb_units == 1) {
590         // Output is just the content of the single frame.
591
592         CodedBitstreamUnit *frame = &frag->units[0];
593
594         frag->data_ref = av_buffer_ref(frame->data_ref);
595         if (!frag->data_ref)
596             return AVERROR(ENOMEM);
597
598         frag->data      = frame->data;
599         frag->data_size = frame->data_size;
600
601     } else {
602         // Build superframe out of frames.
603
604         VP9RawSuperframeIndex sfi;
605         PutBitContext pbc;
606         AVBufferRef *ref;
607         uint8_t *data;
608         size_t size, max, pos;
609         int i, size_len;
610
611         if (frag->nb_units > 8) {
612             av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many frames to "
613                    "make superframe: %d.\n", frag->nb_units);
614             return AVERROR(EINVAL);
615         }
616
617         max = 0;
618         for (i = 0; i < frag->nb_units; i++)
619             if (max < frag->units[i].data_size)
620                 max = frag->units[i].data_size;
621
622         if (max < 2)
623             size_len = 1;
624         else
625             size_len = av_log2(max) / 8 + 1;
626         av_assert0(size_len <= 4);
627
628         sfi.superframe_marker            = VP9_SUPERFRAME_MARKER;
629         sfi.bytes_per_framesize_minus_1  = size_len - 1;
630         sfi.frames_in_superframe_minus_1 = frag->nb_units - 1;
631
632         size = 2;
633         for (i = 0; i < frag->nb_units; i++) {
634             size += size_len + frag->units[i].data_size;
635             sfi.frame_sizes[i] = frag->units[i].data_size;
636         }
637
638         ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
639         if (!ref)
640             return AVERROR(ENOMEM);
641         data = ref->data;
642         memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
643
644         pos = 0;
645         for (i = 0; i < frag->nb_units; i++) {
646             av_assert0(size - pos > frag->units[i].data_size);
647             memcpy(data + pos, frag->units[i].data,
648                    frag->units[i].data_size);
649             pos += frag->units[i].data_size;
650         }
651         av_assert0(size - pos == 2 + frag->nb_units * size_len);
652
653         init_put_bits(&pbc, data + pos, size - pos);
654
655         err = cbs_vp9_write_superframe_index(ctx, &pbc, &sfi);
656         if (err < 0) {
657             av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write "
658                    "superframe index.\n");
659             av_buffer_unref(&ref);
660             return err;
661         }
662
663         av_assert0(put_bits_left(&pbc) == 0);
664         flush_put_bits(&pbc);
665
666         frag->data_ref  = ref;
667         frag->data      = data;
668         frag->data_size = size;
669     }
670
671     return 0;
672 }
673
674 static void cbs_vp9_close(CodedBitstreamContext *ctx)
675 {
676     CodedBitstreamVP9Context *priv = ctx->priv_data;
677
678     av_freep(&priv->write_buffer);
679 }
680
681 const CodedBitstreamType ff_cbs_type_vp9 = {
682     .codec_id          = AV_CODEC_ID_VP9,
683
684     .priv_data_size    = sizeof(CodedBitstreamVP9Context),
685
686     .split_fragment    = &cbs_vp9_split_fragment,
687     .read_unit         = &cbs_vp9_read_unit,
688     .write_unit        = &cbs_vp9_write_unit,
689     .assemble_fragment = &cbs_vp9_assemble_fragment,
690
691     .close             = &cbs_vp9_close,
692 };