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