1 /*
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
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 /**
23 * @file
24 * H.264 / AVC / MPEG4 part10 codec.
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
28 #ifndef AVCODEC_H264_H
29 #define AVCODEC_H264_H
30
38
39 #define interlaced_dct interlaced_dct_is_a_bad_name
40 #define mb_intra mb_intra_is_not_initialized_see_mb_type
41
42 #define MAX_SPS_COUNT 32
43 #define MAX_PPS_COUNT 256
44
45 #define MAX_MMCO_COUNT 66
46
47 #define MAX_DELAYED_PIC_COUNT 16
48
49 #define MAX_MBPAIR_SIZE (256*1024) // a tighter bound could be calculated if someone cares about a few bytes
50
51 /* Compiling in interlaced support reduces the speed
52 * of progressive decoding by about 2%. */
53 #define ALLOW_INTERLACE
54
56
57 /**
58 * The maximum number of slices supported by the decoder.
59 * must be a power of 2
60 */
62
63 #ifdef ALLOW_INTERLACE
64 #define MB_MBAFF h->mb_mbaff
65 #define MB_FIELD h->mb_field_decoding_flag
66 #define FRAME_MBAFF h->mb_aff_frame
67 #define FIELD_PICTURE (s->picture_structure != PICT_FRAME)
72 #else
73 #define MB_MBAFF 0
74 #define MB_FIELD 0
75 #define FRAME_MBAFF 0
76 #define FIELD_PICTURE 0
77 #undef IS_INTERLACED
78 #define IS_INTERLACED(mb_type) 0
79 #define LEFT_MBS 1
80 #define LTOP 0
81 #define LBOT 0
82 #define LEFT(i) 0
83 #endif
84 #define FIELD_OR_MBAFF_PICTURE (FRAME_MBAFF || FIELD_PICTURE)
85
86 #ifndef CABAC
87 #define CABAC h->pps.cabac
88 #endif
89
90 #define CHROMA (h->sps.chroma_format_idc)
91 #define CHROMA422 (h->sps.chroma_format_idc == 2)
92 #define CHROMA444 (h->sps.chroma_format_idc == 3)
93
94 #define EXTENDED_SAR 255
95
96 #define MB_TYPE_REF0 MB_TYPE_ACPRED // dirty but it fits in 16 bit
97 #define MB_TYPE_8x8DCT 0x01000000
98 #define IS_REF0(a) ((a) & MB_TYPE_REF0)
99 #define IS_8x8DCT(a) ((a) & MB_TYPE_8x8DCT)
100
101 #define QP_MAX_NUM (51 + 6*6) // The maximum supported qp
102
103 /* NAL unit types */
104 enum {
120 };
121
122 /**
123 * SEI message types
124 */
132
133 /**
134 * pic_struct in picture timing SEI message
135 */
147
148 /**
149 * Sequence parameter set
150 */
168 int mb_aff;
///< mb_adaptive_frame_field_flag
170 int crop;
///< frame_cropping_flag
171 unsigned int crop_left;
///< frame_cropping_rect_left_offset
172 unsigned int crop_right;
///< frame_cropping_rect_right_offset
173 unsigned int crop_top;
///< frame_cropping_rect_top_offset
205 int new;
///< flag to keep track if the decoder context needs re-init due to changed SPS
207
208 /**
209 * Picture parameter set
210 */
213 int cabac;
///< entropy_coding_mode_flag
217 unsigned int ref_count[2];
///< num_ref_idx_l0/1_active_minus1 + 1
232
233 /**
234 * Memory management control operation opcode.
235 */
245
246 /**
247 * Memory management control operation.
248 */
252 int long_arg;
///< index, pic_num, or num long refs depending on opcode
254
255 /**
256 * H264Context
257 */
263
265
268
269 // prediction stuff
272
277
282
285
294
295 /**
296 * non zero coeff count cache.
297 * is 64 if not available.
298 */
300
302
303 /**
304 * Motion vector cache.
305 */
308 #define LIST_NOT_USED -1 // FIXME rename?
309 #define PART_NOT_AVAILABLE -2
310
311 /**
312 * number of neighbors (top and/or left) that used 8x8 dct
313 */
315
316 /**
317 * block_offset[ 0..23] for frame macroblocks
318 * block_offset[24..47] for field macroblocks
319 */
321
322 uint32_t *
mb2b_xy;
// FIXME are these 4 a good idea?
325
326 int mb_linesize;
///< may be equal to s->linesize or s->linesize * 2, for mbaff
328
331
334
335 /**
336 * current pps
337 */
338 PPS pps;
// FIXME move to Picture perhaps? (->no) do we need that?
339
344
350
351 // interlacing specific flags
354 int mb_mbaff;
///< mb_aff_frame && mb_field_decoding_flag
355
357
358 // Weighted pred stuff
363 // The following 2 can be changed to int8_t but that causes 10cpu cycles speedloss
367
375
376 /**
377 * num_ref_idx_l0/1_active_minus1 + 1
378 */
379 unsigned int ref_count[2];
///< counts frames or fields, depending on current mb mode
383 * Reordered version of default_ref_list
384 * according to picture reordering in slice header */
385 int ref2frm[
MAX_SLICES][2][64];
///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
386
387 // data partitioning
392
393 DECLARE_ALIGNED(16,
DCTELEM,
mb)[16 * 48 * 2];
///< as a dct coeffecient is int32_t in high depth, we need to reserve twice the space.
395 DCTELEM mb_padding[256 * 2];
///< as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too large or ensure that there is some unused stuff after mb
396
397 /**
398 * Cabac
399 */
402
403 /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0, 1, 2), 0x0? luma_cbp */
408 /* chroma_pred_mode for i4x4 or i16x16, else 0 */
415
428
430
432
434
435 // deblock
439
440 // =============================================================
441 // Things below are not used in the MB or more inner code
442
447
448 /**
449 * Used to parse AVC variant of h264
450 */
451 int is_avc;
///< this flag is != 0 if codec is avc1
453 int got_first;
///< this flag is != 0 if we've parsed a frame
454
456
459
461
463
464 // POC stuff
470 int prev_poc_msb;
///< poc_msb of the last reference pic for POC type 0
471 int prev_poc_lsb;
///< poc_lsb of the last reference pic for POC type 0
475
476 /**
477 * frame_num for frames or 2 * frame_num + 1 for field pics.
478 */
480
481 /**
482 * max_frame_num or 2 * max_frame_num for field pics.
483 */
485
487
496
497 /**
498 * memory management control operations buffer.
499 */
503
506
508
509 /**
510 * @name Members for slice based multithreading
511 * @{
512 */
514
515 /**
516 * current slice number, used to initialize slice_num of each thread/context
517 */
519
520 /**
521 * Max number of threads / contexts.
522 * This is equal to AVCodecContext.thread_count unless
523 * multithreaded decoding is impossible, in which case it is
524 * reduced to 1.
525 */
527
528 /**
529 * 1 if the single thread fallback warning has already been
530 * displayed, 0 otherwise.
531 */
533
535 /** @} */
536
537 /**
538 * pic_struct in picture timing SEI message
539 */
541
542 /**
543 * Complement sei_pic_struct
544 * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames.
545 * However, soft telecined frames may have these values.
546 * This is used in an attempt to flag soft telecine progressive.
547 */
549
550 /**
551 * Bit set of clock types for fields/frames in picture timing SEI message.
552 * For each found ct_type, appropriate bit is set (e.g., bit 1 for
553 * interlaced).
554 */
556
557 /**
558 * dpb_output_delay in picture timing SEI message, see H.264 C.2.2
559 */
561
562 /**
563 * cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
564 */
566
567 /**
568 * recovery_frame_cnt from SEI message
569 *
570 * Set to -1 if no recovery point SEI message found or to number of frames
571 * before playback synchronizes. Frames having recovery point are key
572 * frames.
573 */
575 /**
576 * recovery_frame is the frame_num at which the next frame should
577 * be fully constructed.
578 *
579 * Set to -1 when not expecting a recovery point.
580 */
582
583 /**
584 * Are the SEI recovery points looking valid.
585 */
587
590
591 // Timestamp stuff
594
597
599
600 int sync;
///< did we had a keyframe or recovery point
601
606
609
610 /**
611 * Decode SEI
612 */
614
615 /**
616 * Decode SPS
617 */
619
620 /**
621 * compute profile from sps
622 */
624
625 /**
626 * Decode PPS
627 */
629
630 /**
631 * Decode a network abstraction layer unit.
632 * @param consumed is the number of bytes used as input
633 * @param length is the length of the array
634 * @param dst_length is the number of decoded bytes FIXME here
635 * or a decode rbsp tailing?
636 * @return decoded bytes, might be src+1 if no escapes
637 */
639 int *dst_length, int *consumed, int length);
640
641 /**
642 * Free any data that may have been allocated in the H264 context
643 * like SPS, PPS etc.
644 */
646
647 /**
648 * Reconstruct bitstream slice_type.
649 */
651
652 /**
653 * Allocate tables.
654 * needs width/height
655 */
657
658 /**
659 * Fill the default_ref_list.
660 */
662
666
667 /**
668 * Execute the reference picture marking (memory management control operations).
669 */
671
673 int first_slice);
674
676
677 /**
678 * Check if the top & left blocks are available if needed & change the
679 * dc mode so it only uses the available blocks.
680 */
682
683 /**
684 * Check if the top & left blocks are available if needed & change the
685 * dc mode so it only uses the available blocks.
686 */
688
694
695 /**
696 * Decode a macroblock
697 * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
698 */
700
701 /**
702 * Decode a CABAC coded macroblock
703 * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
704 */
706
708
712
715 unsigned int linesize, unsigned int uvlinesize);
718 unsigned int linesize, unsigned int uvlinesize);
719
720 /**
721 * Reset SEI values at the beginning of the frame.
722 *
723 * @param h H.264 context.
724 */
726
727 /*
728 * o-o o-o
729 * / / /
730 * o-o o-o
731 * ,---'
732 * o-o o-o
733 * / / /
734 * o-o o-o
735 */
736
737 /* Scan8 organization:
738 * 0 1 2 3 4 5 6 7
739 * 0 DY y y y y y
740 * 1 y Y Y Y Y
741 * 2 y Y Y Y Y
742 * 3 y Y Y Y Y
743 * 4 y Y Y Y Y
744 * 5 DU u u u u u
745 * 6 u U U U U
746 * 7 u U U U U
747 * 8 u U U U U
748 * 9 u U U U U
749 * 10 DV v v v v v
750 * 11 v V V V V
751 * 12 v V V V V
752 * 13 v V V V V
753 * 14 v V V V V
754 * DY/DU/DV are for luma/chroma DC.
755 */
756
757 #define LUMA_DC_BLOCK_INDEX 48
758 #define CHROMA_DC_BLOCK_INDEX 49
759
760 // This table must be here because scan8[constant] must be known at compiletime
762 4 + 1 * 8, 5 + 1 * 8, 4 + 2 * 8, 5 + 2 * 8,
763 6 + 1 * 8, 7 + 1 * 8, 6 + 2 * 8, 7 + 2 * 8,
764 4 + 3 * 8, 5 + 3 * 8, 4 + 4 * 8, 5 + 4 * 8,
765 6 + 3 * 8, 7 + 3 * 8, 6 + 4 * 8, 7 + 4 * 8,
766 4 + 6 * 8, 5 + 6 * 8, 4 + 7 * 8, 5 + 7 * 8,
767 6 + 6 * 8, 7 + 6 * 8, 6 + 7 * 8, 7 + 7 * 8,
768 4 + 8 * 8, 5 + 8 * 8, 4 + 9 * 8, 5 + 9 * 8,
769 6 + 8 * 8, 7 + 8 * 8, 6 + 9 * 8, 7 + 9 * 8,
770 4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8,
771 6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8,
772 4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8,
773 6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8,
774 0 + 0 * 8, 0 + 5 * 8, 0 + 10 * 8
775 };
776
778 {
779 #if HAVE_BIGENDIAN
780 return (b & 0xFFFF) + (a << 16);
781 #else
782 return (a & 0xFFFF) + (b << 16);
783 #endif
784 }
785
787 {
788 #if HAVE_BIGENDIAN
789 return (b & 0xFF) + (a << 8);
790 #else
791 return (a & 0xFF) + (b << 8);
792 #endif
793 }
794
795 /**
796 * Get the chroma qp.
797 */
799 {
801 }
802
803 /**
804 * Get the predicted intra4x4 prediction mode.
805 */
807 {
808 const int index8 =
scan8[n];
812
814
815 if (min < 0)
817 else
819 }
820
822 {
825
827 i4x4[4] = i4x4_cache[7 + 8 * 3];
828 i4x4[5] = i4x4_cache[7 + 8 * 2];
829 i4x4[6] = i4x4_cache[7 + 8 * 1];
830 }
831
833 {
837
838 AV_COPY32(&nnz[ 0], &nnz_cache[4 + 8 * 1]);
839 AV_COPY32(&nnz[ 4], &nnz_cache[4 + 8 * 2]);
840 AV_COPY32(&nnz[ 8], &nnz_cache[4 + 8 * 3]);
841 AV_COPY32(&nnz[12], &nnz_cache[4 + 8 * 4]);
842 AV_COPY32(&nnz[16], &nnz_cache[4 + 8 * 6]);
843 AV_COPY32(&nnz[20], &nnz_cache[4 + 8 * 7]);
844 AV_COPY32(&nnz[32], &nnz_cache[4 + 8 * 11]);
845 AV_COPY32(&nnz[36], &nnz_cache[4 + 8 * 12]);
846
848 AV_COPY32(&nnz[24], &nnz_cache[4 + 8 * 8]);
849 AV_COPY32(&nnz[28], &nnz_cache[4 + 8 * 9]);
850 AV_COPY32(&nnz[40], &nnz_cache[4 + 8 * 13]);
851 AV_COPY32(&nnz[44], &nnz_cache[4 + 8 * 14]);
852 }
853 }
854
858 int b_xy, int b8_xy,
859 int mb_type, int list)
860 {
863 AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0);
864 AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1);
865 AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2);
866 AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3);
873 } else {
875 AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8 * 0);
876 AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8 * 1);
877 AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8 * 2);
878 }
879 }
880
881 {
884 ref_index[0 + 0 * 2] = ref_cache[
scan8[0]];
885 ref_index[1 + 0 * 2] = ref_cache[scan8[4]];
886 ref_index[0 + 1 * 2] = ref_cache[scan8[8]];
887 ref_index[1 + 1 * 2] = ref_cache[scan8[12]];
888 }
889 }
890
892 {
896 const int b8_xy = 4 * h->
mb_xy;
897
900 } else {
903 }
906
913 }
914 }
915 }
916
918 {
922 0x0001000100010001ULL));
923 else
926 0x0001000100010001ULL));
927 }
928
929 #endif /* AVCODEC_H264_H */