DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Header

Mercurial (d609eb2a8fe2)

VCS Links

There was only 1 search result, so I took you straight to it.
Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

/* MPEG format parsing */

#include "mp3sniff.h"

/* Maximum packet size is 320 kbits/s * 144 / 32 kHz + 1 padding byte */
#define MP3_MAX_SIZE 1441

typedef struct {
  int version;
  int layer;
  int errp;
  int bitrate;
  int freq;
  int pad;
  int priv;
  int mode;
  int modex;
  int copyright;
  int original;
  int emphasis;
} mp3_header;

/* Parse the 4-byte header in p and fill in the header struct. */
static void mp3_parse(const uint8_t* p, mp3_header* header) {
  const int bitrates[2][16] = {
      /* MPEG version 1 layer 3 bitrates. */
      {0, 32000, 40000, 48000, 56000, 64000, 80000, 96000, 112000, 128000,
       160000, 192000, 224000, 256000, 320000, 0},
      /* MPEG Version 2 and 2.5 layer 3 bitrates */
      {0, 8000, 16000, 24000, 32000, 40000, 48000, 56000, 64000, 80000, 96000,
       112000, 128000, 144000, 160000, 0}};
  const int samplerates[4] = {44100, 48000, 32000, 0};

  header->version = (p[1] & 0x18) >> 3;
  header->layer = 4 - ((p[1] & 0x06) >> 1);
  header->errp = (p[1] & 0x01);

  header->bitrate = bitrates[(header->version & 1) ? 0 : 1][(p[2] & 0xf0) >> 4];
  header->freq = samplerates[(p[2] & 0x0c) >> 2];
  if (header->version == 2)
    header->freq >>= 1;
  else if (header->version == 0)
    header->freq >>= 2;
  header->pad = (p[2] & 0x02) >> 1;
  header->priv = (p[2] & 0x01);

  header->mode = (p[3] & 0xc0) >> 6;
  header->modex = (p[3] & 0x30) >> 4;
  header->copyright = (p[3] & 0x08) >> 3;
  header->original = (p[3] & 0x04) >> 2;
  header->emphasis = (p[3] & 0x03);
}

/* calculate the size of an mp3 frame from its header */
static int mp3_framesize(mp3_header* header) {
  int size;
  int scale;

  if ((header->version & 1) == 0)
    scale = 72;
  else
    scale = 144;
  size = header->bitrate * scale / header->freq;
  if (header->pad) size += 1;

  return size;
}

static int is_mp3(const uint8_t* p, long length) {
  /* Do we have enough room to see a 4 byte header? */
  if (length < 4) return 0;
  /* Do we have a sync pattern? */
  if (p[0] == 0xff && (p[1] & 0xe0) == 0xe0) {
    /* Do we have any illegal field values? */
    if (((p[1] & 0x06) >> 1) == 0) return 0;  /* No layer 4 */
    if (((p[2] & 0xf0) >> 4) == 15) return 0; /* Bitrate can't be 1111 */
    if (((p[2] & 0x0c) >> 2) == 3) return 0;  /* Samplerate can't be 11 */
    /* Looks like a header. */
    if ((4 - ((p[1] & 0x06) >> 1)) != 3) return 0; /* Only want level 3 */
    return 1;
  }
  return 0;
}

/* Identify an ID3 tag based on its header. */
/* http://id3.org/id3v2.4.0-structure */
static int is_id3(const uint8_t* p, long length) {
  /* Do we have enough room to see the header? */
  if (length < 10) return 0;
  /* Do we have a sync pattern? */
  if (p[0] == 'I' && p[1] == 'D' && p[2] == '3') {
    if (p[3] == 0xff || p[4] == 0xff) return 0; /* Illegal version. */
    if (p[6] & 0x80 || p[7] & 0x80 || p[8] & 0x80)
      return 0; /* Bad length encoding. */
    /* Looks like an id3 header. */
    return 1;
  }
  return 0;
}

/* Calculate the size of an id3 tag structure from its header. */
static int id3_framesize(const uint8_t* p, long length) {
  int size;

  /* Header is 10 bytes. */
  if (length < 10) {
    return 0;
  }
  /* Frame is header plus declared size. */
  size = 10 + (p[9] | (p[8] << 7) | (p[7] << 14) | (p[6] << 21));

  return size;
}

int mp3_sniff(const uint8_t* buf, long length) {
  mp3_header header;
  const uint8_t* p;
  long skip;
  long avail;

  p = buf;
  avail = length;
  while (avail >= 4) {
    if (is_id3(p, avail)) {
      /* Skip over any id3 tags */
      skip = id3_framesize(p, avail);
      p += skip;
      avail -= skip;
    } else if (is_mp3(p, avail)) {
      mp3_parse(p, &header);
      skip = mp3_framesize(&header);
      if (skip < 4 || skip + 4 >= avail) {
        return 0;
      }
      p += skip;
      avail -= skip;
      /* Check for a second header at the expected offset. */
      if (is_mp3(p, avail)) {
        /* Looks like mp3. */
        return 1;
      } else {
        /* No second header. Not mp3. */
        return 0;
      }
    } else {
      /* No id3 tag or mp3 header. Not mp3. */
      return 0;
    }
  }

  return 0;
}