libmpdemux/mpeg_hdr.c

   1 /*
   2  * based on libmpeg2/header.c by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
   3  *
   4  * This file is part of MPlayer.
   5  *
   6  * MPlayer is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * MPlayer is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include <inttypes.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "config.h"
  27 #include "mpeg_hdr.h"
  28
  29 #include "mp_msg.h"
  30
  31 static float frameratecode2framerate[16] = {
  32   0,
  33   // Official mpeg1/2 framerates: (1-8)
  34   24000.0/1001, 24,25,
  35   30000.0/1001, 30,50,
  36   60000.0/1001, 60,
  37   // Xing's 15fps: (9)
  38   15,
  39   // libmpeg3's "Unofficial economy rates": (10-13)
  40   5,10,12,15,
  41   // some invalid ones: (14-15)
  42   0,0
  43 };
  44
  45
  46 int mp_header_process_sequence_header (mp_mpeg_header_t * picture, const unsigned char * buffer)
  47 {
  48     int width, height;
  49
  50     if ((buffer[6] & 0x20) != 0x20){
  51         fprintf(stderr, "missing marker bit!\n");
  52         return 1;       /* missing marker_bit */
  53     }
  54
  55     height = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
  56
  57     picture->display_picture_width = (height >> 12);
  58     picture->display_picture_height = (height & 0xfff);
  59
  60     width = ((height >> 12) + 15) & ~15;
  61     height = ((height & 0xfff) + 15) & ~15;
  62
  63     picture->aspect_ratio_information = buffer[3] >> 4;
  64     picture->frame_rate_code = buffer[3] & 15;
  65     picture->fps=frameratecode2framerate[picture->frame_rate_code];
  66     picture->bitrate = (buffer[4]<<10)|(buffer[5]<<2)|(buffer[6]>>6);
  67     picture->mpeg1 = 1;
  68     picture->picture_structure = 3; //FRAME_PICTURE;
  69     picture->display_time=100;
  70     return 0;
  71 }
  72
  73 static int header_process_sequence_extension (mp_mpeg_header_t * picture,
  74                                               unsigned char * buffer)
  75 {
  76     /* check chroma format, size extensions, marker bit */
  77
  78     if ( ((buffer[1] & 0x06) == 0x00) ||
  79          ((buffer[1] & 0x01) != 0x00) || (buffer[2] & 0xe0) ||
  80          ((buffer[3] & 0x01) != 0x01) )
  81         return 1;
  82
  83     picture->progressive_sequence = (buffer[1] >> 3) & 1;
  84     picture->mpeg1 = 0;
  85     return 0;
  86 }
  87
  88 static int header_process_picture_coding_extension (mp_mpeg_header_t * picture, unsigned char * buffer)
  89 {
  90     picture->picture_structure = buffer[2] & 3;
  91     picture->top_field_first = buffer[3] >> 7;
  92     picture->repeat_first_field = (buffer[3] >> 1) & 1;
  93     picture->progressive_frame = buffer[4] >> 7;
  94
  95     // repeat_first implementation by A'rpi/ESP-team, based on libmpeg3:
  96     picture->display_time=100;
  97     if(picture->repeat_first_field){
  98         if(picture->progressive_sequence){
  99             if(picture->top_field_first)
 100                 picture->display_time+=200;
 101             else
 102                 picture->display_time+=100;
 103         } else
 104         if(picture->progressive_frame){
 105                 picture->display_time+=50;
 106         }
 107     }
 108     //temopral hack. We calc time on every field, so if we have 2 fields
 109     // interlaced we'll end with double time for 1 frame
 110     if( picture->picture_structure!=3 ) picture->display_time/=2;
 111     return 0;
 112 }
 113
 114 int mp_header_process_extension (mp_mpeg_header_t * picture, unsigned char * buffer)
 115 {
 116     switch (buffer[0] & 0xf0) {
 117     case 0x10:  /* sequence extension */
 118         return header_process_sequence_extension (picture, buffer);
 119     case 0x80:  /* picture coding extension */
 120         return header_process_picture_coding_extension (picture, buffer);
 121     }
 122     return 0;
 123 }
 124
 125 float mpeg12_aspect_info(mp_mpeg_header_t *picture)
 126 {
 127     float aspect = 0.0;
 128
 129     switch(picture->aspect_ratio_information) {
 130       case 2:  // PAL/NTSC SVCD/DVD 4:3
 131       case 8:  // PAL VCD 4:3
 132       case 12: // NTSC VCD 4:3
 133         aspect=4.0/3.0;
 134         break;
 135       case 3:  // PAL/NTSC Widescreen SVCD/DVD 16:9
 136       case 6:  // (PAL?)/NTSC Widescreen SVCD 16:9
 137         aspect=16.0/9.0;
 138         break;
 139       case 4:  // according to ISO-138182-2 Table 6.3
 140         aspect=2.21;
 141         break;
 142       case 1:  // VGA 1:1 - do not prescale
 143       case 9: // Movie Type ??? / 640x480
 144         aspect=0.0;
 145         break;
 146       default:
 147         mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Detected unknown aspect_ratio_information in mpeg sequence header.\n"
 148                "Please report the aspect value (%i) along with the movie type (VGA,PAL,NTSC,"
 149                "SECAM) and the movie resolution (720x576,352x240,480x480,...) to the MPlayer"
 150                " developers, so that we can add support for it!\nAssuming 1:1 aspect for now.\n",
 151                picture->aspect_ratio_information);
 152     }
 153
 154     return aspect;
 155 }
 156
 157 //MPEG4 HEADERS
 158 unsigned char mp_getbits(unsigned char *buffer, unsigned int from, unsigned char len)
 159 {
 160     unsigned int n;
 161     unsigned char m, u, l, y;
 162
 163     n = from / 8;
 164     m = from % 8;
 165     u = 8 - m;
 166     l = (len > u ? len - u : 0);
 167
 168     y = (buffer[n] << m);
 169     if(8 > len)
 170         y  >>= (8-len);
 171     if(l)
 172         y |= (buffer[n+1] >> (8-l));
 173
 174     //fprintf(stderr, "GETBITS(%d -> %d): bytes=0x%x 0x%x, n=%d, m=%d, l=%d, u=%d, Y=%d\n",
 175     //  from, (int) len, (int) buffer[n],(int) buffer[n+1], n, (int) m, (int) l, (int) u, (int) y);
 176     return  y;
 177 }
 178
 179 static inline unsigned int mp_getbits16(unsigned char *buffer, unsigned int from, unsigned char len)
 180 {
 181     if(len > 8)
 182         return (mp_getbits(buffer, from, len - 8) << 8) | mp_getbits(buffer, from + len - 8, 8);
 183     else
 184         return mp_getbits(buffer, from, len);
 185 }
 186
 187 #define getbits mp_getbits
 188 #define getbits16 mp_getbits16
 189
 190 static int read_timeinc(mp_mpeg_header_t * picture, unsigned char * buffer, int n)
 191 {
 192     if(picture->timeinc_bits > 8) {
 193       picture->timeinc_unit = getbits(buffer, n, picture->timeinc_bits - 8) << 8;
 194       n += picture->timeinc_bits - 8;
 195       picture->timeinc_unit |= getbits(buffer, n, 8);
 196       n += 8;
 197     } else {
 198       picture->timeinc_unit = getbits(buffer, n, picture->timeinc_bits);
 199       n += picture->timeinc_bits;
 200     }
 201     //fprintf(stderr, "TIMEINC2: %d, bits: %d\n", picture->timeinc_unit, picture->timeinc_bits);
 202     return n;
 203 }
 204
 205 int mp4_header_process_vol(mp_mpeg_header_t * picture, unsigned char * buffer)
 206 {
 207     unsigned int n, aspect=0, aspectw=0, aspecth=0,  x=1, v;
 208
 209     //begins with 0x0000012x
 210     picture->fps = 0;
 211     picture->timeinc_bits = picture->timeinc_resolution = picture->timeinc_unit = 0;
 212     n = 9;
 213     if(getbits(buffer, n, 1))
 214       n += 7;
 215     n++;
 216     aspect=getbits(buffer, n, 4);
 217     n += 4;
 218     if(aspect == 0x0f) {
 219       aspectw = getbits(buffer, n, 8);
 220       n += 8;
 221       aspecth = getbits(buffer, n, 8);
 222       n += 8;
 223     }
 224
 225     if(getbits(buffer, n, 1)) {
 226       n += 4;
 227       if(getbits(buffer, n, 1))
 228         n += 79;
 229       n++;
 230     } else n++;
 231
 232     n+=3;
 233
 234     picture->timeinc_resolution = getbits(buffer, n, 8) << 8;
 235     n += 8;
 236     picture->timeinc_resolution |= getbits(buffer, n, 8);
 237     n += 8;
 238
 239     picture->timeinc_bits = 0;
 240     v = picture->timeinc_resolution - 1;
 241     while(v && (x<16)) {
 242       v>>=1;
 243       picture->timeinc_bits++;
 244     }
 245     picture->timeinc_bits = (picture->timeinc_bits > 1 ? picture->timeinc_bits : 1);
 246
 247     n++; //marker bit
 248
 249     if(getbits(buffer, n, 1)) { //fixed_vop_timeinc
 250       n++;
 251       n = read_timeinc(picture, buffer, n);
 252
 253       if(picture->timeinc_unit)
 254         picture->fps = (float) picture->timeinc_resolution / (float) picture->timeinc_unit;
 255     }
 256
 257     //fprintf(stderr, "ASPECT: %d, PARW=%d, PARH=%d, TIMEINCRESOLUTION: %d, FIXED_TIMEINC: %d (number of bits: %d), FPS: %u\n",
 258     //  aspect, aspectw, aspecth, picture->timeinc_resolution, picture->timeinc_unit, picture->timeinc_bits, picture->fps);
 259
 260     return 0;
 261 }
 262
 263 void mp4_header_process_vop(mp_mpeg_header_t * picture, unsigned char * buffer)
 264 {
 265   int n;
 266   n = 0;
 267   picture->picture_type = getbits(buffer, n, 2);
 268   n += 2;
 269   while(getbits(buffer, n, 1))
 270     n++;
 271   n++;
 272   getbits(buffer, n, 1);
 273   n++;
 274   n = read_timeinc(picture, buffer, n);
 275 }
 276
 277 #define min(a, b) ((a) <= (b) ? (a) : (b))
 278
 279 static unsigned int read_golomb(unsigned char *buffer, unsigned int *init)
 280 {
 281   unsigned int x, v = 0, v2 = 0, m, len = 0, n = *init;
 282
 283   while(getbits(buffer, n++, 1) == 0)
 284     len++;
 285
 286   x = len + n;
 287   while(n < x)
 288   {
 289     m = min(x - n, 8);
 290     v |= getbits(buffer, n, m);
 291     n += m;
 292     if(x - n > 8)
 293       v <<= 8;
 294   }
 295
 296   v2 = 1;
 297   for(n = 0; n < len; n++)
 298     v2 <<= 1;
 299   v2 = (v2 - 1) + v;
 300
 301   //fprintf(stderr, "READ_GOLOMB(%u), V=2^%u + %u-1 = %u\n", *init, len, v, v2);
 302   *init = x;
 303   return v2;
 304 }
 305
 306
 307 static int h264_parse_vui(mp_mpeg_header_t * picture, unsigned char * buf, unsigned int n)
 308 {
 309   unsigned int overscan, vsp_color, chroma, timing, fixed_fps;
 310
 311   if(getbits(buf, n++, 1))
 312   {
 313     picture->aspect_ratio_information = getbits(buf, n, 8);
 314     n += 8;
 315     if(picture->aspect_ratio_information == 255)
 316     {
 317       picture->display_picture_width = (getbits(buf, n, 8) << 8) | getbits(buf, n + 8, 8);
 318       n += 16;
 319
 320       picture->display_picture_height = (getbits(buf, n, 8) << 8) | getbits(buf, n + 8, 8);
 321       n += 16;
 322     }
 323   }
 324
 325   if((overscan=getbits(buf, n++, 1)))
 326     n++;
 327   if((vsp_color=getbits(buf, n++, 1)))
 328   {
 329     n += 4;
 330     if(getbits(buf, n++, 1))
 331       n += 24;
 332   }
 333   if((chroma=getbits(buf, n++, 1)))
 334   {
 335     read_golomb(buf, &n);
 336     read_golomb(buf, &n);
 337   }
 338   if((timing=getbits(buf, n++, 1)))
 339   {
 340     picture->timeinc_unit = (getbits(buf, n, 8) << 24) | (getbits(buf, n+8, 8) << 16) | (getbits(buf, n+16, 8) << 8) | getbits(buf, n+24, 8);
 341     n += 32;
 342
 343     picture->timeinc_resolution = (getbits(buf, n, 8) << 24) | (getbits(buf, n+8, 8) << 16) | (getbits(buf, n+16, 8) << 8) | getbits(buf, n+24, 8);
 344     n += 32;
 345
 346     fixed_fps = getbits(buf, n, 1);
 347
 348     if(picture->timeinc_unit > 0 && picture->timeinc_resolution > 0)
 349       picture->fps = (float) picture->timeinc_resolution / (float) picture->timeinc_unit;
 350     if(fixed_fps)
 351       picture->fps /= 2;
 352   }
 353
 354   //fprintf(stderr, "H264_PARSE_VUI, OVESCAN=%u, VSP_COLOR=%u, CHROMA=%u, TIMING=%u, DISPW=%u, DISPH=%u, TIMERES=%u, TIMEINC=%u, FIXED_FPS=%u\n", overscan, vsp_color, chroma, timing, picture->display_picture_width, picture->display_picture_height,
 355   //    picture->timeinc_resolution, picture->timeinc_unit, picture->timeinc_unit, fixed_fps);
 356
 357   return n;
 358 }
 359
 360 static int mp_unescape03(unsigned char *buf, int len);
 361
 362 int h264_parse_sps(mp_mpeg_header_t * picture, unsigned char * buf, int len)
 363 {
 364   unsigned int n = 0, v, i, mbh;
 365   int frame_mbs_only;
 366
 367   len = mp_unescape03(buf, len);
 368
 369   picture->fps = picture->timeinc_unit = picture->timeinc_resolution = 0;
 370   n = 24;
 371   read_golomb(buf, &n);
 372   if(buf[0] >= 100){
 373     if(read_golomb(buf, &n) == 3)
 374       n++;
 375     read_golomb(buf, &n);
 376     read_golomb(buf, &n);
 377     n++;
 378     if(getbits(buf, n++, 1)){
 379       //FIXME scaling matrix
 380     }
 381   }
 382   read_golomb(buf, &n);
 383   v = read_golomb(buf, &n);
 384   if(v == 0)
 385     read_golomb(buf, &n);
 386   else if(v == 1)
 387   {
 388     getbits(buf, n++, 1);
 389     read_golomb(buf, &n);
 390     read_golomb(buf, &n);
 391     v = read_golomb(buf, &n);
 392     for(i = 0; i < v; i++)
 393       read_golomb(buf, &n);
 394   }
 395   read_golomb(buf, &n);
 396   getbits(buf, n++, 1);
 397   picture->display_picture_width = 16 *(read_golomb(buf, &n)+1);
 398   mbh = read_golomb(buf, &n)+1;
 399   frame_mbs_only = getbits(buf, n++, 1);
 400   picture->display_picture_height = 16 * (2 - frame_mbs_only) * mbh;
 401   if(!frame_mbs_only)
 402     getbits(buf, n++, 1);
 403   getbits(buf, n++, 1);
 404   if(getbits(buf, n++, 1))
 405   {
 406     read_golomb(buf, &n);
 407     read_golomb(buf, &n);
 408     read_golomb(buf, &n);
 409     read_golomb(buf, &n);
 410   }
 411   if(getbits(buf, n++, 1))
 412     n = h264_parse_vui(picture, buf, n);
 413
 414   return n;
 415 }
 416
 417 static int mp_unescape03(unsigned char *buf, int len)
 418 {
 419   unsigned char *dest;
 420   int i, j, skip;
 421
 422   dest = malloc(len);
 423   if(! dest)
 424     return 0;
 425
 426   j = i = skip = 0;
 427   while(i <= len-3)
 428   {
 429     if(buf[i] == 0 && buf[i+1] == 0 && buf[i+2] == 3)
 430     {
 431       dest[j] = dest[j+1] = 0;
 432       j += 2;
 433       i += 3;
 434       skip++;
 435     }
 436     else
 437     {
 438       dest[j] = buf[i];
 439       j++;
 440       i++;
 441     }
 442   }
 443   dest[j] = buf[len-2];
 444   dest[j+1] = buf[len-1];
 445   len -= skip;
 446   memcpy(buf, dest, len);
 447   free(dest);
 448
 449   return len;
 450 }
 451
 452 int mp_vc1_decode_sequence_header(mp_mpeg_header_t * picture, unsigned char * buf, int len)
 453 {
 454   int n, x;
 455
 456   len = mp_unescape03(buf, len);
 457
 458   picture->display_picture_width = picture->display_picture_height = 0;
 459   picture->fps = 0;
 460   n = 0;
 461   x = getbits(buf, n, 2);
 462   n += 2;
 463   if(x != 3) //not advanced profile
 464     return 0;
 465
 466   getbits16(buf, n, 14);
 467   n += 14;
 468   picture->display_picture_width = getbits16(buf, n, 12) * 2 + 2;
 469   n += 12;
 470   picture->display_picture_height = getbits16(buf, n, 12) * 2 + 2;
 471   n += 12;
 472   getbits(buf, n, 6);
 473   n += 6;
 474   x = getbits(buf, n, 1);
 475   n += 1;
 476   if(x) //display info
 477   {
 478     getbits16(buf, n, 14);
 479     n += 14;
 480     getbits16(buf, n, 14);
 481     n += 14;
 482     if(getbits(buf, n++, 1)) //aspect ratio
 483     {
 484       x = getbits(buf, n, 4);
 485       n += 4;
 486       if(x == 15)
 487       {
 488         getbits16(buf, n, 16);
 489         n += 16;
 490       }
 491     }
 492
 493     if(getbits(buf, n++, 1)) //framerates
 494     {
 495       int frexp=0, frnum=0, frden=0;
 496
 497       if(getbits(buf, n++, 1))
 498       {
 499         frexp = getbits16(buf, n, 16);
 500         n += 16;
 501         picture->fps = (double) (frexp+1) / 32.0;
 502       }
 503       else
 504       {
 505         float frates[] = {0, 24000, 25000, 30000, 50000, 60000, 48000, 72000, 0};
 506         float frdivs[] = {0, 1000, 1001, 0};
 507
 508         frnum = getbits(buf, n, 8);
 509         n += 8;
 510         frden = getbits(buf, n, 4);
 511         n += 4;
 512         if((frden == 1 || frden == 2) && (frnum < 8))
 513             picture->fps = frates[frnum] / frdivs[frden];
 514       }
 515     }
 516   }
 517
 518   //free(dest);
 519   return 1;
 520 }