exiftool_vendored 10.31.0 → 10.40.0

data/bin/Image-ExifTool-10.40/lib/Image/ExifTool/MOI.pm

@@ -0,0 +1,158 @@
+#------------------------------------------------------------------------------
+# File:         MOI.pm
+#
+# Description:  Read MOI meta information
+#
+# Revisions:    2014/12/15 - P. Harvey Created
+#
+# References:   1) https://en.wikipedia.org/wiki/MOI_(file_format)
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::MOI;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.02';
+
+# MOI tags (ref 1)
+%Image::ExifTool::MOI::Main = (
+    GROUPS => { 2 => 'Video' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    NOTES => q{
+        MOI files store information about associated MOD or TOD files, and are
+        written by some JVC, Canon and Panasonic camcorders.
+    },
+    0x00 => { Name => 'MOIVersion',  Format => 'string[2]' },
+  # 0x02 => { Name => 'MOIFileSize', Format => 'int32u' },
+    0x06 => {
+        Name => 'DateTimeOriginal',
+        Format => 'undef[8]',
+        Groups => { 2 => 'Time' },
+        ValueConv => sub {
+            my $val = shift;
+            return undef unless length($val) >= 8;
+            my @v = unpack('nCCCCn', $val);
+            $v[5] /= 1000;
+            return sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%06.3f', @v);
+        },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    0x0e => {
+        Name => 'Duration',
+        Format => 'int32u',
+        ValueConv => '$val / 1000',
+        PrintConv => 'ConvertDuration($val)',
+    },
+    0x80 => {
+        Name => 'AspectRatio',
+        Format => 'int8u',
+        PrintConv => q{
+            my $lo = ($val & 0x0f);
+            my $hi = ($val >> 4);
+            my $aspect;
+            if ($lo < 2) {
+                $aspect = '4:3';
+            } elsif ($lo == 4 or $lo == 5) {
+                $aspect = '16:9';
+            } else {
+                $aspect = 'Unknown';
+            }
+            if ($hi == 4) {
+                $aspect .= ' NTSC';
+            } elsif ($hi == 5) {
+                $aspect .= ' PAL';
+            }
+            return $aspect;
+        },
+    },
+    0x84 => {
+        Name => 'AudioCodec',
+        Format => 'int16u',
+        Groups => { 2 => 'Audio' },
+        PrintHex => 1,
+        PrintConv => {
+            0x00c1 => 'AC3',
+            0x4001 => 'MPEG',
+        },
+    },
+    0x86 => {
+        Name => 'AudioBitrate',
+        Format => 'int8u',
+        Groups => { 2 => 'Audio' },
+        ValueConv => '$val * 16000 + 48000',
+        PrintConv => 'ConvertBitrate($val)',
+    },
+    0xda => {
+        Name => 'VideoBitrate',
+        Format => 'int16u',
+        PrintHex => 1,
+        ValueConv => {
+            0x5896 => '8500000',
+            0x813d => '5500000',
+        },
+        PrintConv => 'ConvertBitrate($val)',
+    },
+);
+
+#------------------------------------------------------------------------------
+# Validate and extract metadata from MOI file
+# Inputs: 0) ExifTool ref, 1) dirInfo ref
+# Returns: 1 on success, 0 if this wasn't a valid MOI file
+sub ProcessMOI($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $buff;
+    # read enough to allow skipping over run-in if it exists
+    $raf->Read($buff, 256) == 256 and $buff =~ /^V6/ or return 0;
+    if (defined $$et{VALUE}{FileSize}) {
+        my $size = unpack('x2N', $buff);
+        $size == $$et{VALUE}{FileSize} or return 0;
+    }
+    $et->SetFileType();
+    SetByteOrder('MM');
+    my $tagTablePtr = GetTagTable('Image::ExifTool::MOI::Main');
+    return $et->ProcessBinaryData({ DataPt => \$buff }, $tagTablePtr);
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::MOI - Read MOI meta information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to read meta
+information from MOI files.
+
+=head1 AUTHOR
+
+Copyright 2003-2017, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<https://en.wikipedia.org/wiki/MOI_(file_format)>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/MOI Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

data/bin/Image-ExifTool-10.40/lib/Image/ExifTool/MPC.pm

@@ -0,0 +1,156 @@
+#------------------------------------------------------------------------------
+# File:         MPC.pm
+#
+# Description:  Read Musepack audio meta information
+#
+# Revisions:    11/14/2006 - P. Harvey Created
+#
+# References:   1) http://www.musepack.net/
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::MPC;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::FLAC;
+
+$VERSION = '1.01';
+
+# MPC metadata blocks
+%Image::ExifTool::MPC::Main = (
+    PROCESS_PROC => \&Image::ExifTool::FLAC::ProcessBitStream,
+    GROUPS => { 2 => 'Audio' },
+    NOTES => q{
+        Tags used in Musepack (MPC) audio files.  ExifTool also extracts ID3 and APE
+        information from these files.
+    },
+    'Bit032-063' => 'TotalFrames',
+    'Bit080-081' => {
+        Name => 'SampleRate',
+        PrintConv => {
+            0 => 44100,
+            1 => 48000,
+            2 => 37800,
+            3 => 32000,
+        },
+    },
+    'Bit084-087' => {
+        Name => 'Quality',
+        PrintConv => {
+             1 => 'Unstable/Experimental',
+             5 => '0',
+             6 => '1',
+             7 => '2 (Telephone)',
+             8 => '3 (Thumb)',
+             9 => '4 (Radio)',
+            10 => '5 (Standard)',
+            11 => '6 (Xtreme)',
+            12 => '7 (Insane)',
+            13 => '8 (BrainDead)',
+            14 => '9',
+            15 => '10',
+       },
+    },
+    'Bit088-093' => 'MaxBand',
+    'Bit096-111' => 'ReplayGainTrackPeak',
+    'Bit112-127' => 'ReplayGainTrackGain',
+    'Bit128-143' => 'ReplayGainAlbumPeak',
+    'Bit144-159' => 'ReplayGainAlbumGain',
+    'Bit179' => {
+        Name => 'FastSeek',
+        PrintConv => { 0 => 'No', 1 => 'Yes' },
+    },
+    'Bit191' => {
+        Name => 'Gapless',
+        PrintConv => { 0 => 'No', 1 => 'Yes' },
+    },
+    'Bit216-223' => {
+        Name => 'EncoderVersion',
+        PrintConv => '$val =~ s/(\d)(\d)(\d)$/$1.$2.$3/; $val',
+    },
+);
+
+#------------------------------------------------------------------------------
+# Extract information from an MPC file
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# - Just looks for MPC trailer if FileType is already set
+# Returns: 1 on success, 0 if this wasn't a valid MPC file
+sub ProcessMPC($$)
+{
+    my ($et, $dirInfo) = @_;
+
+    # must first check for leading ID3 information
+    unless ($$et{DoneID3}) {
+        require Image::ExifTool::ID3;
+        Image::ExifTool::ID3::ProcessID3($et, $dirInfo) and return 1;
+    }
+    my $raf = $$dirInfo{RAF};
+    my $buff;
+
+    # check MPC signature
+    $raf->Read($buff, 32) == 32 and $buff =~ /^MP\+(.)/s or return 0;
+    my $vers = ord($1) & 0x0f;
+    $et->SetFileType();
+
+    # extract audio information (currently only from version 7 MPC files)
+    if ($vers == 0x07) {
+        SetByteOrder('II');
+        my $pos = $raf->Tell() - 32;
+        if ($et->Options('Verbose')) {
+            $et->VPrint(0, "MPC Header (32 bytes):\n");
+            $et->VerboseDump(\$buff, DataPos => $pos);
+        }
+        my $tagTablePtr = GetTagTable('Image::ExifTool::MPC::Main');
+        my %dirInfo = ( DataPt => \$buff, DataPos => $pos );
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
+    } else {
+        $et->Warn('Audio info currently not extracted from this version MPC file');
+    }
+
+    # process APE trailer if it exists
+    require Image::ExifTool::APE;
+    Image::ExifTool::APE::ProcessAPE($et, $dirInfo);
+
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::MPC - Read Musepack audio meta information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to extract meta
+information from Musepack (MPC) audio files.
+
+=head1 AUTHOR
+
+Copyright 2003-2017, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://www.musepack.net/>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/MPC Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

data/bin/Image-ExifTool-10.40/lib/Image/ExifTool/MPEG.pm

@@ -0,0 +1,736 @@
+#------------------------------------------------------------------------------
+# File:         MPEG.pm
+#
+# Description:  Read MPEG-1 and MPEG-2 meta information
+#
+# Revisions:    05/11/2006 - P. Harvey Created
+#
+# References:   1) http://www.mp3-tech.org/
+#               2) http://www.getid3.org/
+#               3) http://dvd.sourceforge.net/dvdinfo/dvdmpeg.html
+#               4) http://ffmpeg.org/
+#               5) http://sourceforge.net/projects/mediainfo/
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::MPEG;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.15';
+
+%Image::ExifTool::MPEG::Audio = (
+    GROUPS => { 2 => 'Audio' },
+    'Bit11-12' => {
+        Name => 'MPEGAudioVersion',
+        RawConv => '$self->{MPEG_Vers} = $val',
+        PrintConv => {
+            0 => 2.5,
+            2 => 2,
+            3 => 1,
+        },
+    },
+    'Bit13-14' => {
+        Name => 'AudioLayer',
+        RawConv => '$self->{MPEG_Layer} = $val',
+        PrintConv => {
+            1 => 3,
+            2 => 2,
+            3 => 1,
+        },
+    },
+    # Bit 15 indicates CRC protection
+    'Bit16-19' => [
+        {
+            Name => 'AudioBitrate',
+            Condition => '$self->{MPEG_Vers} == 3 and $self->{MPEG_Layer} == 3',
+            Notes => 'version 1, layer 1',
+            PrintConvColumns => 3,
+            ValueConv => {
+                0 => 'free',
+                1 => 32000,
+                2 => 64000,
+                3 => 96000,
+                4 => 128000,
+                5 => 160000,
+                6 => 192000,
+                7 => 224000,
+                8 => 256000,
+                9 => 288000,
+                10 => 320000,
+                11 => 352000,
+                12 => 384000,
+                13 => 416000,
+                14 => 448000,
+            },
+            PrintConv => 'ConvertBitrate($val)',
+        },
+        {
+            Name => 'AudioBitrate',
+            Condition => '$self->{MPEG_Vers} == 3 and $self->{MPEG_Layer} == 2',
+            Notes => 'version 1, layer 2',
+            PrintConvColumns => 3,
+            ValueConv => {
+                0 => 'free',
+                1 => 32000,
+                2 => 48000,
+                3 => 56000,
+                4 => 64000,
+                5 => 80000,
+                6 => 96000,
+                7 => 112000,
+                8 => 128000,
+                9 => 160000,
+                10 => 192000,
+                11 => 224000,
+                12 => 256000,
+                13 => 320000,
+                14 => 384000,
+            },
+            PrintConv => 'ConvertBitrate($val)',
+        },
+        {
+            Name => 'AudioBitrate',
+            Condition => '$self->{MPEG_Vers} == 3 and $self->{MPEG_Layer} == 1',
+            Notes => 'version 1, layer 3',
+            PrintConvColumns => 3,
+            ValueConv => {
+                0 => 'free',
+                1 => 32000,
+                2 => 40000,
+                3 => 48000,
+                4 => 56000,
+                5 => 64000,
+                6 => 80000,
+                7 => 96000,
+                8 => 112000,
+                9 => 128000,
+                10 => 160000,
+                11 => 192000,
+                12 => 224000,
+                13 => 256000,
+                14 => 320000,
+            },
+            PrintConv => 'ConvertBitrate($val)',
+        },
+        {
+            Name => 'AudioBitrate',
+            Condition => '$self->{MPEG_Vers} != 3 and $self->{MPEG_Layer} == 3',
+            Notes => 'version 2 or 2.5, layer 1',
+            PrintConvColumns => 3,
+            ValueConv => {
+                0 => 'free',
+                1 => 32000,
+                2 => 48000,
+                3 => 56000,
+                4 => 64000,
+                5 => 80000,
+                6 => 96000,
+                7 => 112000,
+                8 => 128000,
+                9 => 144000,
+                10 => 160000,
+                11 => 176000,
+                12 => 192000,
+                13 => 224000,
+                14 => 256000,
+            },
+            PrintConv => 'ConvertBitrate($val)',
+        },
+        {
+            Name => 'AudioBitrate',
+            Condition => '$self->{MPEG_Vers} != 3 and $self->{MPEG_Layer}',
+            Notes => 'version 2 or 2.5, layer 2 or 3',
+            PrintConvColumns => 3,
+            ValueConv => {
+                0 => 'free',
+                1 => 8000,
+                2 => 16000,
+                3 => 24000,
+                4 => 32000,
+                5 => 40000,
+                6 => 48000,
+                7 => 56000,
+                8 => 64000,
+                9 => 80000,
+                10 => 96000,
+                11 => 112000,
+                12 => 128000,
+                13 => 144000,
+                14 => 160000,
+            },
+            PrintConv => 'ConvertBitrate($val)',
+        },
+    ],
+    'Bit20-21' => [
+        {
+            Name => 'SampleRate',
+            Condition => '$self->{MPEG_Vers} == 3',
+            Notes => 'version 1',
+            PrintConv => {
+                0 => 44100,
+                1 => 48000,
+                2 => 32000,
+            },
+        },
+        {
+            Name => 'SampleRate',
+            Condition => '$self->{MPEG_Vers} == 2',
+            Notes => 'version 2',
+            PrintConv => {
+                0 => 22050,
+                1 => 24000,
+                2 => 16000,
+            },
+        },
+        {
+            Name => 'SampleRate',
+            Condition => '$self->{MPEG_Vers} == 0',
+            Notes => 'version 2.5',
+            PrintConv => {
+                0 => 11025,
+                1 => 12000,
+                2 => 8000,
+            },
+        },
+    ],
+    # Bit 22 - padding flag
+    # Bit 23 - private bit
+    'Bit24-25' => {
+        Name => 'ChannelMode',
+        RawConv => '$self->{MPEG_Mode} = $val',
+        PrintConv => {
+            0 => 'Stereo',
+            1 => 'Joint Stereo',
+            2 => 'Dual Channel',
+            3 => 'Single Channel',
+        },
+    },
+    'Bit26' => {
+        Name => 'MSStereo',
+        Condition => '$self->{MPEG_Layer} == 1',
+        Notes => 'layer 3',
+        PrintConv => { 0 => 'Off', 1 => 'On' },
+    },
+    'Bit27' => {
+        Name => 'IntensityStereo',
+        Condition => '$self->{MPEG_Layer} == 1',
+        Notes => 'layer 3',
+        PrintConv => { 0 => 'Off', 1 => 'On' },
+    },
+    'Bit26-27' => {
+        Name => 'ModeExtension',
+        Condition => '$self->{MPEG_Layer} > 1',
+        Notes => 'layer 1 or 2',
+        PrintConv => {
+            0 => 'Bands 4-31',
+            1 => 'Bands 8-31',
+            2 => 'Bands 12-31',
+            3 => 'Bands 16-31',
+        },
+    },
+    'Bit28'    => {
+        Name => 'CopyrightFlag',
+        PrintConv => {
+            0 => 'False',
+            1 => 'True',
+        },
+    },
+    'Bit29'    => {
+        Name => 'OriginalMedia',
+        PrintConv => {
+            0 => 'False',
+            1 => 'True',
+        },
+    },
+    'Bit30-31' => {
+        Name => 'Emphasis',
+        PrintConv => {
+            0 => 'None',
+            1 => '50/15 ms',
+            2 => 'reserved',
+            3 => 'CCIT J.17',
+        },
+    },
+);
+
+%Image::ExifTool::MPEG::Video = (
+    GROUPS => { 2 => 'Video' },
+    'Bit00-11' => 'ImageWidth',
+    'Bit12-23' => 'ImageHeight',
+    'Bit24-27' => {
+        Name => 'AspectRatio',
+        ValueConv => {
+            1 => 1,
+            2 => 0.6735,
+            3 => 0.7031,
+            4 => 0.7615,
+            5 => 0.8055,
+            6 => 0.8437,
+            7 => 0.8935,
+            8 => 0.9157,
+            9 => 0.9815,
+            10 => 1.0255,
+            11 => 1.0695,
+            12 => 1.0950,
+            13 => 1.1575,
+            14 => 1.2015,
+        },
+        PrintConv => {
+            1      => '1:1',
+            0.6735 => '0.6735',
+            0.7031 => '16:9, 625 line, PAL',
+            0.7615 => '0.7615',
+            0.8055 => '0.8055',
+            0.8437 => '16:9, 525 line, NTSC',
+            0.8935 => '0.8935',
+            0.9157 => '4:3, 625 line, PAL, CCIR601',
+            0.9815 => '0.9815',
+            1.0255 => '1.0255',
+            1.0695 => '1.0695',
+            1.0950 => '4:3, 525 line, NTSC, CCIR601',
+            1.1575 => '1.1575',
+            1.2015 => '1.2015',
+        },
+    },
+    'Bit28-31' => {
+        Name => 'FrameRate',
+        ValueConv => {
+            1 => 23.976,
+            2 => 24,
+            3 => 25,
+            4 => 29.97,
+            5 => 30,
+            6 => 50,
+            7 => 59.94,
+            8 => 60,
+        },
+        PrintConv => '"$val fps"',
+    },
+    'Bit32-49' => {
+        Name => 'VideoBitrate',
+        ValueConv => '$val eq 0x3ffff ? "Variable" : $val * 400',
+        PrintConv => 'ConvertBitrate($val)',
+    },
+    # these tags not very interesting
+    #'Bit50'    => 'MarkerBit',
+    #'Bit51-60' => 'VBVBufferSize',
+    #'Bit61'    => 'ConstrainedParamFlag',
+    #'Bit62'    => 'IntraQuantMatrixFlag',
+);
+
+%Image::ExifTool::MPEG::Xing = (
+    GROUPS => { 2 => 'Audio' },
+    VARS => { NO_ID => 1 },
+    NOTES => 'These tags are extracted from the Xing/Info frame.',
+    1 => { Name => 'VBRFrames' },
+    2 => { Name => 'VBRBytes' },
+    3 => { Name => 'VBRScale' },
+    4 => { Name => 'Encoder' },
+    5 => { Name => 'LameVBRQuality' },
+    6 => { Name => 'LameQuality' },
+    7 => { # (for documentation only)
+        Name => 'LameHeader',
+        SubDirectory => { TagTable => 'Image::ExifTool::MPEG::Lame' },
+    },
+);
+
+# Lame header tags (ref 5)
+%Image::ExifTool::MPEG::Lame = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Audio' },
+    NOTES => 'Tags extracted from Lame 3.90 or later header.',
+    9 => {
+        Name => 'LameMethod',
+        Mask => 0x0f,
+        PrintConv => {
+            1 => 'CBR',
+            2 => 'ABR',
+            3 => 'VBR (old/rh)',
+            4 => 'VBR (new/mtrh)',
+            5 => 'VBR (old/rh)',
+            6 => 'VBR',
+            8 => 'CBR (2-pass)',
+            9 => 'ABR (2-pass)',
+        },
+    },
+    10 => {
+        Name => 'LameLowPassFilter',
+        ValueConv => '$val * 100',
+        PrintConv => '($val / 1000) . " kHz"',
+    },
+    # 19 - EncodingFlags
+    20 => {
+        Name => 'LameBitrate',
+        ValueConv => '$val * 1000',
+        PrintConv => 'ConvertBitrate($val)',
+    },
+    24 => {
+        Name => 'LameStereoMode',
+        Mask => 0x1c,
+        ValueConv => '$val >> 2',
+        PrintConv => {
+            0 => 'Mono',
+            1 => 'Stereo',
+            2 => 'Dual Channels',
+            3 => 'Joint Stereo',
+            4 => 'Forced Joint Stereo',
+            6 => 'Auto',
+            7 => 'Intensity Stereo',
+        },
+    },
+);
+
+# composite tags
+%Image::ExifTool::MPEG::Composite = (
+    Duration => {
+        Groups => { 2 => 'Video' },
+        Require => {
+            0 => 'FileSize',
+        },
+        Desire => {
+            1 => 'ID3Size',
+            2 => 'MPEG:AudioBitrate',
+            3 => 'MPEG:VideoBitrate',
+            4 => 'MPEG:VBRFrames',
+            5 => 'MPEG:SampleRate',
+            6 => 'MPEG:MPEGAudioVersion',
+        },
+        Priority => -1, # (don't want to replace any other Duration tag)
+        ValueConv => q{
+            if ($val[4] and defined $val[5] and defined $val[6]) {
+                # calculate from number of VBR audio frames
+                my $mfs = $prt[5] / ($val[6] == 3 ? 144 : 72);
+                # calculate using VBR length
+                return 8 * $val[4] / $mfs;
+            }
+            # calculate duration as file size divided by total bitrate
+            # (note: this is only approximate!)
+            return undef unless $val[2] or $val[3];
+            return undef if $val[2] and not $val[2] =~ /^\d+$/;
+            return undef if $val[3] and not $val[3] =~ /^\d+$/;
+            return (8 * ($val[0] - ($val[1]||0))) / (($val[2]||0) + ($val[3]||0));
+        },
+        PrintConv => 'ConvertDuration($val) . " (approx)"',
+    },
+    AudioBitrate => {
+        Groups => { 2 => 'Audio' },
+        Notes => 'calculated for variable-bitrate MPEG audio',
+        Require => {
+            0 => 'MPEG:MPEGAudioVersion',
+            1 => 'MPEG:SampleRate',
+            2 => 'MPEG:VBRBytes',
+            3 => 'MPEG:VBRFrames',
+        },
+        ValueConv => q{
+            return undef unless $val[3];
+            my $mfs = $prt[1] / ($val[0] == 3 ? 144 : 72);
+            return $mfs * $val[2] / $val[3];
+        },
+        PrintConv => 'ConvertBitrate($val)',
+    },
+);
+
+# add our composite tags
+Image::ExifTool::AddCompositeTags('Image::ExifTool::MPEG');
+
+
+#------------------------------------------------------------------------------
+# Process information in an MPEG audio or video frame header
+# Inputs: 0) ExifTool object ref, 1) tag table ref, 2-N) list of 32-bit data words
+sub ProcessFrameHeader($$@)
+{
+    my ($et, $tagTablePtr, @data) = @_;
+    my $tag;
+    foreach $tag (sort keys %$tagTablePtr) {
+        next unless $tag =~ /^Bit(\d{2})-?(\d{2})?/;
+        my ($b1, $b2) = ($1, $2 || $1);
+        my $index = int($b1 / 32);
+        my $word = $data[$index];
+        my $mask = 0;
+        foreach (0 .. ($b2 - $b1)) {
+            $mask += (1 << $_);
+        }
+        my $val = ($word >> (31 + 32*$index - $b2)) & $mask;
+        $et->HandleTag($tagTablePtr, $tag, $val);
+    }
+}
+
+#------------------------------------------------------------------------------
+# Read MPEG audio frame header
+# Inputs: 0) ExifTool object reference, 1) Reference to audio data
+#         2) flag set if we are trying to recognized MP3 file only
+# Returns: 1 on success, 0 if no audio header was found
+sub ParseMPEGAudio($$;$)
+{
+    my ($et, $buffPt, $mp3) = @_;
+    my ($word, $pos);
+    my $ext = $$et{FILE_EXT} || '';
+
+    for (;;) {
+        # find frame sync
+        return 0 unless $$buffPt =~ m{(\xff.{3})}sg;
+        $word = unpack('N', $1);    # get audio frame header word
+        unless (($word & 0xffe00000) == 0xffe00000) {
+            pos($$buffPt) = pos($$buffPt) - 2;  # next possible location for frame sync
+            next;
+        }
+        # validate header as much as possible
+        if (($word & 0x180000) == 0x080000 or   # 01 is a reserved version ID
+            ($word & 0x060000) == 0x000000 or   # 00 is a reserved layer description
+            ($word & 0x00f000) == 0x000000 or   # 0000 is the "free" bitrate index
+            ($word & 0x00f000) == 0x00f000 or   # 1111 is a bad bitrate index
+            ($word & 0x000c00) == 0x000c00 or   # 11 is a reserved sampling frequency
+            ($word & 0x000003) == 0x000002 or   # 10 is a reserved emphasis
+            (($mp3 and ($word & 0x060000) != 0x020000))) # must be layer 3 for MP3
+        {
+            # give up easily unless this really should be an MP3 file
+            return 0 unless $ext eq 'MP3';
+            pos($$buffPt) = pos($$buffPt) - 1;
+            next;
+        }
+        $pos = pos($$buffPt);
+        last;
+    }
+    # set file type if not done already
+    $et->SetFileType();
+
+    my $tagTablePtr = GetTagTable('Image::ExifTool::MPEG::Audio');
+    ProcessFrameHeader($et, $tagTablePtr, $word);
+
+    # extract the VBR information (ref MP3::Info)
+    my ($v, $m) = ($$et{MPEG_Vers}, $$et{MPEG_Mode});
+    while (defined $v and defined $m) {
+        my $len = length $$buffPt;
+        $pos += $v == 3 ? ($m == 3 ? 17 : 32) : ($m == 3 ?  9 : 17);
+        last if $pos + 8 > $len;
+        my $buff = substr($$buffPt, $pos, 8);
+        last unless $buff =~ /^(Xing|Info)/;
+        my $xingTable = GetTagTable('Image::ExifTool::MPEG::Xing');
+        my $vbrScale;
+        my $flags = unpack('x4N', $buff);
+        my $isVBR = ($buff !~ /^Info/);     # Info frame is not VBR (ref 5)
+        $pos += 8;
+        if ($flags & 0x01) {    # VBRFrames
+            last if $pos + 4 > $len;
+            $et->HandleTag($xingTable, 1, unpack("x${pos}N", $$buffPt)) if $isVBR;
+            $pos += 4;
+        }
+        if ($flags & 0x02) {    # VBRBytes
+            last if $pos + 4 > $len;
+            $et->HandleTag($xingTable, 2, unpack("x${pos}N", $$buffPt)) if $isVBR;
+            $pos += 4;
+        }
+        if ($flags & 0x04) {    # VBR_TOC
+            last if $pos + 100 > $len;
+            # (ignore toc for now)
+            $pos += 100;
+        }
+        if ($flags & 0x08) {    # VBRScale
+            last if $pos + 4 > $len;
+            $vbrScale = unpack("x${pos}N", $$buffPt);
+            $et->HandleTag($xingTable, 3, $vbrScale) if $isVBR;
+            $pos += 4;
+        }
+        # process Lame header (ref 5)
+        if ($flags & 0x10) {    # Lame
+            last if $pos + 348 > $len;
+        } elsif ($pos + 4 <= $len) {
+            my $lib = substr($$buffPt, $pos, 4);
+            unless ($lib eq 'LAME' or $lib eq 'GOGO') {
+                # attempt to identify other encoders
+                my $n;
+                if (index($$buffPt, 'RCA mp3PRO Encoder') >= 0) {
+                    $lib = 'RCA mp3PRO';
+                } elsif (($n = index($$buffPt, 'THOMSON mp3PRO Encoder')) >= 0) {
+                    $lib = 'Thomson mp3PRO';
+                    $n += 22;
+                    $lib .= ' ' . substr($$buffPt, $n, 6) if length($$buffPt) - $n >= 6;
+                } elsif (index($$buffPt, 'MPGE') >= 0) {
+                    $lib = 'Gogo (<3.0)';
+                } else {
+                    last;
+                }
+                $et->HandleTag($xingTable, 4, $lib);
+                last;
+            }
+        }
+        my $lameLen = $len - $pos;
+        last if $lameLen < 9;
+        my $enc = substr($$buffPt, $pos, 9);
+        if ($enc ge 'LAME3.90') {
+            $et->HandleTag($xingTable, 4, $enc);
+            if ($vbrScale <= 100) {
+                $et->HandleTag($xingTable, 5, int((100 - $vbrScale) / 10));
+                $et->HandleTag($xingTable, 6, (100 - $vbrScale) % 10);
+            }
+            my %dirInfo = (
+                DataPt   => $buffPt,
+                DirStart => $pos,
+                DirLen   => length($$buffPt) - $pos,
+            );
+            my $subTablePtr = GetTagTable('Image::ExifTool::MPEG::Lame');
+            $et->ProcessDirectory(\%dirInfo, $subTablePtr);
+        } else {
+            $et->HandleTag($xingTable, 4, substr($$buffPt, $pos, 20));
+        }
+        last;   # (didn't want to loop anyway)
+    }
+
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Read MPEG video frame header
+# Inputs: 0) ExifTool object reference, 1) Reference to video data
+# Returns: 1 on success, 0 if no video header was found
+sub ProcessMPEGVideo($$)
+{
+    my ($et, $buffPt) = @_;
+
+    return 0 unless length $$buffPt >= 4;
+    my ($w1, $w2) = unpack('N2', $$buffPt);
+    # validate as much as possible
+    if (($w1 & 0x000000f0) == 0x00000000 or     # 0000 is a forbidden aspect ratio
+        ($w1 & 0x000000f0) == 0x000000f0 or     # 1111 is a reserved aspect ratio
+        ($w1 & 0x0000000f) == 0 or              # frame rate must be 1-8
+        ($w1 & 0x0000000f) > 8)
+    {
+        return 0;
+    }
+    # set file type if not done already
+    $et->SetFileType('MPEG') unless $$et{VALUE}{FileType};
+
+    my $tagTablePtr = GetTagTable('Image::ExifTool::MPEG::Video');
+    ProcessFrameHeader($et, $tagTablePtr, $w1, $w2);
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Read MPEG audio and video frame headers
+# Inputs: 0) ExifTool object reference, 1) Reference to audio/video data
+# Returns: 1 on success, 0 if no video header was found
+# To Do: Properly parse MPEG streams:
+#   0xb7 - sequence end
+#   0xb9 - end code
+#   0xba - pack start code
+#   0xbb - system header
+#   0xbc - program map <-- should parse this
+#   0xbd - private stream 1 --> for VOB, this contains sub-streams:
+#           0x20-0x3f - pictures
+#           0x80-0x87 - audio (AC3,DTS,SDDS)
+#           0xa0-0xa7 - audio (LPCM)
+#   0xbe - padding
+#   0xbf - private stream 2
+#   0xc0-0xdf - audio stream
+#   0xe0-0xef - video stream
+sub ParseMPEGAudioVideo($$)
+{
+    my ($et, $buffPt) = @_;
+    my (%found, $didHdr);
+    my $rtnVal = 0;
+    my %proc = ( audio => \&ParseMPEGAudio, video => \&ProcessMPEGVideo );
+
+    delete $$et{AudioBitrate};
+    delete $$et{VideoBitrate};
+
+    while ($$buffPt =~ /\0\0\x01(\xb3|\xc0)/g) {
+        my $type = $1 eq "\xb3" ? 'video' : 'audio';
+        unless ($didHdr) {
+            # make sure we didn't miss an audio frame sync before this (eg. MP3 file)
+            # (the last byte of the 4-byte MP3 audio frame header word may be zero,
+            # but the 2nd last must be non-zero, so we need only check to pos-3)
+            my $buff = substr($$buffPt, 0, pos($$buffPt) - 3);
+            $found{audio} = 1 if ParseMPEGAudio($et, \$buff);
+            $didHdr = 1;
+        }
+        next if $found{$type};
+        my $len = length($$buffPt) - pos($$buffPt);
+        last if $len < 4;
+        $len > 256 and $len = 256;
+        my $dat = substr($$buffPt, pos($$buffPt), $len);
+        # process MPEG audio or video
+        if (&{$proc{$type}}($et, \$dat)) {
+            $rtnVal = 1;
+            $found{$type} = 1;
+            # done if we found audio and video
+            last if scalar(keys %found) == 2;
+        }
+    }
+    return $rtnVal;
+}
+
+#------------------------------------------------------------------------------
+# Read information from an MPEG file
+# Inputs: 0) ExifTool object reference, 1) Directory information reference
+# Returns: 1 on success, 0 if this wasn't a valid MPEG file
+sub ProcessMPEG($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $buff;
+
+    $raf->Read($buff, 4) == 4 or return 0;
+    return 0 unless $buff =~ /^\0\0\x01[\xb0-\xbf]/;
+    $et->SetFileType();
+
+    $raf->Seek(0,0);
+    $raf->Read($buff, 65536*4) or return 0;
+
+    return ParseMPEGAudioVideo($et, \$buff);
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::MPEG - Read MPEG-1 and MPEG-2 meta information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to read MPEG-1
+and MPEG-2 audio/video files.
+
+=head1 NOTES
+
+Since ISO charges money for the official MPEG specification, this module is
+based on unofficial sources which may be incomplete, inaccurate or outdated.
+
+=head1 AUTHOR
+
+Copyright 2003-2017, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://www.mp3-tech.org/>
+
+=item L<http://www.getid3.org/>
+
+=item L<http://dvd.sourceforge.net/dvdinfo/dvdmpeg.html>
+
+=item L<http://ffmpeg.org/>
+
+=item L<http://sourceforge.net/projects/mediainfo/>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/MPEG Tags>,
+L<MP3::Info(3pm)|MP3::Info>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+