| 1 |
|
| /* |
| 2 |
|
| * header.c |
| 3 |
|
| * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org> |
| 4 |
|
| * Copyright (C) 2003 Regis Duchesne <hpreg@zoy.org> |
| 5 |
|
| * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> |
| 6 |
|
| * |
| 7 |
|
| * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. |
| 8 |
|
| * See http://libmpeg2.sourceforge.net/ for updates. |
| 9 |
|
| * |
| 10 |
|
| * mpeg2dec is free software; you can redistribute it and/or modify |
| 11 |
|
| * it under the terms of the GNU General Public License as published by |
| 12 |
|
| * the Free Software Foundation; either version 2 of the License, or |
| 13 |
|
| * (at your option) any later version. |
| 14 |
|
| * |
| 15 |
|
| * mpeg2dec is distributed in the hope that it will be useful, |
| 16 |
|
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 |
|
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 |
|
| * GNU General Public License for more details. |
| 19 |
|
| * |
| 20 |
|
| * You should have received a copy of the GNU General Public License |
| 21 |
|
| * along with this program; if not, write to the Free Software |
| 22 |
|
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 23 |
|
| */ |
| 24 |
|
| |
| 25 |
|
| #include "config.h" |
| 26 |
|
| |
| 27 |
|
| #include <inttypes.h> |
| 28 |
|
| #include <stdlib.h> /* defines NULL */ |
| 29 |
|
| #include <string.h> /* memcmp */ |
| 30 |
|
| |
| 31 |
|
| #include "mpeg2.h" |
| 32 |
|
| #include "attributes.h" |
| 33 |
|
| #include "mpeg2_internal.h" |
| 34 |
|
| |
| 35 |
|
| #define SEQ_EXT 2 |
| 36 |
|
| #define SEQ_DISPLAY_EXT 4 |
| 37 |
|
| #define QUANT_MATRIX_EXT 8 |
| 38 |
|
| #define COPYRIGHT_EXT 0x10 |
| 39 |
|
| #define PIC_DISPLAY_EXT 0x80 |
| 40 |
|
| #define PIC_CODING_EXT 0x100 |
| 41 |
|
| |
| 42 |
|
| /* default intra quant matrix, in zig-zag order */ |
| 43 |
|
| static const uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) = { |
| 44 |
|
| 8, |
| 45 |
|
| 16, 16, |
| 46 |
|
| 19, 16, 19, |
| 47 |
|
| 22, 22, 22, 22, |
| 48 |
|
| 22, 22, 26, 24, 26, |
| 49 |
|
| 27, 27, 27, 26, 26, 26, |
| 50 |
|
| 26, 27, 27, 27, 29, 29, 29, |
| 51 |
|
| 34, 34, 34, 29, 29, 29, 27, 27, |
| 52 |
|
| 29, 29, 32, 32, 34, 34, 37, |
| 53 |
|
| 38, 37, 35, 35, 34, 35, |
| 54 |
|
| 38, 38, 40, 40, 40, |
| 55 |
|
| 48, 48, 46, 46, |
| 56 |
|
| 56, 56, 58, |
| 57 |
|
| 69, 69, |
| 58 |
|
| 83 |
| 59 |
|
| }; |
| 60 |
|
| |
| 61 |
|
| uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) = { |
| 62 |
|
| /* Zig-Zag scan pattern */ |
| 63 |
|
| 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, |
| 64 |
|
| 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, |
| 65 |
|
| 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, |
| 66 |
|
| 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63 |
| 67 |
|
| }; |
| 68 |
|
| |
| 69 |
|
| uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) = { |
| 70 |
|
| /* Alternate scan pattern */ |
| 71 |
|
| 0, 8, 16, 24, 1, 9, 2, 10, 17, 25, 32, 40, 48, 56, 57, 49, |
| 72 |
|
| 41, 33, 26, 18, 3, 11, 4, 12, 19, 27, 34, 42, 50, 58, 35, 43, |
| 73 |
|
| 51, 59, 20, 28, 5, 13, 6, 14, 21, 29, 36, 44, 52, 60, 37, 45, |
| 74 |
|
| 53, 61, 22, 30, 7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63 |
| 75 |
|
| }; |
| 76 |
|
| |
| 77 |
0 |
| void mpeg2_header_state_init (mpeg2dec_t * mpeg2dec) |
| 78 |
|
| { |
| 79 |
0 |
▶ | if (mpeg2dec->sequence.width != (unsigned)-1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->sequence.width != (unsigned)-1) { |
0 |
0 |
0 |
|
| 80 |
|
| int i; |
| 81 |
|
| |
| 82 |
0 |
| mpeg2dec->sequence.width = (unsigned)-1; |
| 83 |
0 |
▶ | if (!mpeg2dec->custom_fbuf) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!mpeg2dec->custom_fbuf) |
0 |
0 |
0 |
|
| 84 |
0 |
| for (i = mpeg2dec->alloc_index_user; |
| 85 |
0 |
▶ | i < mpeg2dec->alloc_index; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| i < mpeg2dec->alloc_index; i++) { |
0 |
0 |
0 |
|
| 86 |
0 |
| mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[0]); |
| 87 |
0 |
| mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[1]); |
| 88 |
0 |
| mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[2]); |
| 89 |
|
| } |
| 90 |
0 |
▶ | if (mpeg2dec->convert_start) |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->convert_start) |
0 |
0 |
0 |
|
| 91 |
0 |
▶ | for (i = 0; i < 3; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < 3; i++) { |
0 |
0 |
0 |
|
| 92 |
0 |
| mpeg2_free (mpeg2dec->yuv_buf[i][0]); |
| 93 |
0 |
| mpeg2_free (mpeg2dec->yuv_buf[i][1]); |
| 94 |
0 |
| mpeg2_free (mpeg2dec->yuv_buf[i][2]); |
| 95 |
|
| } |
| 96 |
0 |
▶ | if (mpeg2dec->decoder.convert_id) |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->decoder.convert_id) |
0 |
0 |
0 |
|
| 97 |
0 |
| mpeg2_free (mpeg2dec->decoder.convert_id); |
| 98 |
|
| } |
| 99 |
0 |
| mpeg2dec->decoder.coding_type = I_TYPE; |
| 100 |
0 |
| mpeg2dec->decoder.convert = NULL; |
| 101 |
0 |
| mpeg2dec->decoder.convert_id = NULL; |
| 102 |
0 |
| mpeg2dec->picture = mpeg2dec->pictures; |
| 103 |
0 |
| mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf; |
| 104 |
0 |
| mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf; |
| 105 |
0 |
| mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf; |
| 106 |
0 |
| mpeg2dec->first = 1; |
| 107 |
0 |
| mpeg2dec->alloc_index = 0; |
| 108 |
0 |
| mpeg2dec->alloc_index_user = 0; |
| 109 |
0 |
| mpeg2dec->first_decode_slice = 1; |
| 110 |
0 |
| mpeg2dec->nb_decode_slices = 0xb0 - 1; |
| 111 |
0 |
| mpeg2dec->convert = NULL; |
| 112 |
0 |
| mpeg2dec->convert_start = NULL; |
| 113 |
0 |
| mpeg2dec->custom_fbuf = 0; |
| 114 |
0 |
| mpeg2dec->yuv_index = 0; |
| 115 |
0 |
| } |
| 116 |
|
| |
| 117 |
0 |
| void mpeg2_reset_info (mpeg2_info_t * info) |
| 118 |
|
| { |
| 119 |
0 |
| info->current_picture = info->current_picture_2nd = NULL; |
| 120 |
0 |
| info->display_picture = info->display_picture_2nd = NULL; |
| 121 |
0 |
| info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL; |
| 122 |
0 |
| } |
| 123 |
|
| |
| 124 |
0 |
| static void info_user_data (mpeg2dec_t * mpeg2dec) |
| 125 |
|
| { |
| 126 |
0 |
▶ | if (mpeg2dec->user_data_len) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->user_data_len) { |
0 |
0 |
0 |
|
| 127 |
0 |
| mpeg2dec->info.user_data = mpeg2dec->chunk_buffer; |
| 128 |
0 |
| mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3; |
| 129 |
|
| } |
| 130 |
0 |
| } |
| 131 |
|
| |
| 132 |
0 |
| int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec) |
| 133 |
|
| { |
| 134 |
0 |
| uint8_t * buffer = mpeg2dec->chunk_start; |
| 135 |
0 |
| mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence); |
| 136 |
|
| static unsigned int frame_period[16] = { |
| 137 |
|
| 0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000, |
| 138 |
|
| /* unofficial: xing 15 fps */ |
| 139 |
|
| 1800000, |
| 140 |
|
| /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */ |
| 141 |
|
| 5400000, 2700000, 2250000, 1800000, 0, 0 |
| 142 |
|
| }; |
| 143 |
|
| int i; |
| 144 |
|
| |
| 145 |
0 |
▶ | if ((buffer[6] & 0x20) != 0x20) /* missing marker_bit */ |
Branch: 1 branch
| Branch | True | False | Total |
| if ((buffer[6] & 0x20) != 0x20) /* missing marker_bit */ |
0 |
0 |
0 |
|
| 146 |
0 |
| return 1; |
| 147 |
|
| |
| 148 |
0 |
| i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2]; |
| 149 |
0 |
▶ | if (! (sequence->display_width = sequence->picture_width = i >> 12)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (! (sequence->display_width = sequence->picture_width = i >> 12)) |
0 |
0 |
0 |
|
| 150 |
0 |
| return 1; |
| 151 |
0 |
▶ | if (! (sequence->display_height = sequence->picture_height = i & 0xfff)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (! (sequence->display_height = sequence->picture_height = i & 0xfff)) |
0 |
0 |
0 |
|
| 152 |
0 |
| return 1; |
| 153 |
0 |
| sequence->width = (sequence->picture_width + 15) & ~15; |
| 154 |
0 |
| sequence->height = (sequence->picture_height + 15) & ~15; |
| 155 |
0 |
| sequence->chroma_width = sequence->width >> 1; |
| 156 |
0 |
| sequence->chroma_height = sequence->height >> 1; |
| 157 |
|
| |
| 158 |
0 |
| sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE | |
| 159 |
|
| SEQ_VIDEO_FORMAT_UNSPECIFIED); |
| 160 |
|
| |
| 161 |
0 |
| sequence->pixel_width = buffer[3] >> 4; /* aspect ratio */ |
| 162 |
0 |
| sequence->frame_period = frame_period[buffer[3] & 15]; |
| 163 |
|
| |
| 164 |
0 |
| sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6); |
| 165 |
|
| |
| 166 |
0 |
| sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800; |
| 167 |
|
| |
| 168 |
0 |
▶ | if (buffer[7] & 4) |
Branch: 1 branch
| Branch | True | False | Total |
| if (buffer[7] & 4) |
0 |
0 |
0 |
|
| 169 |
0 |
| sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS; |
| 170 |
|
| |
| 171 |
0 |
| mpeg2dec->copy_matrix = 3; |
| 172 |
0 |
▶ | if (buffer[7] & 2) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (buffer[7] & 2) { |
0 |
0 |
0 |
|
| 173 |
0 |
▶ | for (i = 0; i < 64; i++) |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < 64; i++) |
0 |
0 |
0 |
|
| 174 |
0 |
| mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] = |
| 175 |
0 |
| (buffer[i+7] << 7) | (buffer[i+8] >> 1); |
| 176 |
0 |
| buffer += 64; |
| 177 |
|
| } else |
| 178 |
0 |
▶ | for (i = 0; i < 64; i++) |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < 64; i++) |
0 |
0 |
0 |
|
| 179 |
0 |
| mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] = |
| 180 |
0 |
| default_intra_quantizer_matrix[i]; |
| 181 |
|
| |
| 182 |
0 |
▶ | if (buffer[7] & 1) |
Branch: 1 branch
| Branch | True | False | Total |
| if (buffer[7] & 1) |
0 |
0 |
0 |
|
| 183 |
0 |
▶ | for (i = 0; i < 64; i++) |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < 64; i++) |
0 |
0 |
0 |
|
| 184 |
0 |
| mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] = |
| 185 |
0 |
| buffer[i+8]; |
| 186 |
|
| else |
| 187 |
0 |
| memset (mpeg2dec->new_quantizer_matrix[1], 16, 64); |
| 188 |
|
| |
| 189 |
0 |
| sequence->profile_level_id = 0x80; |
| 190 |
0 |
| sequence->colour_primaries = 0; |
| 191 |
0 |
| sequence->transfer_characteristics = 0; |
| 192 |
0 |
| sequence->matrix_coefficients = 0; |
| 193 |
|
| |
| 194 |
0 |
| mpeg2dec->ext_state = SEQ_EXT; |
| 195 |
0 |
| mpeg2dec->state = STATE_SEQUENCE; |
| 196 |
0 |
| mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0; |
| 197 |
|
| |
| 198 |
0 |
| return 0; |
| 199 |
|
| } |
| 200 |
|
| |
| 201 |
0 |
| static int sequence_ext (mpeg2dec_t * mpeg2dec) |
| 202 |
|
| { |
| 203 |
0 |
| uint8_t * buffer = mpeg2dec->chunk_start; |
| 204 |
0 |
| mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence); |
| 205 |
|
| uint32_t flags; |
| 206 |
|
| |
| 207 |
0 |
▶ | if (!(buffer[3] & 1)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(buffer[3] & 1)) |
0 |
0 |
0 |
|
| 208 |
0 |
| return 1; |
| 209 |
|
| |
| 210 |
0 |
| sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4); |
| 211 |
|
| |
| 212 |
0 |
| sequence->display_width = sequence->picture_width += |
| 213 |
0 |
| ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000; |
| 214 |
0 |
| sequence->display_height = sequence->picture_height += |
| 215 |
0 |
| (buffer[2] << 7) & 0x3000; |
| 216 |
0 |
| sequence->width = (sequence->picture_width + 15) & ~15; |
| 217 |
0 |
| sequence->height = (sequence->picture_height + 15) & ~15; |
| 218 |
0 |
| flags = sequence->flags | SEQ_FLAG_MPEG2; |
| 219 |
0 |
▶ | if (!(buffer[1] & 8)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(buffer[1] & 8)) { |
0 |
0 |
0 |
|
| 220 |
0 |
| flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE; |
| 221 |
0 |
| sequence->height = (sequence->height + 31) & ~31; |
| 222 |
|
| } |
| 223 |
0 |
▶ | if (buffer[5] & 0x80) |
Branch: 1 branch
| Branch | True | False | Total |
| if (buffer[5] & 0x80) |
0 |
0 |
0 |
|
| 224 |
0 |
| flags |= SEQ_FLAG_LOW_DELAY; |
| 225 |
0 |
| sequence->flags = flags; |
| 226 |
0 |
| sequence->chroma_width = sequence->width; |
| 227 |
0 |
| sequence->chroma_height = sequence->height; |
| 228 |
0 |
| switch (buffer[1] & 6) { |
| 229 |
0 |
| case 0: /* invalid */ |
| 230 |
0 |
| return 1; |
| 231 |
0 |
| case 2: /* 4:2:0 */ |
| 232 |
0 |
| sequence->chroma_height >>= 1; |
| 233 |
0 |
| case 4: /* 4:2:2 */ |
| 234 |
0 |
| sequence->chroma_width >>= 1; |
| 235 |
|
| } |
| 236 |
|
| |
| 237 |
0 |
| sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000; |
| 238 |
|
| |
| 239 |
0 |
| sequence->vbv_buffer_size |= buffer[4] << 21; |
| 240 |
|
| |
| 241 |
0 |
| sequence->frame_period = |
| 242 |
0 |
| sequence->frame_period * ((buffer[5]&31)+1) / (((buffer[5]>>5)&3)+1); |
| 243 |
|
| |
| 244 |
0 |
| mpeg2dec->ext_state = SEQ_DISPLAY_EXT; |
| 245 |
|
| |
| 246 |
0 |
| return 0; |
| 247 |
|
| } |
| 248 |
|
| |
| 249 |
0 |
| static int sequence_display_ext (mpeg2dec_t * mpeg2dec) |
| 250 |
|
| { |
| 251 |
0 |
| uint8_t * buffer = mpeg2dec->chunk_start; |
| 252 |
0 |
| mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence); |
| 253 |
|
| |
| 254 |
0 |
| sequence->flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) | |
| 255 |
0 |
| ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT)); |
| 256 |
0 |
▶ | if (buffer[0] & 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (buffer[0] & 1) { |
0 |
0 |
0 |
|
| 257 |
0 |
| sequence->flags |= SEQ_FLAG_COLOUR_DESCRIPTION; |
| 258 |
0 |
| sequence->colour_primaries = buffer[1]; |
| 259 |
0 |
| sequence->transfer_characteristics = buffer[2]; |
| 260 |
0 |
| sequence->matrix_coefficients = buffer[3]; |
| 261 |
0 |
| buffer += 3; |
| 262 |
|
| } |
| 263 |
|
| |
| 264 |
0 |
▶ | if (!(buffer[2] & 2)) /* missing marker_bit */ |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(buffer[2] & 2)) /* missing marker_bit */ |
0 |
0 |
0 |
|
| 265 |
0 |
| return 1; |
| 266 |
|
| |
| 267 |
0 |
▶ | if( (buffer[1] << 6) | (buffer[2] >> 2) ) |
Branch: 1 branch
| Branch | True | False | Total |
| if( (buffer[1] << 6) | (buffer[2] >> 2) ) |
0 |
0 |
0 |
|
| 268 |
0 |
| sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2); |
| 269 |
0 |
▶ | if( ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3) ) |
Branch: 1 branch
| Branch | True | False | Total |
| if( ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3) ) |
0 |
0 |
0 |
|
| 270 |
0 |
| sequence->display_height = |
| 271 |
0 |
| ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3); |
| 272 |
|
| |
| 273 |
0 |
| return 0; |
| 274 |
|
| } |
| 275 |
|
| |
| 276 |
0 |
| static inline void simplify (unsigned int * u, unsigned int * v) |
| 277 |
|
| { |
| 278 |
|
| unsigned int a, b, tmp; |
| 279 |
|
| |
| 280 |
0 |
| a = *u; b = *v; |
| 281 |
0 |
▶ | while (a) { /* find greatest common divisor */ |
Branch: 1 branch
| Branch | True | False | Total |
| while (a) { /* find greatest common divisor */ |
0 |
0 |
0 |
|
| 282 |
0 |
| tmp = a; a = b % tmp; b = tmp; |
| 283 |
|
| } |
| 284 |
0 |
| *u /= b; *v /= b; |
| 285 |
0 |
| } |
| 286 |
|
| |
| 287 |
0 |
| static inline void finalize_sequence (mpeg2_sequence_t * sequence) |
| 288 |
|
| { |
| 289 |
|
| int width; |
| 290 |
|
| int height; |
| 291 |
|
| |
| 292 |
0 |
| sequence->byte_rate *= 50; |
| 293 |
|
| |
| 294 |
0 |
▶ | if (sequence->flags & SEQ_FLAG_MPEG2) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (sequence->flags & SEQ_FLAG_MPEG2) { |
0 |
0 |
0 |
|
| 295 |
0 |
| switch (sequence->pixel_width) { |
| 296 |
0 |
| case 1: /* square pixels */ |
| 297 |
0 |
| sequence->pixel_width = sequence->pixel_height = 1; return; |
| 298 |
0 |
| case 2: /* 4:3 aspect ratio */ |
| 299 |
0 |
| width = 4; height = 3; break; |
| 300 |
0 |
| case 3: /* 16:9 aspect ratio */ |
| 301 |
0 |
| width = 16; height = 9; break; |
| 302 |
0 |
| case 4: /* 2.21:1 aspect ratio */ |
| 303 |
0 |
| width = 221; height = 100; break; |
| 304 |
0 |
| default: /* illegal */ |
| 305 |
0 |
| sequence->pixel_width = sequence->pixel_height = 0; return; |
| 306 |
|
| } |
| 307 |
0 |
| width *= sequence->display_height; |
| 308 |
0 |
| height *= sequence->display_width; |
| 309 |
|
| |
| 310 |
|
| } else { |
| 311 |
0 |
▶ | if (sequence->byte_rate == 50 * 0x3ffff) |
Branch: 1 branch
| Branch | True | False | Total |
| if (sequence->byte_rate == 50 * 0x3ffff) |
0 |
0 |
0 |
|
| 312 |
0 |
| sequence->byte_rate = 0; /* mpeg-1 VBR */ |
| 313 |
|
| |
| 314 |
0 |
| switch (sequence->pixel_width) { |
| 315 |
0 |
| case 0: case 15: /* illegal */ |
| 316 |
0 |
| sequence->pixel_width = sequence->pixel_height = 0; return; |
| 317 |
0 |
| case 1: /* square pixels */ |
| 318 |
0 |
| sequence->pixel_width = sequence->pixel_height = 1; return; |
| 319 |
0 |
| case 3: /* 720x576 16:9 */ |
| 320 |
0 |
| sequence->pixel_width = 64; sequence->pixel_height = 45; return; |
| 321 |
0 |
| case 6: /* 720x480 16:9 */ |
| 322 |
0 |
| sequence->pixel_width = 32; sequence->pixel_height = 27; return; |
| 323 |
0 |
| case 8: /* BT.601 625 lines 4:3 */ |
| 324 |
0 |
| sequence->pixel_width = 59; sequence->pixel_height = 54; return; |
| 325 |
0 |
| case 12: /* BT.601 525 lines 4:3 */ |
| 326 |
0 |
| sequence->pixel_width = 10; sequence->pixel_height = 11; return; |
| 327 |
0 |
| default: |
| 328 |
0 |
| height = 88 * sequence->pixel_width + 1171; |
| 329 |
0 |
| width = 2000; |
| 330 |
|
| } |
| 331 |
|
| } |
| 332 |
|
| |
| 333 |
0 |
| sequence->pixel_width = width; |
| 334 |
0 |
| sequence->pixel_height = height; |
| 335 |
0 |
| simplify (&sequence->pixel_width, &sequence->pixel_height); |
| 336 |
|
| } |
| 337 |
|
| |
| 338 |
0 |
| int mpeg2_guess_aspect (const mpeg2_sequence_t * sequence, |
| 339 |
|
| unsigned int * pixel_width, |
| 340 |
|
| unsigned int * pixel_height) |
| 341 |
|
| { |
| 342 |
|
| static struct { |
| 343 |
|
| unsigned int width, height; |
| 344 |
|
| } video_modes[] = { |
| 345 |
|
| {720, 576}, /* 625 lines, 13.5 MHz (D1, DV, DVB, DVD) */ |
| 346 |
|
| {704, 576}, /* 625 lines, 13.5 MHz (1/1 D1, DVB, DVD, 4CIF) */ |
| 347 |
|
| {544, 576}, /* 625 lines, 10.125 MHz (DVB, laserdisc) */ |
| 348 |
|
| {528, 576}, /* 625 lines, 10.125 MHz (3/4 D1, DVB, laserdisc) */ |
| 349 |
|
| {480, 576}, /* 625 lines, 9 MHz (2/3 D1, DVB, SVCD) */ |
| 350 |
|
| {352, 576}, /* 625 lines, 6.75 MHz (D2, 1/2 D1, CVD, DVB, DVD) */ |
| 351 |
|
| {352, 288}, /* 625 lines, 6.75 MHz, 1 field (D4, VCD, DVB, DVD, CIF) */ |
| 352 |
|
| {176, 144}, /* 625 lines, 3.375 MHz, half field (QCIF) */ |
| 353 |
|
| {720, 486}, /* 525 lines, 13.5 MHz (D1) */ |
| 354 |
|
| {704, 486}, /* 525 lines, 13.5 MHz */ |
| 355 |
|
| {720, 480}, /* 525 lines, 13.5 MHz (DV, DSS, DVD) */ |
| 356 |
|
| {704, 480}, /* 525 lines, 13.5 MHz (1/1 D1, ATSC, DVD) */ |
| 357 |
|
| {544, 480}, /* 525 lines. 10.125 MHz (DSS, laserdisc) */ |
| 358 |
|
| {528, 480}, /* 525 lines. 10.125 MHz (3/4 D1, laserdisc) */ |
| 359 |
|
| {480, 480}, /* 525 lines, 9 MHz (2/3 D1, SVCD) */ |
| 360 |
|
| {352, 480}, /* 525 lines, 6.75 MHz (D2, 1/2 D1, CVD, DVD) */ |
| 361 |
|
| {352, 240} /* 525 lines. 6.75 MHz, 1 field (D4, VCD, DSS, DVD) */ |
| 362 |
|
| }; |
| 363 |
|
| unsigned int width, height, pix_width, pix_height, i, DAR_16_9; |
| 364 |
|
| |
| 365 |
0 |
| *pixel_width = sequence->pixel_width; |
| 366 |
0 |
| *pixel_height = sequence->pixel_height; |
| 367 |
0 |
| width = sequence->picture_width; |
| 368 |
0 |
| height = sequence->picture_height; |
| 369 |
0 |
▶ | for (i = 0; i < sizeof (video_modes) / sizeof (video_modes[0]); i++) |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < sizeof (video_modes) / sizeof (video_modes[0]); i++) |
0 |
0 |
0 |
|
| 370 |
0 |
▶ | if (width == video_modes[i].width && height == video_modes[i].height) |
Branch: 2 branches
| Branch | True | False | Total |
| if (width == video_modes[i].width && height == video_modes[i].height) |
0 |
0 |
0 |
| if (width == video_modes[i].width && height == video_modes[i].height) |
0 |
0 |
0 |
|
| 371 |
0 |
| break; |
| 372 |
0 |
▶ | if (i == sizeof (video_modes) / sizeof (video_modes[0]) || |
Branch: 1 branch
| Branch | True | False | Total |
| if (i == sizeof (video_modes) / sizeof (video_modes[0]) || |
0 |
0 |
0 |
|
| 373 |
0 |
▶ | (sequence->pixel_width == 1 && sequence->pixel_height == 1) || |
Branch: 2 branches
| Branch | True | False | Total |
| (sequence->pixel_width == 1 && sequence->pixel_height == 1) || |
0 |
0 |
0 |
| (sequence->pixel_width == 1 && sequence->pixel_height == 1) || |
0 |
0 |
0 |
|
| 374 |
0 |
▶ | width != sequence->display_width || height != sequence->display_height) |
Branch: 2 branches
| Branch | True | False | Total |
| width != sequence->display_width || height != sequence->display_height) |
0 |
0 |
0 |
| width != sequence->display_width || height != sequence->display_height) |
0 |
0 |
0 |
|
| 375 |
0 |
| return 0; |
| 376 |
|
| |
| 377 |
0 |
▶ | for (pix_height = 1; height * pix_height < 480; pix_height <<= 1); |
Branch: 1 branch
| Branch | True | False | Total |
| for (pix_height = 1; height * pix_height < 480; pix_height <<= 1); |
0 |
0 |
0 |
|
| 378 |
0 |
| height *= pix_height; |
| 379 |
0 |
▶ | for (pix_width = 1; width * pix_width <= 352; pix_width <<= 1); |
Branch: 1 branch
| Branch | True | False | Total |
| for (pix_width = 1; width * pix_width <= 352; pix_width <<= 1); |
0 |
0 |
0 |
|
| 380 |
0 |
| width *= pix_width; |
| 381 |
|
| |
| 382 |
0 |
▶ | if (! (sequence->flags & SEQ_FLAG_MPEG2)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (! (sequence->flags & SEQ_FLAG_MPEG2)) { |
0 |
0 |
0 |
|
| 383 |
|
| static unsigned int mpeg1_check[2][2] = {{11, 54}, {27, 45}}; |
| 384 |
0 |
▶ | DAR_16_9 = (sequence->pixel_height == 27 || |
Branch: 1 branch
| Branch | True | False | Total |
| DAR_16_9 = (sequence->pixel_height == 27 || |
0 |
0 |
0 |
|
| 385 |
0 |
▶ | sequence->pixel_height == 45); |
Branch: 1 branch
| Branch | True | False | Total |
| sequence->pixel_height == 45); |
0 |
0 |
0 |
|
| 386 |
0 |
▶ | if (width < 704 || |
Branch: 1 branch
| Branch | True | False | Total |
| if (width < 704 || |
0 |
0 |
0 |
|
| 387 |
0 |
▶ | sequence->pixel_height != mpeg1_check[DAR_16_9][height == 576]) |
Branch: 1 branch
| Branch | True | False | Total |
| sequence->pixel_height != mpeg1_check[DAR_16_9][height == 576]) |
0 |
0 |
0 |
|
| 388 |
0 |
| return 0; |
| 389 |
|
| } else { |
| 390 |
0 |
| DAR_16_9 = (3 * sequence->picture_width * sequence->pixel_width > |
| 391 |
0 |
| 4 * sequence->picture_height * sequence->pixel_height); |
| 392 |
0 |
| switch (width) { |
| 393 |
0 |
| case 528: case 544: pix_width *= 4; pix_height *= 3; break; |
| 394 |
0 |
| case 480: pix_width *= 3; pix_height *= 2; break; |
| 395 |
|
| } |
| 396 |
|
| } |
| 397 |
0 |
▶ | if (DAR_16_9) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (DAR_16_9) { |
0 |
0 |
0 |
|
| 398 |
0 |
| pix_width *= 4; pix_height *= 3; |
| 399 |
|
| } |
| 400 |
0 |
▶ | if (height == 576) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (height == 576) { |
0 |
0 |
0 |
|
| 401 |
0 |
| pix_width *= 59; pix_height *= 54; |
| 402 |
|
| } else { |
| 403 |
0 |
| pix_width *= 10; pix_height *= 11; |
| 404 |
|
| } |
| 405 |
0 |
| *pixel_width = pix_width; |
| 406 |
0 |
| *pixel_height = pix_height; |
| 407 |
0 |
| simplify (pixel_width, pixel_height); |
| 408 |
0 |
▶ | return (height == 576) ? 1 : 2; |
Branch: 1 branch
| Branch | True | False | Total |
| return (height == 576) ? 1 : 2; |
0 |
0 |
0 |
|
| 409 |
|
| } |
| 410 |
|
| |
| 411 |
0 |
| static void copy_matrix (mpeg2dec_t * mpeg2dec, int idx) |
| 412 |
|
| { |
| 413 |
0 |
| if (memcmp (mpeg2dec->quantizer_matrix[idx], |
| 414 |
0 |
▶ | mpeg2dec->new_quantizer_matrix[idx], 64)) { |
Branch: 1 branch
| Branch | True | False | Total |
| mpeg2dec->new_quantizer_matrix[idx], 64)) { |
0 |
0 |
0 |
|
| 415 |
0 |
| memcpy (mpeg2dec->quantizer_matrix[idx], |
| 416 |
0 |
| mpeg2dec->new_quantizer_matrix[idx], 64); |
| 417 |
0 |
| mpeg2dec->scaled[idx] = -1; |
| 418 |
|
| } |
| 419 |
0 |
| } |
| 420 |
|
| |
| 421 |
0 |
| static void finalize_matrix (mpeg2dec_t * mpeg2dec) |
| 422 |
|
| { |
| 423 |
0 |
| mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); |
| 424 |
|
| int i; |
| 425 |
|
| |
| 426 |
0 |
▶ | for (i = 0; i < 2; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < 2; i++) { |
0 |
0 |
0 |
|
| 427 |
0 |
▶ | if (mpeg2dec->copy_matrix & (1 << i)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->copy_matrix & (1 << i)) |
0 |
0 |
0 |
|
| 428 |
0 |
| copy_matrix (mpeg2dec, i); |
| 429 |
0 |
▶ | if ((mpeg2dec->copy_matrix & (4 << i)) && |
Branch: 1 branch
| Branch | True | False | Total |
| if ((mpeg2dec->copy_matrix & (4 << i)) && |
0 |
0 |
0 |
|
| 430 |
0 |
| memcmp (mpeg2dec->quantizer_matrix[i], |
| 431 |
0 |
▶ | mpeg2dec->new_quantizer_matrix[i+2], 64)) { |
Branch: 1 branch
| Branch | True | False | Total |
| mpeg2dec->new_quantizer_matrix[i+2], 64)) { |
0 |
0 |
0 |
|
| 432 |
0 |
| copy_matrix (mpeg2dec, i + 2); |
| 433 |
0 |
| decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2]; |
| 434 |
0 |
▶ | } else if (mpeg2dec->copy_matrix & (5 << i)) |
Branch: 1 branch
| Branch | True | False | Total |
| } else if (mpeg2dec->copy_matrix & (5 << i)) |
0 |
0 |
0 |
|
| 435 |
0 |
| decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i]; |
| 436 |
|
| } |
| 437 |
0 |
| } |
| 438 |
|
| |
| 439 |
0 |
| static mpeg2_state_t invalid_end_action (mpeg2dec_t * mpeg2dec) |
| 440 |
|
| { |
| 441 |
0 |
| mpeg2_reset_info (&(mpeg2dec->info)); |
| 442 |
0 |
| mpeg2dec->info.gop = NULL; |
| 443 |
0 |
| info_user_data (mpeg2dec); |
| 444 |
0 |
| mpeg2_header_state_init (mpeg2dec); |
| 445 |
0 |
| mpeg2dec->sequence = mpeg2dec->new_sequence; |
| 446 |
0 |
| mpeg2dec->action = mpeg2_seek_header; |
| 447 |
0 |
| mpeg2dec->state = STATE_SEQUENCE; |
| 448 |
0 |
| return STATE_SEQUENCE; |
| 449 |
|
| } |
| 450 |
|
| |
| 451 |
0 |
| void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec) |
| 452 |
|
| { |
| 453 |
0 |
| mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence); |
| 454 |
0 |
| mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); |
| 455 |
|
| |
| 456 |
0 |
| finalize_sequence (sequence); |
| 457 |
0 |
| finalize_matrix (mpeg2dec); |
| 458 |
|
| |
| 459 |
0 |
| decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2); |
| 460 |
0 |
| decoder->width = sequence->width; |
| 461 |
0 |
| decoder->height = sequence->height; |
| 462 |
0 |
| decoder->vertical_position_extension = (sequence->picture_height > 2800); |
| 463 |
0 |
| decoder->chroma_format = ((sequence->chroma_width == sequence->width) + |
| 464 |
0 |
| (sequence->chroma_height == sequence->height)); |
| 465 |
|
| |
| 466 |
0 |
▶ | if (mpeg2dec->sequence.width != (unsigned)-1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->sequence.width != (unsigned)-1) { |
0 |
0 |
0 |
|
| 467 |
|
| /* |
| 468 |
|
| * According to 6.1.1.6, repeat sequence headers should be |
| 469 |
|
| * identical to the original. However some encoders do not |
| 470 |
|
| * respect that and change various fields (including bitrate |
| 471 |
|
| * and aspect ratio) in the repeat sequence headers. So we |
| 472 |
|
| * choose to be as conservative as possible and only restart |
| 473 |
|
| * the decoder if the width, height, chroma_width, |
| 474 |
|
| * chroma_height or low_delay flag are modified. |
| 475 |
|
| */ |
| 476 |
0 |
▶ | if (sequence->width != mpeg2dec->sequence.width || |
Branch: 1 branch
| Branch | True | False | Total |
| if (sequence->width != mpeg2dec->sequence.width || |
0 |
0 |
0 |
|
| 477 |
0 |
▶ | sequence->height != mpeg2dec->sequence.height || |
Branch: 1 branch
| Branch | True | False | Total |
| sequence->height != mpeg2dec->sequence.height || |
0 |
0 |
0 |
|
| 478 |
0 |
▶ | sequence->chroma_width != mpeg2dec->sequence.chroma_width || |
Branch: 1 branch
| Branch | True | False | Total |
| sequence->chroma_width != mpeg2dec->sequence.chroma_width || |
0 |
0 |
0 |
|
| 479 |
0 |
▶ | sequence->chroma_height != mpeg2dec->sequence.chroma_height || |
Branch: 1 branch
| Branch | True | False | Total |
| sequence->chroma_height != mpeg2dec->sequence.chroma_height || |
0 |
0 |
0 |
|
| 480 |
0 |
▶ | ((sequence->flags ^ mpeg2dec->sequence.flags) & |
Branch: 1 branch
| Branch | True | False | Total |
| ((sequence->flags ^ mpeg2dec->sequence.flags) & |
0 |
0 |
0 |
|
| 481 |
|
| SEQ_FLAG_LOW_DELAY)) { |
| 482 |
0 |
| decoder->stride_frame = sequence->width; |
| 483 |
0 |
| mpeg2_header_end (mpeg2dec); |
| 484 |
0 |
| mpeg2dec->action = invalid_end_action; |
| 485 |
0 |
| mpeg2dec->state = STATE_INVALID_END; |
| 486 |
0 |
| return; |
| 487 |
|
| } |
| 488 |
0 |
| mpeg2dec->state = (memcmp (&(mpeg2dec->sequence), sequence, |
| 489 |
|
| sizeof (mpeg2_sequence_t)) ? |
| 490 |
0 |
▶ | STATE_SEQUENCE_MODIFIED : STATE_SEQUENCE_REPEATED); |
Branch: 1 branch
| Branch | True | False | Total |
| STATE_SEQUENCE_MODIFIED : STATE_SEQUENCE_REPEATED); |
0 |
0 |
0 |
|
| 491 |
|
| } else |
| 492 |
0 |
| decoder->stride_frame = sequence->width; |
| 493 |
0 |
| mpeg2dec->sequence = *sequence; |
| 494 |
0 |
| mpeg2_reset_info (&(mpeg2dec->info)); |
| 495 |
0 |
| mpeg2dec->info.sequence = &(mpeg2dec->sequence); |
| 496 |
0 |
| mpeg2dec->info.gop = NULL; |
| 497 |
0 |
| info_user_data (mpeg2dec); |
| 498 |
|
| } |
| 499 |
|
| |
| 500 |
0 |
| int mpeg2_header_gop (mpeg2dec_t * mpeg2dec) |
| 501 |
|
| { |
| 502 |
0 |
| uint8_t * buffer = mpeg2dec->chunk_start; |
| 503 |
0 |
| mpeg2_gop_t * gop = &(mpeg2dec->new_gop); |
| 504 |
|
| |
| 505 |
0 |
▶ | if (! (buffer[1] & 8)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (! (buffer[1] & 8)) |
0 |
0 |
0 |
|
| 506 |
0 |
| return 1; |
| 507 |
0 |
| gop->hours = (buffer[0] >> 2) & 31; |
| 508 |
0 |
| gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63; |
| 509 |
0 |
| gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63; |
| 510 |
0 |
| gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63; |
| 511 |
0 |
| gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6); |
| 512 |
0 |
| mpeg2dec->state = STATE_GOP; |
| 513 |
0 |
| return 0; |
| 514 |
|
| } |
| 515 |
|
| |
| 516 |
0 |
| void mpeg2_header_gop_finalize (mpeg2dec_t * mpeg2dec) |
| 517 |
|
| { |
| 518 |
0 |
| mpeg2dec->gop = mpeg2dec->new_gop; |
| 519 |
0 |
| mpeg2_reset_info (&(mpeg2dec->info)); |
| 520 |
0 |
| mpeg2dec->info.gop = &(mpeg2dec->gop); |
| 521 |
0 |
| info_user_data (mpeg2dec); |
| 522 |
0 |
| } |
| 523 |
|
| |
| 524 |
0 |
| void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int b_type) |
| 525 |
|
| { |
| 526 |
|
| int i; |
| 527 |
|
| |
| 528 |
0 |
▶ | for (i = 0; i < 3; i++) |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < 3; i++) |
0 |
0 |
0 |
|
| 529 |
0 |
▶ | if (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf && |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf && |
0 |
0 |
0 |
|
| 530 |
0 |
▶ | mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) { |
Branch: 1 branch
| Branch | True | False | Total |
| mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) { |
0 |
0 |
0 |
|
| 531 |
0 |
| mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf; |
| 532 |
0 |
| mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0]; |
| 533 |
0 |
▶ | if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { |
Branch: 2 branches
| Branch | True | False | Total |
| if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { |
0 |
0 |
0 |
| if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { |
0 |
0 |
0 |
|
| 534 |
0 |
▶ | if (b_type || mpeg2dec->convert) |
Branch: 2 branches
| Branch | True | False | Total |
| if (b_type || mpeg2dec->convert) |
0 |
0 |
0 |
| if (b_type || mpeg2dec->convert) |
0 |
0 |
0 |
|
| 535 |
0 |
| mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0]; |
| 536 |
0 |
| mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; |
| 537 |
|
| } |
| 538 |
0 |
| break; |
| 539 |
|
| } |
| 540 |
0 |
| } |
| 541 |
|
| |
| 542 |
0 |
| int mpeg2_header_picture (mpeg2dec_t * mpeg2dec) |
| 543 |
|
| { |
| 544 |
0 |
| uint8_t * buffer = mpeg2dec->chunk_start; |
| 545 |
0 |
| mpeg2_picture_t * picture = &(mpeg2dec->new_picture); |
| 546 |
0 |
| mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); |
| 547 |
|
| int type; |
| 548 |
|
| |
| 549 |
0 |
| mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ? |
| 550 |
0 |
▶ | STATE_PICTURE : STATE_PICTURE_2ND); |
Branch: 1 branch
| Branch | True | False | Total |
| STATE_PICTURE : STATE_PICTURE_2ND); |
0 |
0 |
0 |
|
| 551 |
0 |
| mpeg2dec->ext_state = PIC_CODING_EXT; |
| 552 |
|
| |
| 553 |
0 |
| picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6); |
| 554 |
|
| |
| 555 |
0 |
| type = (buffer [1] >> 3) & 7; |
| 556 |
0 |
▶ | if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) { |
Branch: 2 branches
| Branch | True | False | Total |
| if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) { |
0 |
0 |
0 |
| if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) { |
0 |
0 |
0 |
|
| 557 |
|
| /* forward_f_code and backward_f_code - used in mpeg1 only */ |
| 558 |
0 |
| decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1; |
| 559 |
0 |
| decoder->f_motion.f_code[0] = |
| 560 |
0 |
| (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1; |
| 561 |
0 |
| decoder->b_motion.f_code[1] = (buffer[4] >> 6) & 1; |
| 562 |
0 |
| decoder->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1; |
| 563 |
|
| } |
| 564 |
|
| |
| 565 |
0 |
| picture->flags = PIC_FLAG_PROGRESSIVE_FRAME | type; |
| 566 |
0 |
| picture->tag = picture->tag2 = 0; |
| 567 |
0 |
▶ | if (mpeg2dec->num_tags) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->num_tags) { |
0 |
0 |
0 |
|
| 568 |
0 |
▶ | if (mpeg2dec->bytes_since_tag >= mpeg2dec->chunk_ptr - buffer + 4) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->bytes_since_tag >= mpeg2dec->chunk_ptr - buffer + 4) { |
0 |
0 |
0 |
|
| 569 |
0 |
| mpeg2dec->num_tags = 0; |
| 570 |
0 |
| picture->tag = mpeg2dec->tag_current; |
| 571 |
0 |
| picture->tag2 = mpeg2dec->tag2_current; |
| 572 |
0 |
| picture->flags |= PIC_FLAG_TAGS; |
| 573 |
0 |
▶ | } else if (mpeg2dec->num_tags > 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| } else if (mpeg2dec->num_tags > 1) { |
0 |
0 |
0 |
|
| 574 |
0 |
| mpeg2dec->num_tags = 1; |
| 575 |
0 |
| picture->tag = mpeg2dec->tag_previous; |
| 576 |
0 |
| picture->tag2 = mpeg2dec->tag2_previous; |
| 577 |
0 |
| picture->flags |= PIC_FLAG_TAGS; |
| 578 |
|
| } |
| 579 |
|
| } |
| 580 |
0 |
| picture->nb_fields = 2; |
| 581 |
0 |
| picture->display_offset[0].x = picture->display_offset[1].x = |
| 582 |
0 |
| picture->display_offset[2].x = mpeg2dec->display_offset_x; |
| 583 |
0 |
| picture->display_offset[0].y = picture->display_offset[1].y = |
| 584 |
0 |
| picture->display_offset[2].y = mpeg2dec->display_offset_y; |
| 585 |
|
| |
| 586 |
|
| /* XXXXXX decode extra_information_picture as well */ |
| 587 |
|
| |
| 588 |
0 |
| decoder->q_scale_type = 0; |
| 589 |
0 |
| decoder->intra_dc_precision = 7; |
| 590 |
0 |
| decoder->frame_pred_frame_dct = 1; |
| 591 |
0 |
| decoder->concealment_motion_vectors = 0; |
| 592 |
0 |
| decoder->scan = mpeg2_scan_norm; |
| 593 |
0 |
| decoder->picture_structure = FRAME_PICTURE; |
| 594 |
0 |
| mpeg2dec->copy_matrix = 0; |
| 595 |
|
| |
| 596 |
0 |
| return 0; |
| 597 |
|
| } |
| 598 |
|
| |
| 599 |
0 |
| static int picture_coding_ext (mpeg2dec_t * mpeg2dec) |
| 600 |
|
| { |
| 601 |
0 |
| uint8_t * buffer = mpeg2dec->chunk_start; |
| 602 |
0 |
| mpeg2_picture_t * picture = &(mpeg2dec->new_picture); |
| 603 |
0 |
| mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); |
| 604 |
|
| uint32_t flags; |
| 605 |
|
| |
| 606 |
|
| /* pre subtract 1 for use later in compute_motion_vector */ |
| 607 |
0 |
| decoder->f_motion.f_code[0] = (buffer[0] & 15) - 1; |
| 608 |
0 |
| decoder->f_motion.f_code[1] = (buffer[1] >> 4) - 1; |
| 609 |
0 |
| decoder->b_motion.f_code[0] = (buffer[1] & 15) - 1; |
| 610 |
0 |
| decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1; |
| 611 |
|
| |
| 612 |
0 |
| flags = picture->flags; |
| 613 |
0 |
| decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3); |
| 614 |
0 |
| decoder->picture_structure = buffer[2] & 3; |
| 615 |
0 |
| switch (decoder->picture_structure) { |
| 616 |
0 |
| case TOP_FIELD: |
| 617 |
0 |
| flags |= PIC_FLAG_TOP_FIELD_FIRST; |
| 618 |
0 |
| case BOTTOM_FIELD: |
| 619 |
0 |
| picture->nb_fields = 1; |
| 620 |
0 |
| break; |
| 621 |
0 |
| case FRAME_PICTURE: |
| 622 |
0 |
▶ | if (!(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)) { |
0 |
0 |
0 |
|
| 623 |
0 |
▶ | picture->nb_fields = (buffer[3] & 2) ? 3 : 2; |
Branch: 1 branch
| Branch | True | False | Total |
| picture->nb_fields = (buffer[3] & 2) ? 3 : 2; |
0 |
0 |
0 |
|
| 624 |
0 |
| flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0; |
| 625 |
0 |
| flags |= (buffer[3] & 2) ? PIC_FLAG_REPEAT_FIRST_FIELD : 0; |
| 626 |
|
| } else |
| 627 |
0 |
▶ | picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2; |
Branch: 2 branches
| Branch | True | False | Total |
| picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2; |
0 |
0 |
0 |
| picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2; |
0 |
0 |
0 |
|
| 628 |
0 |
| break; |
| 629 |
0 |
| default: |
| 630 |
0 |
| return 1; |
| 631 |
|
| } |
| 632 |
0 |
| decoder->top_field_first = buffer[3] >> 7; |
| 633 |
0 |
| decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1; |
| 634 |
0 |
| decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1; |
| 635 |
0 |
| decoder->q_scale_type = buffer[3] & 16; |
| 636 |
0 |
| decoder->intra_vlc_format = (buffer[3] >> 3) & 1; |
| 637 |
0 |
▶ | decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm; |
Branch: 1 branch
| Branch | True | False | Total |
| decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm; |
0 |
0 |
0 |
|
| 638 |
0 |
▶ | if (!(buffer[4] & 0x80)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(buffer[4] & 0x80)) |
0 |
0 |
0 |
|
| 639 |
0 |
| flags &= ~PIC_FLAG_PROGRESSIVE_FRAME; |
| 640 |
0 |
▶ | if (buffer[4] & 0x40) |
Branch: 1 branch
| Branch | True | False | Total |
| if (buffer[4] & 0x40) |
0 |
0 |
0 |
|
| 641 |
0 |
| flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) & |
| 642 |
|
| PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY; |
| 643 |
0 |
| picture->flags = flags; |
| 644 |
|
| |
| 645 |
0 |
| mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT; |
| 646 |
|
| |
| 647 |
0 |
| return 0; |
| 648 |
|
| } |
| 649 |
|
| |
| 650 |
0 |
| static int picture_display_ext (mpeg2dec_t * mpeg2dec) |
| 651 |
|
| { |
| 652 |
0 |
| uint8_t * buffer = mpeg2dec->chunk_start; |
| 653 |
0 |
| mpeg2_picture_t * picture = &(mpeg2dec->new_picture); |
| 654 |
|
| int i, nb_pos; |
| 655 |
|
| |
| 656 |
0 |
| nb_pos = picture->nb_fields; |
| 657 |
0 |
▶ | if (mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) |
0 |
0 |
0 |
|
| 658 |
0 |
| nb_pos >>= 1; |
| 659 |
|
| |
| 660 |
0 |
▶ | for (i = 0; i < nb_pos; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < nb_pos; i++) { |
0 |
0 |
0 |
|
| 661 |
|
| int x, y; |
| 662 |
|
| |
| 663 |
0 |
| x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) | |
| 664 |
0 |
| (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i); |
| 665 |
0 |
| y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) | |
| 666 |
0 |
| (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i); |
| 667 |
0 |
▶ | if (! (x & y & 1)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (! (x & y & 1)) |
0 |
0 |
0 |
|
| 668 |
0 |
| return 1; |
| 669 |
0 |
| picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1; |
| 670 |
0 |
| picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1; |
| 671 |
|
| } |
| 672 |
0 |
▶ | for (; i < 3; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (; i < 3; i++) { |
0 |
0 |
0 |
|
| 673 |
0 |
| picture->display_offset[i].x = mpeg2dec->display_offset_x; |
| 674 |
0 |
| picture->display_offset[i].y = mpeg2dec->display_offset_y; |
| 675 |
|
| } |
| 676 |
0 |
| return 0; |
| 677 |
|
| } |
| 678 |
|
| |
| 679 |
0 |
| void mpeg2_header_picture_finalize (mpeg2dec_t * mpeg2dec, uint32_t accels) |
| 680 |
|
| { |
| 681 |
0 |
| mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); |
| 682 |
0 |
| int old_type_b = (decoder->coding_type == B_TYPE); |
| 683 |
0 |
| int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY; |
| 684 |
|
| |
| 685 |
0 |
| finalize_matrix (mpeg2dec); |
| 686 |
0 |
| decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE; |
| 687 |
|
| |
| 688 |
0 |
▶ | if (mpeg2dec->state == STATE_PICTURE) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->state == STATE_PICTURE) { |
0 |
0 |
0 |
|
| 689 |
|
| mpeg2_picture_t * picture; |
| 690 |
|
| mpeg2_picture_t * other; |
| 691 |
|
| |
| 692 |
0 |
| decoder->second_field = 0; |
| 693 |
|
| |
| 694 |
0 |
| picture = other = mpeg2dec->pictures; |
| 695 |
0 |
▶ | if (old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2)) |
0 |
0 |
0 |
|
| 696 |
0 |
| picture += 2; |
| 697 |
|
| else |
| 698 |
0 |
| other += 2; |
| 699 |
0 |
| mpeg2dec->picture = picture; |
| 700 |
0 |
| *picture = mpeg2dec->new_picture; |
| 701 |
|
| |
| 702 |
0 |
▶ | if (!old_type_b) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!old_type_b) { |
0 |
0 |
0 |
|
| 703 |
0 |
| mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1]; |
| 704 |
0 |
| mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0]; |
| 705 |
|
| } |
| 706 |
0 |
| mpeg2dec->fbuf[0] = NULL; |
| 707 |
0 |
| mpeg2_reset_info (&(mpeg2dec->info)); |
| 708 |
0 |
| mpeg2dec->info.current_picture = picture; |
| 709 |
0 |
| mpeg2dec->info.display_picture = picture; |
| 710 |
0 |
▶ | if (decoder->coding_type != B_TYPE) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (decoder->coding_type != B_TYPE) { |
0 |
0 |
0 |
|
| 711 |
0 |
▶ | if (!low_delay) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!low_delay) { |
0 |
0 |
0 |
|
| 712 |
0 |
▶ | if (mpeg2dec->first) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->first) { |
0 |
0 |
0 |
|
| 713 |
0 |
| mpeg2dec->info.display_picture = NULL; |
| 714 |
0 |
| mpeg2dec->first = 0; |
| 715 |
|
| } else { |
| 716 |
0 |
| mpeg2dec->info.display_picture = other; |
| 717 |
0 |
▶ | if (other->nb_fields == 1) |
Branch: 1 branch
| Branch | True | False | Total |
| if (other->nb_fields == 1) |
0 |
0 |
0 |
|
| 718 |
0 |
| mpeg2dec->info.display_picture_2nd = other + 1; |
| 719 |
0 |
| mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1]; |
| 720 |
|
| } |
| 721 |
|
| } |
| 722 |
0 |
▶ | if (!low_delay + !mpeg2dec->convert) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!low_delay + !mpeg2dec->convert) |
0 |
0 |
0 |
|
| 723 |
0 |
| mpeg2dec->info.discard_fbuf = |
| 724 |
0 |
| mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert]; |
| 725 |
|
| } |
| 726 |
0 |
▶ | if (mpeg2dec->convert) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->convert) { |
0 |
0 |
0 |
|
| 727 |
|
| mpeg2_convert_init_t convert_init; |
| 728 |
0 |
▶ | if (!mpeg2dec->convert_start) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!mpeg2dec->convert_start) { |
0 |
0 |
0 |
|
| 729 |
|
| int y_size, uv_size; |
| 730 |
|
| |
| 731 |
0 |
| mpeg2dec->decoder.convert_id = |
| 732 |
0 |
| mpeg2_malloc (mpeg2dec->convert_id_size, |
| 733 |
|
| MPEG2_ALLOC_CONVERT_ID); |
| 734 |
0 |
| mpeg2dec->convert (MPEG2_CONVERT_START, |
| 735 |
|
| mpeg2dec->decoder.convert_id, |
| 736 |
0 |
| &(mpeg2dec->sequence), |
| 737 |
|
| mpeg2dec->convert_stride, accels, |
| 738 |
|
| mpeg2dec->convert_arg, &convert_init); |
| 739 |
0 |
| mpeg2dec->convert_start = convert_init.start; |
| 740 |
0 |
| mpeg2dec->decoder.convert = convert_init.copy; |
| 741 |
|
| |
| 742 |
0 |
| y_size = decoder->stride_frame * mpeg2dec->sequence.height; |
| 743 |
0 |
| uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format); |
| 744 |
0 |
| mpeg2dec->yuv_buf[0][0] = |
| 745 |
0 |
| (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV); |
| 746 |
0 |
| mpeg2dec->yuv_buf[0][1] = |
| 747 |
0 |
| (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); |
| 748 |
0 |
| mpeg2dec->yuv_buf[0][2] = |
| 749 |
0 |
| (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); |
| 750 |
0 |
| mpeg2dec->yuv_buf[1][0] = |
| 751 |
0 |
| (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV); |
| 752 |
0 |
| mpeg2dec->yuv_buf[1][1] = |
| 753 |
0 |
| (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); |
| 754 |
0 |
| mpeg2dec->yuv_buf[1][2] = |
| 755 |
0 |
| (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); |
| 756 |
0 |
| y_size = decoder->stride_frame * 32; |
| 757 |
0 |
| uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format); |
| 758 |
0 |
| mpeg2dec->yuv_buf[2][0] = |
| 759 |
0 |
| (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV); |
| 760 |
0 |
| mpeg2dec->yuv_buf[2][1] = |
| 761 |
0 |
| (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); |
| 762 |
0 |
| mpeg2dec->yuv_buf[2][2] = |
| 763 |
0 |
| (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); |
| 764 |
|
| } |
| 765 |
0 |
▶ | if (!mpeg2dec->custom_fbuf) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!mpeg2dec->custom_fbuf) { |
0 |
0 |
0 |
|
| 766 |
0 |
▶ | while (mpeg2dec->alloc_index < 3) { |
Branch: 1 branch
| Branch | True | False | Total |
| while (mpeg2dec->alloc_index < 3) { |
0 |
0 |
0 |
|
| 767 |
|
| mpeg2_fbuf_t * fbuf; |
| 768 |
|
| |
| 769 |
0 |
| fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf; |
| 770 |
0 |
| fbuf->id = NULL; |
| 771 |
0 |
| fbuf->buf[0] = |
| 772 |
0 |
| (uint8_t *) mpeg2_malloc (convert_init.buf_size[0], |
| 773 |
|
| MPEG2_ALLOC_CONVERTED); |
| 774 |
0 |
| fbuf->buf[1] = |
| 775 |
0 |
| (uint8_t *) mpeg2_malloc (convert_init.buf_size[1], |
| 776 |
|
| MPEG2_ALLOC_CONVERTED); |
| 777 |
0 |
| fbuf->buf[2] = |
| 778 |
0 |
| (uint8_t *) mpeg2_malloc (convert_init.buf_size[2], |
| 779 |
|
| MPEG2_ALLOC_CONVERTED); |
| 780 |
|
| } |
| 781 |
0 |
| mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE)); |
| 782 |
|
| } |
| 783 |
0 |
▶ | } else if (!mpeg2dec->custom_fbuf) { |
Branch: 1 branch
| Branch | True | False | Total |
| } else if (!mpeg2dec->custom_fbuf) { |
0 |
0 |
0 |
|
| 784 |
0 |
▶ | while (mpeg2dec->alloc_index < 3) { |
Branch: 1 branch
| Branch | True | False | Total |
| while (mpeg2dec->alloc_index < 3) { |
0 |
0 |
0 |
|
| 785 |
|
| mpeg2_fbuf_t * fbuf; |
| 786 |
|
| int y_size, uv_size; |
| 787 |
|
| |
| 788 |
0 |
| fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf); |
| 789 |
0 |
| fbuf->id = NULL; |
| 790 |
0 |
| y_size = decoder->stride_frame * mpeg2dec->sequence.height; |
| 791 |
0 |
| uv_size = y_size >> (2 - decoder->chroma_format); |
| 792 |
0 |
| fbuf->buf[0] = (uint8_t *) mpeg2_malloc (y_size, |
| 793 |
|
| MPEG2_ALLOC_YUV); |
| 794 |
0 |
| fbuf->buf[1] = (uint8_t *) mpeg2_malloc (uv_size, |
| 795 |
|
| MPEG2_ALLOC_YUV); |
| 796 |
0 |
| fbuf->buf[2] = (uint8_t *) mpeg2_malloc (uv_size, |
| 797 |
|
| MPEG2_ALLOC_YUV); |
| 798 |
|
| } |
| 799 |
0 |
| mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE)); |
| 800 |
|
| } |
| 801 |
|
| } else { |
| 802 |
0 |
| decoder->second_field = 1; |
| 803 |
0 |
| mpeg2dec->picture++; /* second field picture */ |
| 804 |
0 |
| *(mpeg2dec->picture) = mpeg2dec->new_picture; |
| 805 |
0 |
| mpeg2dec->info.current_picture_2nd = mpeg2dec->picture; |
| 806 |
0 |
▶ | if (low_delay || decoder->coding_type == B_TYPE) |
Branch: 2 branches
| Branch | True | False | Total |
| if (low_delay || decoder->coding_type == B_TYPE) |
0 |
0 |
0 |
| if (low_delay || decoder->coding_type == B_TYPE) |
0 |
0 |
0 |
|
| 807 |
0 |
| mpeg2dec->info.display_picture_2nd = mpeg2dec->picture; |
| 808 |
|
| } |
| 809 |
|
| |
| 810 |
0 |
| info_user_data (mpeg2dec); |
| 811 |
0 |
| } |
| 812 |
|
| |
| 813 |
0 |
| static int copyright_ext (mpeg2dec_t * mpeg2dec) |
| 814 |
|
| { |
| 815 |
0 |
| return 0; |
| 816 |
|
| } |
| 817 |
|
| |
| 818 |
0 |
| static int quant_matrix_ext (mpeg2dec_t * mpeg2dec) |
| 819 |
|
| { |
| 820 |
0 |
| uint8_t * buffer = mpeg2dec->chunk_start; |
| 821 |
|
| int i, j; |
| 822 |
|
| |
| 823 |
0 |
▶ | for (i = 0; i < 4; i++) |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < 4; i++) |
0 |
0 |
0 |
|
| 824 |
0 |
▶ | if (buffer[0] & (8 >> i)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (buffer[0] & (8 >> i)) { |
0 |
0 |
0 |
|
| 825 |
0 |
▶ | for (j = 0; j < 64; j++) |
Branch: 1 branch
| Branch | True | False | Total |
| for (j = 0; j < 64; j++) |
0 |
0 |
0 |
|
| 826 |
0 |
| mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] = |
| 827 |
0 |
| (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i)); |
| 828 |
0 |
| mpeg2dec->copy_matrix |= 1 << i; |
| 829 |
0 |
| buffer += 64; |
| 830 |
|
| } |
| 831 |
|
| |
| 832 |
0 |
| return 0; |
| 833 |
|
| } |
| 834 |
|
| |
| 835 |
0 |
| int mpeg2_header_extension (mpeg2dec_t * mpeg2dec) |
| 836 |
|
| { |
| 837 |
|
| static int (* parser[]) (mpeg2dec_t *) = { |
| 838 |
|
| 0, sequence_ext, sequence_display_ext, quant_matrix_ext, |
| 839 |
|
| copyright_ext, 0, 0, picture_display_ext, picture_coding_ext |
| 840 |
|
| }; |
| 841 |
|
| int ext, ext_bit; |
| 842 |
|
| |
| 843 |
0 |
| ext = mpeg2dec->chunk_start[0] >> 4; |
| 844 |
0 |
| ext_bit = 1 << ext; |
| 845 |
|
| |
| 846 |
0 |
▶ | if (!(mpeg2dec->ext_state & ext_bit)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(mpeg2dec->ext_state & ext_bit)) |
0 |
0 |
0 |
|
| 847 |
0 |
| return 0; /* ignore illegal extensions */ |
| 848 |
0 |
| mpeg2dec->ext_state &= ~ext_bit; |
| 849 |
0 |
| return parser[ext] (mpeg2dec); |
| 850 |
|
| } |
| 851 |
|
| |
| 852 |
0 |
| int mpeg2_header_user_data (mpeg2dec_t * mpeg2dec) |
| 853 |
|
| { |
| 854 |
0 |
| mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start; |
| 855 |
0 |
| mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1; |
| 856 |
|
| |
| 857 |
0 |
| return 0; |
| 858 |
|
| } |
| 859 |
|
| |
| 860 |
0 |
| static void prescale (mpeg2dec_t * mpeg2dec, int idx) |
| 861 |
|
| { |
| 862 |
|
| static int non_linear_scale [] = { |
| 863 |
|
| 0, 1, 2, 3, 4, 5, 6, 7, |
| 864 |
|
| 8, 10, 12, 14, 16, 18, 20, 22, |
| 865 |
|
| 24, 28, 32, 36, 40, 44, 48, 52, |
| 866 |
|
| 56, 64, 72, 80, 88, 96, 104, 112 |
| 867 |
|
| }; |
| 868 |
|
| int i, j, k; |
| 869 |
0 |
| mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); |
| 870 |
|
| |
| 871 |
0 |
▶ | if (mpeg2dec->scaled[idx] != decoder->q_scale_type) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->scaled[idx] != decoder->q_scale_type) { |
0 |
0 |
0 |
|
| 872 |
0 |
| mpeg2dec->scaled[idx] = decoder->q_scale_type; |
| 873 |
0 |
▶ | for (i = 0; i < 32; i++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (i = 0; i < 32; i++) { |
0 |
0 |
0 |
|
| 874 |
0 |
▶ | k = decoder->q_scale_type ? non_linear_scale[i] : (i << 1); |
Branch: 1 branch
| Branch | True | False | Total |
| k = decoder->q_scale_type ? non_linear_scale[i] : (i << 1); |
0 |
0 |
0 |
|
| 875 |
0 |
▶ | for (j = 0; j < 64; j++) |
Branch: 1 branch
| Branch | True | False | Total |
| for (j = 0; j < 64; j++) |
0 |
0 |
0 |
|
| 876 |
0 |
| decoder->quantizer_prescale[idx][i][j] = |
| 877 |
0 |
| k * mpeg2dec->quantizer_matrix[idx][j]; |
| 878 |
|
| } |
| 879 |
|
| } |
| 880 |
0 |
| } |
| 881 |
|
| |
| 882 |
0 |
| mpeg2_state_t mpeg2_header_slice_start (mpeg2dec_t * mpeg2dec) |
| 883 |
|
| { |
| 884 |
0 |
| mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); |
| 885 |
|
| |
| 886 |
0 |
| mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0; |
| 887 |
0 |
| mpeg2dec->state = ((mpeg2dec->picture->nb_fields > 1 || |
| 888 |
0 |
▶ | mpeg2dec->state == STATE_PICTURE_2ND) ? |
Branch: 1 branch
| Branch | True | False | Total |
| mpeg2dec->state == STATE_PICTURE_2ND) ? |
0 |
0 |
0 |
|
| 889 |
0 |
▶ | STATE_SLICE : STATE_SLICE_1ST); |
Branch: 1 branch
| Branch | True | False | Total |
| STATE_SLICE : STATE_SLICE_1ST); |
0 |
0 |
0 |
|
| 890 |
|
| |
| 891 |
0 |
▶ | if (mpeg2dec->decoder.coding_type != D_TYPE) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->decoder.coding_type != D_TYPE) { |
0 |
0 |
0 |
|
| 892 |
0 |
| prescale (mpeg2dec, 0); |
| 893 |
0 |
▶ | if (decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2]) |
Branch: 1 branch
| Branch | True | False | Total |
| if (decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2]) |
0 |
0 |
0 |
|
| 894 |
0 |
| prescale (mpeg2dec, 2); |
| 895 |
0 |
▶ | if (mpeg2dec->decoder.coding_type != I_TYPE) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->decoder.coding_type != I_TYPE) { |
0 |
0 |
0 |
|
| 896 |
0 |
| prescale (mpeg2dec, 1); |
| 897 |
0 |
▶ | if (decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3]) |
Branch: 1 branch
| Branch | True | False | Total |
| if (decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3]) |
0 |
0 |
0 |
|
| 898 |
0 |
| prescale (mpeg2dec, 3); |
| 899 |
|
| } |
| 900 |
|
| } |
| 901 |
|
| |
| 902 |
0 |
▶ | if (!(mpeg2dec->nb_decode_slices)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(mpeg2dec->nb_decode_slices)) |
0 |
0 |
0 |
|
| 903 |
0 |
| mpeg2dec->picture->flags |= PIC_FLAG_SKIP; |
| 904 |
0 |
▶ | else if (mpeg2dec->convert_start) { |
Branch: 1 branch
| Branch | True | False | Total |
| else if (mpeg2dec->convert_start) { |
0 |
0 |
0 |
|
| 905 |
0 |
| mpeg2dec->convert_start (decoder->convert_id, mpeg2dec->fbuf[0], |
| 906 |
0 |
| mpeg2dec->picture, mpeg2dec->info.gop); |
| 907 |
|
| |
| 908 |
0 |
▶ | if (mpeg2dec->decoder.coding_type == B_TYPE) |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->decoder.coding_type == B_TYPE) |
0 |
0 |
0 |
|
| 909 |
0 |
| mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->yuv_buf[2], |
| 910 |
0 |
| mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1], |
| 911 |
0 |
| mpeg2dec->yuv_buf[mpeg2dec->yuv_index]); |
| 912 |
|
| else { |
| 913 |
0 |
| mpeg2_init_fbuf (&(mpeg2dec->decoder), |
| 914 |
0 |
| mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1], |
| 915 |
0 |
| mpeg2dec->yuv_buf[mpeg2dec->yuv_index], |
| 916 |
0 |
| mpeg2dec->yuv_buf[mpeg2dec->yuv_index]); |
| 917 |
0 |
▶ | if (mpeg2dec->state == STATE_SLICE) |
Branch: 1 branch
| Branch | True | False | Total |
| if (mpeg2dec->state == STATE_SLICE) |
0 |
0 |
0 |
|
| 918 |
0 |
| mpeg2dec->yuv_index ^= 1; |
| 919 |
|
| } |
| 920 |
|
| } else { |
| 921 |
|
| int b_type; |
| 922 |
|
| |
| 923 |
0 |
| b_type = (mpeg2dec->decoder.coding_type == B_TYPE); |
| 924 |
0 |
| mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->fbuf[0]->buf, |
| 925 |
0 |
| mpeg2dec->fbuf[b_type + 1]->buf, |
| 926 |
0 |
| mpeg2dec->fbuf[b_type]->buf); |
| 927 |
|
| } |
| 928 |
0 |
| mpeg2dec->action = NULL; |
| 929 |
0 |
| return STATE_INTERNAL_NORETURN; |
| 930 |
|
| } |
| 931 |
|
| |
| 932 |
0 |
| static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec) |
| 933 |
|
| { |
| 934 |
0 |
| mpeg2_reset_info (&(mpeg2dec->info)); |
| 935 |
0 |
| mpeg2dec->info.sequence = NULL; |
| 936 |
0 |
| mpeg2dec->info.gop = NULL; |
| 937 |
0 |
| mpeg2_header_state_init (mpeg2dec); |
| 938 |
0 |
| mpeg2dec->action = mpeg2_seek_header; |
| 939 |
0 |
| return mpeg2_seek_header (mpeg2dec); |
| 940 |
|
| } |
| 941 |
|
| |
| 942 |
0 |
| mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec) |
| 943 |
|
| { |
| 944 |
|
| mpeg2_picture_t * picture; |
| 945 |
|
| int b_type; |
| 946 |
|
| |
| 947 |
0 |
| b_type = (mpeg2dec->decoder.coding_type == B_TYPE); |
| 948 |
0 |
| picture = mpeg2dec->pictures; |
| 949 |
0 |
▶ | if ((mpeg2dec->picture >= picture + 2) ^ b_type) |
Branch: 1 branch
| Branch | True | False | Total |
| if ((mpeg2dec->picture >= picture + 2) ^ b_type) |
0 |
0 |
0 |
|
| 950 |
0 |
| picture = mpeg2dec->pictures + 2; |
| 951 |
|
| |
| 952 |
0 |
| mpeg2_reset_info (&(mpeg2dec->info)); |
| 953 |
0 |
▶ | if (!(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { |
0 |
0 |
0 |
|
| 954 |
0 |
| mpeg2dec->info.display_picture = picture; |
| 955 |
0 |
▶ | if (picture->nb_fields == 1) |
Branch: 1 branch
| Branch | True | False | Total |
| if (picture->nb_fields == 1) |
0 |
0 |
0 |
|
| 956 |
0 |
| mpeg2dec->info.display_picture_2nd = picture + 1; |
| 957 |
0 |
| mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type]; |
| 958 |
0 |
▶ | if (!mpeg2dec->convert) |
Branch: 1 branch
| Branch | True | False | Total |
| if (!mpeg2dec->convert) |
0 |
0 |
0 |
|
| 959 |
0 |
| mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1]; |
| 960 |
0 |
▶ | } else if (!mpeg2dec->convert) |
Branch: 1 branch
| Branch | True | False | Total |
| } else if (!mpeg2dec->convert) |
0 |
0 |
0 |
|
| 961 |
0 |
| mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type]; |
| 962 |
0 |
| mpeg2dec->action = seek_sequence; |
| 963 |
0 |
| return STATE_END; |
| 964 |
|
| } |