libmpeg3/video/headers.c

   1 #include "../mpeg3demux.h"
   2 #include "../mpeg3private.h"
   3 #include "../mpeg3protos.h"
   4 #include "mpeg3video.h"
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8
   9 int mpeg3video_getseqhdr(mpeg3video_t *video)
  10 {
  11         int i;
  12         mpeg3_t *file = video->file;
  13
  14         int aspect_ratio, picture_rate, vbv_buffer_size;
  15         int constrained_parameters_flag;
  16         int load_intra_quantizer_matrix, load_non_intra_quantizer_matrix;
  17
  18 //printf("mpeg3video_getseqhdr 1\n");
  19         video->horizontal_size = mpeg3bits_getbits(video->vstream, 12);
  20         video->vertical_size = mpeg3bits_getbits(video->vstream, 12);
  21         aspect_ratio = mpeg3bits_getbits(video->vstream, 4);
  22         video->framerate_code = mpeg3bits_getbits(video->vstream, 4);
  23         video->bitrate = mpeg3bits_getbits(video->vstream, 18);
  24         mpeg3bits_getbit_noptr(video->vstream); /* marker bit (=1) */
  25         vbv_buffer_size = mpeg3bits_getbits(video->vstream, 10);
  26         constrained_parameters_flag = mpeg3bits_getbit_noptr(video->vstream);
  27         video->frame_rate = mpeg3_frame_rate_table[video->framerate_code];
  28
  29         load_intra_quantizer_matrix = mpeg3bits_getbit_noptr(video->vstream);
  30         if(load_intra_quantizer_matrix)
  31         {
  32         for(i = 0; i < 64; i++)
  33                 video->intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
  34         }
  35         else
  36         {
  37         for(i = 0; i < 64; i++)
  38                 video->intra_quantizer_matrix[i] = mpeg3_default_intra_quantizer_matrix[i];
  39         }
  40
  41         load_non_intra_quantizer_matrix = mpeg3bits_getbit_noptr(video->vstream);
  42         if(load_non_intra_quantizer_matrix)
  43         {
  44         for(i = 0; i < 64; i++)
  45                 video->non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
  46         }
  47         else
  48         {
  49         for(i = 0; i < 64; i++)
  50                 video->non_intra_quantizer_matrix[i] = 16;
  51         }
  52
  53 /* copy luminance to chrominance matrices */
  54         for(i = 0; i < 64; i++)
  55         {
  56         video->chroma_intra_quantizer_matrix[i] = video->intra_quantizer_matrix[i];
  57                 video->chroma_non_intra_quantizer_matrix[i] = video->non_intra_quantizer_matrix[i];
  58         }
  59
  60 //printf("mpeg3video_getseqhdr 100\n");
  61         return 0;
  62 }
  63
  64
  65 /* decode sequence extension */
  66
  67 int mpeg3video_sequence_extension(mpeg3video_t *video)
  68 {
  69         int prof_lev;
  70         int horizontal_size_extension, vertical_size_extension;
  71         int bit_rate_extension, vbv_buffer_size_extension, low_delay;
  72         int frame_rate_extension_n, frame_rate_extension_d;
  73         int pos = 0;
  74
  75         video->mpeg2 = 1;
  76         video->scalable_mode = SC_NONE; /* unless overwritten by seq. scal. ext. */
  77         prof_lev = mpeg3bits_getbyte_noptr(video->vstream);
  78         video->prog_seq = mpeg3bits_getbit_noptr(video->vstream);
  79         video->chroma_format = mpeg3bits_getbits(video->vstream, 2);
  80         horizontal_size_extension = mpeg3bits_getbits(video->vstream, 2);
  81         vertical_size_extension = mpeg3bits_getbits(video->vstream, 2);
  82         bit_rate_extension = mpeg3bits_getbits(video->vstream, 12);
  83         mpeg3bits_getbit_noptr(video->vstream);
  84         vbv_buffer_size_extension = mpeg3bits_getbyte_noptr(video->vstream);
  85         low_delay = mpeg3bits_getbit_noptr(video->vstream);
  86         frame_rate_extension_n = mpeg3bits_getbits(video->vstream, 2);
  87         frame_rate_extension_d = mpeg3bits_getbits(video->vstream, 5);
  88         video->horizontal_size = (horizontal_size_extension << 12) | (video->horizontal_size & 0x0fff);
  89         video->vertical_size = (vertical_size_extension << 12) | (video->vertical_size & 0x0fff);
  90         return 0;
  91 }
  92
  93
  94 /* decode sequence display extension */
  95
  96 int mpeg3video_sequence_display_extension(mpeg3video_t *video)
  97 {
  98         int colour_primaries = 0, transfer_characteristics = 0;
  99         int display_horizontal_size, display_vertical_size;
 100         int pos = 0;
 101         int video_format = mpeg3bits_getbits(video->vstream, 3);
 102         int colour_description = mpeg3bits_getbit_noptr(video->vstream);
 103
 104         if(colour_description)
 105         {
 106         colour_primaries = mpeg3bits_getbyte_noptr(video->vstream);
 107         transfer_characteristics = mpeg3bits_getbyte_noptr(video->vstream);
 108         video->matrix_coefficients = mpeg3bits_getbyte_noptr(video->vstream);
 109         }
 110
 111         display_horizontal_size = mpeg3bits_getbits(video->vstream, 14);
 112         mpeg3bits_getbit_noptr(video->vstream);
 113         display_vertical_size = mpeg3bits_getbits(video->vstream, 14);
 114         return 0;
 115 }
 116
 117
 118 /* decode quant matrix entension */
 119
 120 int mpeg3video_quant_matrix_extension(mpeg3video_t *video)
 121 {
 122         int i;
 123         int load_intra_quantiser_matrix, load_non_intra_quantiser_matrix;
 124         int load_chroma_intra_quantiser_matrix;
 125         int load_chroma_non_intra_quantiser_matrix;
 126         int pos = 0;
 127
 128         if((load_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
 129         {
 130         for(i = 0; i < 64; i++)
 131                 {
 132                 video->chroma_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
 133                         = video->intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
 134                         = mpeg3bits_getbyte_noptr(video->vstream);
 135         }
 136         }
 137
 138         if((load_non_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
 139         {
 140         for (i = 0; i < 64; i++)
 141                 {
 142                 video->chroma_non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
 143                         = video->non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]]
 144                         = mpeg3bits_getbyte_noptr(video->vstream);
 145         }
 146         }
 147
 148         if((load_chroma_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
 149         {
 150         for(i = 0; i < 64; i++)
 151                 video->chroma_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
 152         }
 153
 154         if((load_chroma_non_intra_quantiser_matrix = mpeg3bits_getbit_noptr(video->vstream)) != 0)
 155         {
 156         for(i = 0; i < 64; i++)
 157                 video->chroma_non_intra_quantizer_matrix[video->mpeg3_zigzag_scan_table[i]] = mpeg3bits_getbyte_noptr(video->vstream);
 158         }
 159         return 0;
 160 }
 161
 162
 163 /* decode sequence scalable extension */
 164
 165 int mpeg3video_sequence_scalable_extension(mpeg3video_t *video)
 166 {
 167         int layer_id;
 168
 169         video->scalable_mode = mpeg3bits_getbits(video->vstream, 2) + 1; /* add 1 to make SC_DP != SC_NONE */
 170         layer_id = mpeg3bits_getbits(video->vstream, 4);
 171
 172         if(video->scalable_mode == SC_SPAT)
 173         {
 174         video->llw = mpeg3bits_getbits(video->vstream, 14); /* lower_layer_prediction_horizontal_size */
 175         mpeg3bits_getbit_noptr(video->vstream);
 176         video->llh = mpeg3bits_getbits(video->vstream, 14); /* lower_layer_prediction_vertical_size */
 177         video->hm = mpeg3bits_getbits(video->vstream, 5);
 178         video->hn = mpeg3bits_getbits(video->vstream, 5);
 179         video->vm = mpeg3bits_getbits(video->vstream, 5);
 180         video->vn = mpeg3bits_getbits(video->vstream, 5);
 181         }
 182
 183         if(video->scalable_mode == SC_TEMP)
 184         fprintf(stderr, "mpeg3video_sequence_scalable_extension: temporal scalability not implemented\n");
 185         return 0;
 186 }
 187
 188
 189 /* decode picture display extension */
 190
 191 int mpeg3video_picture_display_extension(mpeg3video_t *video)
 192 {
 193         int n, i;
 194         short frame_centre_horizontal_offset[3];
 195         short frame_centre_vertical_offset[3];
 196
 197
 198
 199         if(video->prog_seq || video->pict_struct != FRAME_PICTURE)
 200                 n = 1;
 201         else
 202                 n = video->repeatfirst ? 3 : 2;
 203
 204
 205
 206
 207         for(i = 0; i < n; i++)
 208         {
 209         frame_centre_horizontal_offset[i] = (short)mpeg3bits_getbits(video->vstream, 16);
 210         mpeg3bits_getbit_noptr(video->vstream);
 211         frame_centre_vertical_offset[i] = (short)mpeg3bits_getbits(video->vstream, 16);
 212         mpeg3bits_getbit_noptr(video->vstream);
 213         }
 214         return 0;
 215 }
 216
 217
 218 /* decode picture coding extension */
 219
 220 int mpeg3video_picture_coding_extension(mpeg3video_t *video)
 221 {
 222         int chroma_420_type, composite_display_flag;
 223         int v_axis = 0, sub_carrier = 0, burst_amplitude = 0, sub_carrier_phase = 0;
 224
 225         video->h_forw_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
 226         video->v_forw_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
 227         video->h_back_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
 228         video->v_back_r_size = mpeg3bits_getbits(video->vstream, 4) - 1;
 229         video->dc_prec = mpeg3bits_getbits(video->vstream, 2);
 230         video->pict_struct = mpeg3bits_getbits(video->vstream, 2);
 231         video->topfirst = mpeg3bits_getbit_noptr(video->vstream);
 232         video->frame_pred_dct = mpeg3bits_getbit_noptr(video->vstream);
 233         video->conceal_mv = mpeg3bits_getbit_noptr(video->vstream);
 234         video->qscale_type = mpeg3bits_getbit_noptr(video->vstream);
 235         video->intravlc = mpeg3bits_getbit_noptr(video->vstream);
 236         video->altscan = mpeg3bits_getbit_noptr(video->vstream);
 237
 238
 239         video->repeatfirst = mpeg3bits_getbit_noptr(video->vstream);
 240
 241
 242         chroma_420_type = mpeg3bits_getbit_noptr(video->vstream);
 243         video->prog_frame = mpeg3bits_getbit_noptr(video->vstream);
 244
 245         if(video->repeat_count > 100)
 246                 video->repeat_count = 0;
 247         video->repeat_count += 100;
 248
 249         video->current_repeat = 0;
 250
 251 /*
 252  * printf("%d %d %d %d\n",
 253  * video->prog_seq ? 1 : 0,
 254  * video->prog_frame ? 1 : 0,
 255  * video->topfirst ? 1 : 0,
 256  * video->repeatfirst ? 1 : 0);
 257  */
 258
 259
 260
 261         if(video->repeatfirst)
 262         {
 263                 if(video->prog_seq)
 264                 {
 265                         if(video->topfirst)
 266                                 video->repeat_count += 200;
 267                         else
 268                                 video->repeat_count += 100;
 269                 }
 270                 else
 271                 if(video->prog_frame)
 272                 {
 273                         video->repeat_count += 50;
 274                 }
 275         }
 276
 277         composite_display_flag = mpeg3bits_getbit_noptr(video->vstream);
 278
 279         if(composite_display_flag)
 280         {
 281         v_axis = mpeg3bits_getbit_noptr(video->vstream);
 282         video->field_sequence = mpeg3bits_getbits(video->vstream, 3);
 283         sub_carrier = mpeg3bits_getbit_noptr(video->vstream);
 284         burst_amplitude = mpeg3bits_getbits(video->vstream, 7);
 285         sub_carrier_phase = mpeg3bits_getbyte_noptr(video->vstream);
 286         }
 287         return 0;
 288 }
 289
 290
 291 /* decode picture spatial scalable extension */
 292
 293 int mpeg3video_picture_spatial_scalable_extension(mpeg3video_t *video)
 294 {
 295         video->pict_scal = 1; /* use spatial scalability in this picture */
 296
 297         video->lltempref = mpeg3bits_getbits(video->vstream, 10);
 298         mpeg3bits_getbit_noptr(video->vstream);
 299         video->llx0 = mpeg3bits_getbits(video->vstream, 15);
 300         if(video->llx0 >= 16384) video->llx0 -= 32768;
 301         mpeg3bits_getbit_noptr(video->vstream);
 302         video->lly0 = mpeg3bits_getbits(video->vstream, 15);
 303         if(video->lly0 >= 16384) video->lly0 -= 32768;
 304         video->stwc_table_index = mpeg3bits_getbits(video->vstream, 2);
 305         video->llprog_frame = mpeg3bits_getbit_noptr(video->vstream);
 306         video->llfieldsel = mpeg3bits_getbit_noptr(video->vstream);
 307         return 0;
 308 }
 309
 310
 311 /* decode picture temporal scalable extension
 312  *
 313  * not implemented
 314  *
 315  */
 316
 317 int mpeg3video_picture_temporal_scalable_extension(mpeg3video_t *video)
 318 {
 319         fprintf(stderr, "mpeg3video_picture_temporal_scalable_extension: temporal scalability not supported\n");
 320         return 0;
 321 }
 322
 323
 324 /* decode extension and user data */
 325
 326 int mpeg3video_ext_user_data(mpeg3video_t *video)
 327 {
 328         int code = mpeg3bits_next_startcode(video->vstream);
 329
 330
 331         while((code == MPEG3_EXT_START_CODE || code == MPEG3_USER_START_CODE) &&
 332                 !mpeg3bits_eof(video->vstream))
 333         {
 334         mpeg3bits_refill(video->vstream);
 335
 336         if(code == MPEG3_EXT_START_CODE)
 337                 {
 338                 int ext_id = mpeg3bits_getbits(video->vstream, 4);
 339                 switch(ext_id)
 340                         {
 341                         case SEQ_ID:
 342                                         mpeg3video_sequence_extension(video);
 343                                         break;
 344                         case DISP_ID:
 345                                         mpeg3video_sequence_display_extension(video);
 346                                         break;
 347                         case QUANT_ID:
 348                                         mpeg3video_quant_matrix_extension(video);
 349                                         break;
 350                         case SEQSCAL_ID:
 351                                         mpeg3video_sequence_scalable_extension(video);
 352                                         break;
 353                         case PANSCAN_ID:
 354                                         mpeg3video_picture_display_extension(video);
 355                                         break;
 356                         case CODING_ID:
 357                                         mpeg3video_picture_coding_extension(video);
 358                                         break;
 359                         case SPATSCAL_ID:
 360                                         mpeg3video_picture_spatial_scalable_extension(video);
 361                                         break;
 362                         case TEMPSCAL_ID:
 363                                         mpeg3video_picture_temporal_scalable_extension(video);
 364                                         break;
 365                         default:
 366                                         fprintf(stderr,"mpeg3video_ext_user_data: reserved extension start code ID %d\n", ext_id);
 367                                         break;
 368                 }
 369                 }
 370                 code = mpeg3bits_next_startcode(video->vstream);
 371         }
 372
 373 /*
 374  * printf("mpeg3video_ext_user_data prog_seq=%d prog_frame=%d\n",
 375  * video->prog_seq,
 376  * video->prog_frame);
 377  */
 378         return 0;
 379 }
 380
 381
 382 /* decode group of pictures header */
 383
 384 int mpeg3video_getgophdr(mpeg3video_t *video)
 385 {
 386         int drop_flag, closed_gop, broken_link;
 387
 388 //printf("mpeg3video_getgophdr 1\n");
 389         video->has_gops = 1;
 390         drop_flag = mpeg3bits_getbit_noptr(video->vstream);
 391         video->gop_timecode.hour = mpeg3bits_getbits(video->vstream, 5);
 392         video->gop_timecode.minute = mpeg3bits_getbits(video->vstream, 6);
 393         mpeg3bits_getbit_noptr(video->vstream);
 394         video->gop_timecode.second = mpeg3bits_getbits(video->vstream, 6);
 395         video->gop_timecode.frame = mpeg3bits_getbits(video->vstream, 6);
 396         closed_gop = mpeg3bits_getbit_noptr(video->vstream);
 397         broken_link = mpeg3bits_getbit_noptr(video->vstream);
 398
 399 //printf("mpeg3video_getgophdr 100\n");
 400 /*
 401  * printf("%d:%d:%d:%d %d %d %d\n", video->gop_timecode.hour, video->gop_timecode.minute, video->gop_timecode.second, video->gop_timecode.frame,
 402  *      drop_flag, closed_gop, broken_link);
 403  */
 404         return mpeg3bits_error(video->vstream);
 405 }
 406
 407 /* decode picture header */
 408
 409 int mpeg3video_getpicturehdr(mpeg3video_t *video)
 410 {
 411         int temp_ref, vbv_delay;
 412
 413         video->pict_scal = 0; /* unless overwritten by pict. spat. scal. ext. */
 414
 415         temp_ref = mpeg3bits_getbits(video->vstream, 10);
 416         video->pict_type = mpeg3bits_getbits(video->vstream, 3);
 417         vbv_delay = mpeg3bits_getbits(video->vstream, 16);
 418
 419         if(video->pict_type == P_TYPE || video->pict_type == B_TYPE)
 420         {
 421         video->full_forw = mpeg3bits_getbit_noptr(video->vstream);
 422         video->forw_r_size = mpeg3bits_getbits(video->vstream, 3) - 1;
 423         }
 424
 425         if(video->pict_type == B_TYPE)
 426         {
 427         video->full_back = mpeg3bits_getbit_noptr(video->vstream);
 428         video->back_r_size = mpeg3bits_getbits(video->vstream, 3) - 1;
 429         }
 430
 431 /* get extra bit picture */
 432         while(mpeg3bits_getbit_noptr(video->vstream) &&
 433                 !mpeg3bits_eof(video->vstream))
 434                 mpeg3bits_getbyte_noptr(video->vstream);
 435         return 0;
 436 }
 437
 438
 439 int mpeg3video_get_header(mpeg3video_t *video, int dont_repeat)
 440 {
 441         unsigned int code;
 442         mpeg3_t *file = video->file;
 443         mpeg3_vtrack_t *track = video->track;
 444         mpeg3_bits_t *vstream = video->vstream;
 445         mpeg3_demuxer_t *demuxer = track->demuxer;
 446
 447 /* a sequence header should be found before returning from get_header the */
 448 /* first time (this is to set horizontal/vertical size properly) */
 449
 450 /* Repeat the frame until it's less than 1 count from repeat_count */
 451         if(video->repeat_count - video->current_repeat >= 100 && !dont_repeat)
 452         {
 453                 return 0;
 454         }
 455
 456         if(dont_repeat)
 457         {
 458                 video->repeat_count = 0;
 459                 video->current_repeat = 0;
 460         }
 461         else
 462                 video->repeat_count -= video->current_repeat;
 463
 464 // Case of no picture coding extension
 465         if(video->repeat_count < 0) video->repeat_count = 0;
 466
 467         while(1)
 468         {
 469 /* look for startcode */
 470         code = mpeg3bits_next_startcode(vstream);
 471
 472
 473                 if(mpeg3bits_eof(vstream)) return 1;
 474
 475
 476                 if(code != MPEG3_SEQUENCE_END_CODE) mpeg3bits_refill(vstream);
 477
 478         switch(code)
 479                 {
 480                 case MPEG3_SEQUENCE_START_CODE:
 481                         video->found_seqhdr = 1;
 482                         mpeg3video_getseqhdr(video);
 483                         mpeg3video_ext_user_data(video);
 484                         break;
 485
 486                 case MPEG3_GOP_START_CODE:
 487                         mpeg3video_getgophdr(video);
 488                         mpeg3video_ext_user_data(video);
 489                         break;
 490
 491                 case MPEG3_PICTURE_START_CODE:
 492                         mpeg3video_getpicturehdr(video);
 493                         mpeg3video_ext_user_data(video);
 494                         if(video->found_seqhdr) return 0;       /* Exit here */
 495                         break;
 496
 497                 case MPEG3_SEQUENCE_END_CODE:
 498 // Continue until the end
 499                                 mpeg3bits_refill(vstream);
 500                                 break;
 501
 502                 default:
 503                         break;
 504         }
 505         }
 506
 507
 508         return 1;      /* Shouldn't be reached. */
 509 }
 510
 511 int mpeg3video_ext_bit_info(mpeg3_slice_buffer_t *slice_buffer)
 512 {
 513         while(mpeg3slice_getbit(slice_buffer)) mpeg3slice_getbyte(slice_buffer);
 514         return 0;
 515 }
 516
 517 /* decode slice header */
 518 int mpeg3video_getslicehdr(mpeg3_slice_t *slice, mpeg3video_t *video)
 519 {
 520         int slice_vertical_position_extension, intra_slice;
 521         int qs;
 522
 523         slice_vertical_position_extension = (video->mpeg2 && video->vertical_size > 2800) ?
 524                 mpeg3slice_getbits(slice->slice_buffer, 3) : 0;
 525
 526         if(video->scalable_mode == SC_DP) slice->pri_brk = mpeg3slice_getbits(slice->slice_buffer, 7);
 527
 528         qs = mpeg3slice_getbits(slice->slice_buffer, 5);
 529         slice->quant_scale = video->mpeg2 ? (video->qscale_type ? mpeg3_non_linear_mquant_table[qs] : (qs << 1)) : qs;
 530
 531         if(mpeg3slice_getbit(slice->slice_buffer))
 532         {
 533         intra_slice = mpeg3slice_getbit(slice->slice_buffer);
 534         mpeg3slice_getbits(slice->slice_buffer, 7);
 535         mpeg3video_ext_bit_info(slice->slice_buffer);
 536         }
 537         else
 538                 intra_slice = 0;
 539
 540         return slice_vertical_position_extension;
 541 }
 542
 543