github/mpv
1
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2024-08-24 07:21:49 +02:00
Code Releases Activity

libmpcodecs: remove redundant audio and video decoders

Browse Source 
Probably all of these are supported by libavcodec. Missing things can
be added back.

Also remove qtpalette.h. It was used by demux_mov.c, and should have
been deleted with commit 1fde09db6f.
This commit is contained in:
wm4 2012-08-18 11:17:35 +02:00
parent 6f7ba66817
commit 6a26b4a665
27 changed files with 1 additions and 7822 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Makefile
View File

@ -34,8 +34,6 @@ SRCS_COMMON-$(DVBIN) += stream/dvb_tune.c \
SRCS_COMMON-$(DVDREAD) += stream/stream_dvd.c \
stream/stream_dvd_common.c
SRCS_COMMON-$(FAAD) += libmpcodecs/ad_faad.c
# These filters use private headers and do not work with shared libavcodec.
SRCS_COMMON-$(FFMPEG_INTERNALS) += libmpcodecs/vf_mcdeint.c \
libmpcodecs/vf_spp.c \
@ -44,18 +42,13 @@ SRCS_COMMON-$(FTP) += stream/stream_ftp.c
SRCS_COMMON-$(GIF) += libmpdemux/demux_gif.c
SRCS_COMMON-$(HAVE_POSIX_SELECT) += libmpcodecs/vf_bmovl.c
SRCS_COMMON-$(HAVE_SYS_MMAN_H) += libaf/af_export.c osdep/mmap_anon.c
SRCS_COMMON-$(JPEG) += libmpcodecs/vd_ijpg.c
SRCS_COMMON-$(LADSPA) += libaf/af_ladspa.c
SRCS_COMMON-$(LIBA52) += libmpcodecs/ad_liba52.c
SRCS_COMMON-$(LIBASS) += libmpcodecs/vf_ass.c \
sub/ass_mp.c \
sub/sd_ass.c \
SRCS_COMMON-$(LIBBLURAY) += stream/stream_bluray.c
SRCS_COMMON-$(LIBBS2B) += libaf/af_bs2b.c
SRCS_COMMON-$(LIBDCA) += libmpcodecs/ad_libdca.c
SRCS_COMMON-$(LIBMAD) += libmpcodecs/ad_libmad.c
SRCS_COMMON-$(LIBPOSTPROC) += libmpcodecs/vf_pp.c
SRCS_COMMON-$(LIBSMBCLIENT) += stream/stream_smb.c
@ -83,7 +76,6 @@ SRCS_COMMON-$(NETWORKING) += stream/stream_netstream.c \
stream/tcp.c \
stream/stream_udp.c \
SRCS_COMMON-$(PNG) += libmpcodecs/vd_mpng.c
SRCS_COMMON-$(PRIORITY) += osdep/priority.c
SRCS_COMMON-$(PVR) += stream/stream_pvr.c
SRCS_COMMON-$(RADIO) += stream/stream_radio.c
@ -147,15 +139,8 @@ SRCS_COMMON = asxparser.c \
libaf/reorder_ch.c \
libaf/window.c \
libmpcodecs/ad.c \
libmpcodecs/ad_alaw.c \
libmpcodecs/ad_dvdpcm.c \
libmpcodecs/ad_ffmpeg.c \
libmpcodecs/ad_spdif.c \
libmpcodecs/ad_hwac3.c \
libmpcodecs/ad_hwmpa.c \
libmpcodecs/ad_imaadpcm.c \
libmpcodecs/ad_msadpcm.c \
libmpcodecs/ad_pcm.c \
libmpcodecs/dec_audio.c \
libmpcodecs/dec_video.c \
libmpcodecs/img_format.c \
@ -163,11 +148,6 @@ SRCS_COMMON = asxparser.c \
libmpcodecs/pullup.c \
libmpcodecs/vd.c \
libmpcodecs/vd_ffmpeg.c \
libmpcodecs/vd_hmblck.c \
libmpcodecs/vd_lzo.c \
libmpcodecs/vd_mtga.c \
libmpcodecs/vd_null.c \
libmpcodecs/vd_raw.c \
libmpcodecs/vf.c \
libmpcodecs/vf_1bpp.c \
libmpcodecs/vf_2xsai.c \
@ -257,7 +237,6 @@ SRCS_COMMON = asxparser.c \
libmpdemux/ebml.c \
libmpdemux/extension.c \
libmpdemux/mf.c \
libmpdemux/mp3_hdr.c \
libmpdemux/mp_taglists.c \
libmpdemux/video.c \
libvo/osd.c \
@ -359,7 +338,6 @@ DIRS = . \
libaf \
libao2 \
libmpcodecs \
libmpcodecs/native \
libmpdemux \
libvo \
osdep \

101
configure vendored
View File

@ -347,13 +347,9 @@ Codecs:
--enable-jpeg enable JPEG input/output support [autodetect]
--enable-libcdio enable libcdio support [autodetect]
--enable-libav skip Libav autodetection [autodetect]
--enable-faad enable FAAD2 (AAC) [autodetect]
--disable-ladspa disable LADSPA plugin support [autodetect]
--disable-libbs2b disable libbs2b audio filter support [autodetect]
--disable-mpg123 disable libmpg123 MP3 decoding support [autodetect]
--disable-mad disable libmad (MPEG audio) support [autodetect]
--enable-libdca enable libdca support [autodetect]
--disable-liba52 disable liba52 [autodetect]
Video output:
--enable-gl enable OpenGL video output [autodetect]
@ -461,11 +457,7 @@ _portaudio=auto
_jack=auto
_openal=no
_libcdio=auto
_mad=auto
_mpg123=auto
_liba52=auto
_libdca=auto
_faad=auto
_ladspa=auto
_libbs2b=auto
_vcd=auto
@ -664,18 +656,10 @@ for ac_option do
--disable-jack) _jack=no ;;
--enable-openal) _openal=yes ;;
--disable-openal) _openal=no ;;
--enable-mad) _mad=yes ;;
--disable-mad) _mad=no ;;
--enable-libcdio) _libcdio=yes ;;
--disable-libcdio) _libcdio=no ;;
--enable-mpg123) _mpg123=yes ;;
--disable-mpg123) _mpg123=no ;;
--enable-liba52) _liba52=yes ;;
--disable-liba52) _liba52=no ;;
--enable-libdca) _libdca=yes ;;
--disable-libdca) _libdca=no ;;
--enable-faad) _faad=yes ;;
--disable-faad) _faad=no ;;
--enable-ladspa) _ladspa=yes ;;
--disable-ladspa) _ladspa=no ;;
--enable-libbs2b) _libbs2b=yes ;;
@ -2856,22 +2840,6 @@ fi
echores "$_zlib"
echocheck "mad support"
if test "$_mad" = auto ; then
_mad=no
statement_check mad.h 'mad_synth_init(0)' -lmad && _mad=yes
fi
if test "$_mad" = yes ; then
def_mad='#define CONFIG_LIBMAD 1'
extra_ldflags="$extra_ldflags -lmad"
codecmodules="libmad $codecmodules"
else
def_mad='#undef CONFIG_LIBMAD'
nocodecmodules="libmad $nocodecmodules"
fi
echores "$_mad"
# Any version of libmpg123 that knows MPG123_RESYNC_LIMIT shall be fine.
# That is, 1.2.0 onwards. Recommened is 1.14 onwards, though.
echocheck "mpg123 support"
@ -2888,67 +2856,6 @@ else
fi
echores "$_mpg123"
echocheck "liba52 support"
def_liba52='#undef CONFIG_LIBA52'
if test "$_liba52" = auto ; then
_liba52=no
cat > $TMPC << EOF
#include <inttypes.h>
#include <a52dec/a52.h>
int main(void) { a52_state_t *testHand; testHand=a52_init(0); return 0; }
EOF
cc_check -la52 && _liba52=yes && extra_ldflags="$extra_ldflags -la52"
fi
if test "$_liba52" = yes ; then
def_liba52='#define CONFIG_LIBA52 1'
codecmodules="liba52 $codecmodules"
else
nocodecmodules="liba52 $nocodecmodules"
fi
echores "$_liba52"
echocheck "libdca support"
if test "$_libdca" = auto ; then
_libdca=no
for _ld_dca in -ldca -ldts ; do
statement_check_broken stdint.h dts.h 'dts_init(0)' $_ld_dca $_ld_lm &&
extra_ldflags="$extra_ldflags $_ld_dca" && _libdca=yes && break
done
fi
if test "$_libdca" = yes ; then
def_libdca='#define CONFIG_LIBDCA 1'
codecmodules="libdca $codecmodules"
else
def_libdca='#undef CONFIG_LIBDCA'
nocodecmodules="libdca $nocodecmodules"
fi
echores "$_libdca"
echocheck "FAAD2 support"
if test "$_faad" = auto ; then
_faad=no
cat > $TMPC << EOF
#include <neaacdec.h>
#ifndef FAAD_MIN_STREAMSIZE
#error Too old version
#endif
int main(void) { faacDecHandle testhand; faacDecFrameInfo testinfo;
testhand = faacDecOpen(); faacDecInit(0, 0, 0, 0, 0); return 0; }
EOF
cc_check -lfaad $_ld_lm && _faad=yes
fi
def_faad='#undef CONFIG_FAAD'
if test "$_faad" = yes ; then
def_faad='#define CONFIG_FAAD 1'
extra_ldflags="$extra_ldflags -lfaad"
codecmodules="faad2 $codecmodules"
else
nocodecmodules="faad2 $nocodecmodules"
fi
echores "$_faad"
echocheck "LADSPA plugin support"
if test "$_ladspa" = auto ; then
@ -3426,7 +3333,6 @@ DIRECT3D = $_direct3d
DVBIN = $_dvbin
DVDREAD = $_dvdread
DXR3 = $_dxr3
FAAD = $_faad
FTP = $_ftp
GIF = $_gif
GL = $_gl
@ -3439,14 +3345,11 @@ JACK = $_jack
JOYSTICK = $_joystick
JPEG = $_jpeg
LADSPA = $_ladspa
LIBA52 = $_liba52
LIBASS = $_ass
LIBASS_OSD = $_libass_osd
DUMMY_OSD = $_dummy_osd
LIBBLURAY = $_bluray
LIBBS2B = $_libbs2b
LIBDCA = $_libdca
LIBMAD = $_mad
LCMS2 = $_lcms2
LIBPOSTPROC = $libpostproc
LIBSMBCLIENT = $_smb
@ -3616,10 +3519,6 @@ $def_vcd
/* codec libraries */
$def_faad
$def_liba52
$def_libdca
$def_mad
$def_mpg123
$def_zlib

2602
etc/codecs.conf
View File

File diff suppressed because it is too large Load Diff

28
libmpcodecs/ad.c
View File

@ -33,42 +33,14 @@
extern const ad_functions_t mpcodecs_ad_mpg123;
extern const ad_functions_t mpcodecs_ad_ffmpeg;
extern const ad_functions_t mpcodecs_ad_liba52;
extern const ad_functions_t mpcodecs_ad_hwac3;
extern const ad_functions_t mpcodecs_ad_hwmpa;
extern const ad_functions_t mpcodecs_ad_pcm;
extern const ad_functions_t mpcodecs_ad_dvdpcm;
extern const ad_functions_t mpcodecs_ad_alaw;
extern const ad_functions_t mpcodecs_ad_imaadpcm;
extern const ad_functions_t mpcodecs_ad_faad;
extern const ad_functions_t mpcodecs_ad_libmad;
extern const ad_functions_t mpcodecs_ad_spdif;
extern const ad_functions_t mpcodecs_ad_libdca;
const ad_functions_t * const mpcodecs_ad_drivers[] =
{
#ifdef CONFIG_MPG123
&mpcodecs_ad_mpg123,
#endif
#ifdef CONFIG_LIBA52
&mpcodecs_ad_liba52,
#endif
&mpcodecs_ad_hwac3,
&mpcodecs_ad_hwmpa,
&mpcodecs_ad_ffmpeg,
&mpcodecs_ad_spdif,
&mpcodecs_ad_pcm,
&mpcodecs_ad_dvdpcm,
&mpcodecs_ad_alaw,
&mpcodecs_ad_imaadpcm,
#ifdef CONFIG_FAAD
&mpcodecs_ad_faad,
#endif
#ifdef CONFIG_LIBMAD
&mpcodecs_ad_libmad,
#endif
#ifdef CONFIG_LIBDCA
&mpcodecs_ad_libdca,
#endif
NULL
};

93
libmpcodecs/ad_alaw.c
View File

@ -1,93 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "config.h"
#include "ad_internal.h"
static const ad_info_t info =
{
"aLaw/uLaw audio decoder",
"alaw",
"Nick Kurshev",
"A'rpi",
""
};
LIBAD_EXTERN(alaw)
#include "native/alaw.h"
static int init(sh_audio_t *sh_audio)
{
/* aLaw audio codec:*/
if(!sh_audio->wf) return 0;
sh_audio->channels=sh_audio->wf->nChannels;
sh_audio->samplerate=sh_audio->wf->nSamplesPerSec;
sh_audio->i_bps=sh_audio->channels*sh_audio->samplerate;
sh_audio->samplesize=2;
return 1;
}
static int preinit(sh_audio_t *sh)
{
sh->audio_out_minsize=2048;
sh->ds->ss_div = 1; // 1 samples/packet
sh->ds->ss_mul = sh->wf->nChannels; // bytes/packet
return 1;
}
static void uninit(sh_audio_t *sh)
{
}
static int control(sh_audio_t *sh,int cmd,void* arg, ...)
{
int skip;
switch(cmd)
{
case ADCTRL_SKIP_FRAME:
skip=sh->i_bps/16;
skip=skip&(~3);
demux_read_data(sh->ds,NULL,skip);
return CONTROL_TRUE;
default:
return CONTROL_UNKNOWN;
}
return CONTROL_UNKNOWN;
}
static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
{
int len;
int l=demux_read_data(sh_audio->ds,buf,minlen/2);
unsigned short *d=(unsigned short *) buf;
unsigned char *s=buf;
len=2*l;
if(sh_audio->format==6 || sh_audio->format==0x77616C61){
/* aLaw */
while(l>0){ --l; d[l]=alaw2short[s[l]]; }
} else {
/* uLaw */
while(l>0){ --l; d[l]=ulaw2short[s[l]]; }
}
return len;
}

162
libmpcodecs/ad_dvdpcm.c
View File

@ -1,162 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "config.h"
#include "mp_msg.h"
#include "ad_internal.h"
static const ad_info_t info =
{
"Uncompressed DVD/VOB LPCM audio decoder",
"dvdpcm",
"Nick Kurshev",
"A'rpi",
""
};
LIBAD_EXTERN(dvdpcm)
static int init(sh_audio_t *sh)
{
/* DVD PCM Audio:*/
sh->i_bps = 0;
if(sh->codecdata_len==3){
// we have LPCM header:
unsigned char h=sh->codecdata[1];
sh->channels=1+(h&7);
switch((h>>4)&3){
case 0: sh->samplerate=48000;break;
case 1: sh->samplerate=96000;break;
case 2: sh->samplerate=44100;break;
case 3: sh->samplerate=32000;break;
}
switch ((h >> 6) & 3) {
case 0:
sh->sample_format = AF_FORMAT_S16_BE;
sh->samplesize = 2;
break;
case 1:
mp_tmsg(MSGT_DECAUDIO, MSGL_INFO, "Samples of this format are needed to improve support. Please contact the developers.\n");
sh->i_bps = sh->channels * sh->samplerate * 5 / 2;
case 2:
sh->sample_format = AF_FORMAT_S24_BE;
sh->samplesize = 3;
break;
default:
sh->sample_format = AF_FORMAT_S16_BE;
sh->samplesize = 2;
}
} else {
// use defaults:
sh->channels=2;
sh->samplerate=48000;
sh->sample_format = AF_FORMAT_S16_BE;
sh->samplesize = 2;
}
if (!sh->i_bps)
sh->i_bps = sh->samplesize * sh->channels * sh->samplerate;
return 1;
}
static int preinit(sh_audio_t *sh)
{
sh->audio_out_minsize=2048;
return 1;
}
static void uninit(sh_audio_t *sh)
{
}
static int control(sh_audio_t *sh,int cmd,void* arg, ...)
{
int skip;
switch(cmd)
{
case ADCTRL_SKIP_FRAME:
skip=sh->i_bps/16;
skip=skip&(~3);
demux_read_data(sh->ds,NULL,skip);
return CONTROL_TRUE;
}
return CONTROL_UNKNOWN;
}
static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
{
int j,len;
if (sh_audio->samplesize == 3) {
if (((sh_audio->codecdata[1] >> 6) & 3) == 1) {
// 20 bit
// not sure if the "& 0xf0" and "<< 4" are the right way around
// can somebody clarify?
for (j = 0; j < minlen; j += 12) {
char tmp[10];
len = demux_read_data(sh_audio->ds, tmp, 10);
if (len < 10) break;
// first sample
buf[j + 0] = tmp[0];
buf[j + 1] = tmp[1];
buf[j + 2] = tmp[8] & 0xf0;
// second sample
buf[j + 3] = tmp[2];
buf[j + 4] = tmp[3];
buf[j + 5] = tmp[8] << 4;
// third sample
buf[j + 6] = tmp[4];
buf[j + 7] = tmp[5];
buf[j + 8] = tmp[9] & 0xf0;
// fourth sample
buf[j + 9] = tmp[6];
buf[j + 10] = tmp[7];
buf[j + 11] = tmp[9] << 4;
}
len = j;
} else {
// 24 bit
for (j = 0; j < minlen; j += 12) {
char tmp[12];
len = demux_read_data(sh_audio->ds, tmp, 12);
if (len < 12) break;
// first sample
buf[j + 0] = tmp[0];
buf[j + 1] = tmp[1];
buf[j + 2] = tmp[8];
// second sample
buf[j + 3] = tmp[2];
buf[j + 4] = tmp[3];
buf[j + 5] = tmp[9];
// third sample
buf[j + 6] = tmp[4];
buf[j + 7] = tmp[5];
buf[j + 8] = tmp[10];
// fourth sample
buf[j + 9] = tmp[6];
buf[j + 10] = tmp[7];
buf[j + 11] = tmp[11];
}
len = j;
}
} else
len=demux_read_data(sh_audio->ds,buf,(minlen+3)&(~3));
return len;
}

324
libmpcodecs/ad_faad.c
View File

@ -1,324 +0,0 @@
/*
* MPlayer AAC decoder using libfaad2
*
* Copyright (C) 2002 Felix Buenemann <atmosfear at users.sourceforge.net>
*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <neaacdec.h>
#include "config.h"
#include "options.h"
#include "ad_internal.h"
#include "libaf/reorder_ch.h"
static const ad_info_t info =
{
"AAC (MPEG2/4 Advanced Audio Coding)",
"faad",
"Felix Buenemann",
"faad2",
"uses libfaad2"
};
LIBAD_EXTERN(faad)
/* configure maximum supported channels, *
* this is theoretically max. 64 chans */
#define FAAD_MAX_CHANNELS 8
#define FAAD_BUFFLEN (FAAD_MIN_STREAMSIZE*FAAD_MAX_CHANNELS)
//#define AAC_DUMP_COMPRESSED
static faacDecHandle faac_hdec;
static faacDecFrameInfo faac_finfo;
static int preinit(sh_audio_t *sh)
{
sh->audio_out_minsize=8192*FAAD_MAX_CHANNELS;
sh->audio_in_minsize=FAAD_BUFFLEN;
return 1;
}
static int aac_probe(unsigned char *buffer, int len)
{
int i = 0, pos = 0;
mp_msg(MSGT_DECAUDIO,MSGL_V, "\nAAC_PROBE: %d bytes\n", len);
while(i <= len-4) {
if(
((buffer[i] == 0xff) && ((buffer[i+1] & 0xf6) == 0xf0)) ||
(buffer[i] == 'A' && buffer[i+1] == 'D' && buffer[i+2] == 'I' && buffer[i+3] == 'F')
) {
pos = i;
break;
}
mp_msg(MSGT_DECAUDIO,MSGL_V, "AUDIO PAYLOAD: %x %x %x %x\n", buffer[i], buffer[i+1], buffer[i+2], buffer[i+3]);
i++;
}
mp_msg(MSGT_DECAUDIO,MSGL_V, "\nAAC_PROBE: ret %d\n", pos);
return pos;
}
static int init(sh_audio_t *sh)
{
struct MPOpts *opts = sh->opts;
unsigned long faac_samplerate;
unsigned char faac_channels;
int faac_init, pos = 0;
faac_hdec = faacDecOpen();
// If we don't get the ES descriptor, try manual config
if(!sh->codecdata_len && sh->wf) {
sh->codecdata_len = sh->wf->cbSize;
sh->codecdata = malloc(sh->codecdata_len);
memcpy(sh->codecdata, sh->wf+1, sh->codecdata_len);
mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"FAAD: codecdata extracted from WAVEFORMATEX\n");
}
if(!sh->codecdata_len || sh->format == mmioFOURCC('M', 'P', '4', 'L')) {
faacDecConfigurationPtr faac_conf;
/* Set the default object type and samplerate */
/* This is useful for RAW AAC files */
faac_conf = faacDecGetCurrentConfiguration(faac_hdec);
if(sh->samplerate)
faac_conf->defSampleRate = sh->samplerate;
/* XXX: FAAD support FLOAT output, how do we handle
* that (FAAD_FMT_FLOAT)? ::atmos
*/
if (opts->audio_output_channels <= 2)
faac_conf->downMatrix = 1;
switch(sh->samplesize){
case 1: // 8Bit
mp_msg(MSGT_DECAUDIO,MSGL_WARN,"FAAD: 8Bit samplesize not supported by FAAD, assuming 16Bit!\n");
default:
sh->samplesize=2;
case 2: // 16Bit
faac_conf->outputFormat = FAAD_FMT_16BIT;
break;
case 3: // 24Bit
faac_conf->outputFormat = FAAD_FMT_24BIT;
break;
case 4: // 32Bit
faac_conf->outputFormat = FAAD_FMT_32BIT;
break;
}
//faac_conf->defObjectType = LTP; // => MAIN, LC, SSR, LTP available.
faacDecSetConfiguration(faac_hdec, faac_conf);
sh->a_in_buffer_len = demux_read_data(sh->ds, sh->a_in_buffer, sh->a_in_buffer_size);
if (!sh->a_in_buffer_len) {
// faad init will crash with 0 buffer length
mp_msg(MSGT_DECAUDIO, MSGL_FATAL, "Could not get audio data!\n");
return 0;
}
/* external faad does not have latm lookup support */
faac_init = faacDecInit(faac_hdec, sh->a_in_buffer,
sh->a_in_buffer_len, &faac_samplerate, &faac_channels);
if (faac_init < 0) {
pos = aac_probe(sh->a_in_buffer, sh->a_in_buffer_len);
if(pos) {
sh->a_in_buffer_len -= pos;
memmove(sh->a_in_buffer, &(sh->a_in_buffer[pos]), sh->a_in_buffer_len);
sh->a_in_buffer_len +=
demux_read_data(sh->ds,&(sh->a_in_buffer[sh->a_in_buffer_len]),
sh->a_in_buffer_size - sh->a_in_buffer_len);
pos = 0;
}
/* init the codec */
faac_init = faacDecInit(faac_hdec, sh->a_in_buffer,
sh->a_in_buffer_len, &faac_samplerate, &faac_channels);
}
sh->a_in_buffer_len -= (faac_init > 0)?faac_init:0; // how many bytes init consumed
// XXX FIXME: shouldn't we memcpy() here in a_in_buffer ?? --A'rpi
} else { // We have ES DS in codecdata
faacDecConfigurationPtr faac_conf = faacDecGetCurrentConfiguration(faac_hdec);
if (opts->audio_output_channels <= 2) {
faac_conf->downMatrix = 1;
faacDecSetConfiguration(faac_hdec, faac_conf);
}
/*int i;
for(i = 0; i < sh_audio->codecdata_len; i++)
printf("codecdata_dump %d: 0x%02X\n", i, sh_audio->codecdata[i]);*/
faac_init = faacDecInit2(faac_hdec, sh->codecdata,
sh->codecdata_len, &faac_samplerate, &faac_channels);
}
if(faac_init < 0) {
mp_msg(MSGT_DECAUDIO,MSGL_WARN,"FAAD: Failed to initialize the decoder!\n"); // XXX: deal with cleanup!
faacDecClose(faac_hdec);
// XXX: free a_in_buffer here or in uninit?
return 0;
} else {
mp_msg(MSGT_DECAUDIO,MSGL_V,"FAAD: Decoder init done (%dBytes)!\n", sh->a_in_buffer_len); // XXX: remove or move to debug!
mp_msg(MSGT_DECAUDIO,MSGL_V,"FAAD: Negotiated samplerate: %ldHz channels: %d\n", faac_samplerate, faac_channels);
// 8 channels is aac channel order #7.
sh->channels = faac_channels == 7 ? 8 : faac_channels;
if (opts->audio_output_channels <= 2)
sh->channels = faac_channels > 1 ? 2 : 1;
sh->samplerate = faac_samplerate;
sh->samplesize=2;
//sh->o_bps = sh->samplesize*faac_channels*faac_samplerate;
if(!sh->i_bps) {
mp_msg(MSGT_DECAUDIO, MSGL_V, "FAAD: compressed input bitrate missing, assuming 128kbit/s!\n");
sh->i_bps = 128*1000/8; // XXX: HACK!!! ::atmos
} else
mp_msg(MSGT_DECAUDIO,MSGL_V,"FAAD: got %dkbit/s bitrate from MP4 header!\n",sh->i_bps*8/1000);
}
return 1;
}
static void uninit(sh_audio_t *sh)
{
mp_msg(MSGT_DECAUDIO,MSGL_V,"FAAD: Closing decoder!\n");
faacDecClose(faac_hdec);
}
static int aac_sync(sh_audio_t *sh)
{
int pos = 0;
// do not probe LATM, faad does that
if(!sh->codecdata_len && sh->format != mmioFOURCC('M', 'P', '4', 'L')) {
if(sh->a_in_buffer_len < sh->a_in_buffer_size){
sh->a_in_buffer_len +=
demux_read_data(sh->ds,&sh->a_in_buffer[sh->a_in_buffer_len],
sh->a_in_buffer_size - sh->a_in_buffer_len);
}
pos = aac_probe(sh->a_in_buffer, sh->a_in_buffer_len);
if(pos) {
sh->a_in_buffer_len -= pos;
memmove(sh->a_in_buffer, &(sh->a_in_buffer[pos]), sh->a_in_buffer_len);
mp_msg(MSGT_DECAUDIO,MSGL_V, "\nAAC SYNC AFTER %d bytes\n", pos);
}
}
return pos;
}
static int control(sh_audio_t *sh,int cmd,void* arg, ...)
{
switch(cmd)
{
case ADCTRL_RESYNC_STREAM:
aac_sync(sh);
return CONTROL_TRUE;
#if 0
case ADCTRL_SKIP_FRAME:
return CONTROL_TRUE;
#endif
}
return CONTROL_UNKNOWN;
}
#define MAX_FAAD_ERRORS 10
static int decode_audio(sh_audio_t *sh,unsigned char *buf,int minlen,int maxlen)
{
int len = 0, last_dec_len = 1, errors = 0;
// int j = 0;
void *faac_sample_buffer;
while(len < minlen && last_dec_len > 0 && errors < MAX_FAAD_ERRORS) {
/* update buffer for raw aac streams: */
if(!sh->codecdata_len)
if(sh->a_in_buffer_len < sh->a_in_buffer_size){
sh->a_in_buffer_len +=
demux_read_data(sh->ds,&sh->a_in_buffer[sh->a_in_buffer_len],
sh->a_in_buffer_size - sh->a_in_buffer_len);
}
#ifdef DUMP_AAC_COMPRESSED
{int i;
for (i = 0; i < 16; i++)
printf ("%02X ", sh->a_in_buffer[i]);
printf ("\n");}
#endif
if(!sh->codecdata_len){
// raw aac stream:
do {
faac_sample_buffer = faacDecDecode(faac_hdec, &faac_finfo, sh->a_in_buffer, sh->a_in_buffer_len);
/* update buffer index after faacDecDecode */
if(faac_finfo.bytesconsumed >= sh->a_in_buffer_len) {
sh->a_in_buffer_len=0;
} else {
sh->a_in_buffer_len-=faac_finfo.bytesconsumed;
memmove(sh->a_in_buffer,&sh->a_in_buffer[faac_finfo.bytesconsumed],sh->a_in_buffer_len);
}
if(faac_finfo.error > 0) {
mp_msg(MSGT_DECAUDIO,MSGL_WARN,"FAAD: error: %s, trying to resync!\n",
faacDecGetErrorMessage(faac_finfo.error));
if (sh->a_in_buffer_len <= 0) {
errors = MAX_FAAD_ERRORS;
break;
}
sh->a_in_buffer_len--;
memmove(sh->a_in_buffer,&sh->a_in_buffer[1],sh->a_in_buffer_len);
aac_sync(sh);
errors++;
} else
break;
} while(errors < MAX_FAAD_ERRORS);
} else {
// packetized (.mp4) aac stream:
unsigned char* bufptr=NULL;
double pts;
int buflen=ds_get_packet_pts(sh->ds, &bufptr, &pts);
if(buflen<=0) break;
if (pts != MP_NOPTS_VALUE) {
sh->pts = pts;
sh->pts_bytes = 0;
}
faac_sample_buffer = faacDecDecode(faac_hdec, &faac_finfo, bufptr, buflen);
}
//for (j=0;j<faac_finfo.channels;j++) printf("%d:%d\n", j, faac_finfo.channel_position[j]);
if(faac_finfo.error > 0) {
mp_msg(MSGT_DECAUDIO,MSGL_WARN,"FAAD: Failed to decode frame: %s \n",
faacDecGetErrorMessage(faac_finfo.error));
} else if (faac_finfo.samples == 0) {
mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"FAAD: Decoded zero samples!\n");
} else {
/* XXX: samples already multiplied by channels! */
mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"FAAD: Successfully decoded frame (%ld Bytes)!\n",
sh->samplesize*faac_finfo.samples);
if (sh->channels >= 5)
reorder_channel_copy_nch(faac_sample_buffer,
AF_CHANNEL_LAYOUT_AAC_DEFAULT,
buf+len, AF_CHANNEL_LAYOUT_MPLAYER_DEFAULT,
sh->channels,
faac_finfo.samples, sh->samplesize);
else
memcpy(buf+len,faac_sample_buffer, sh->samplesize*faac_finfo.samples);
last_dec_len = sh->samplesize*faac_finfo.samples;
len += last_dec_len;
sh->pts_bytes += last_dec_len;
//printf("FAAD: buffer: %d bytes consumed: %d \n", k, faac_finfo.bytesconsumed);
}
}
return len;
}

577
libmpcodecs/ad_hwac3.c
View File

@ -1,577 +0,0 @@
/*
* DTS code based on "ac3/decode_dts.c" and "ac3/conversion.c" from "ogle 0.9"
* (see http://www.dtek.chalmers.se/~dvd/)
* Reference: DOCS/tech/hwac3.txt !!!!!
*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#define _GNU_SOURCE
#define _XOPEN_SOURCE 600
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <libavutil/intreadwrite.h>
#include <libavutil/common.h>
#include "config.h"
#include "mp_msg.h"
#include "mpbswap.h"
#include "ad_internal.h"
static int isdts = -1;
static const ad_info_t info =
{
"AC3/DTS pass-through S/PDIF",
"hwac3",
"Nick Kurshev/Peter Schüller",
"???",
""
};
LIBAD_EXTERN(hwac3)
static int dts_syncinfo(uint8_t *indata_ptr, int *flags, int *sample_rate, int *bit_rate);
static int decode_audio_dts(unsigned char *indata_ptr, int len, unsigned char *buf);
static int a52_syncinfo (uint8_t *buf, int *sample_rate, int *bit_rate)
{
static const uint16_t rate[] = { 32, 40, 48, 56, 64, 80, 96, 112,
128, 160, 192, 224, 256, 320, 384, 448,
512, 576, 640};
int frmsizecod;
int bitrate;
int half;
if (buf[0] != 0x0b || buf[1] != 0x77) /* syncword */
return 0;
if (buf[5] >= 0x60) /* bsid >= 12 */
return 0;
half = buf[5] >> 3;
half = FFMAX(half - 8, 0);
frmsizecod = buf[4] & 63;
if (frmsizecod >= 38)
return 0;
bitrate = rate[frmsizecod >> 1];
*bit_rate = (bitrate * 1000) >> half;
switch (buf[4] & 0xc0) {
case 0:
*sample_rate = 48000 >> half;
return 4 * bitrate;
case 0x40:
*sample_rate = 44100 >> half;
return 2 * (320 * bitrate / 147 + (frmsizecod & 1));
case 0x80:
*sample_rate = 32000 >> half;
return 6 * bitrate;
default:
return 0;
}
}
static int ac3dts_fillbuff(sh_audio_t *sh_audio)
{
int length = 0;
int flags = 0;
int sample_rate = 0;
int bit_rate = 0;
sh_audio->a_in_buffer_len = 0;
/* sync frame:*/
while(1)
{
// Original code DTS has a 10 bytes header.
// Now max 12 bytes for 14 bits DTS header.
while(sh_audio->a_in_buffer_len < 12)
{
int c = demux_getc(sh_audio->ds);
if(c<0)
return -1; /* EOF*/
sh_audio->a_in_buffer[sh_audio->a_in_buffer_len++] = c;
}
if (sh_audio->format == 0x2001)
{
length = dts_syncinfo(sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
if(length >= 12)
{
if(isdts != 1)
{
mp_msg(MSGT_DECAUDIO, MSGL_STATUS, "hwac3: switched to DTS, %d bps, %d Hz\n", bit_rate, sample_rate);
isdts = 1;
}
break;
}
}
else
{
length = a52_syncinfo(sh_audio->a_in_buffer, &sample_rate, &bit_rate);
if(length >= 7 && length <= 3840)
{
if(isdts != 0)
{
mp_msg(MSGT_DECAUDIO, MSGL_STATUS, "hwac3: switched to AC3, %d bps, %d Hz\n", bit_rate, sample_rate);
isdts = 0;
}
break; /* we're done.*/
}
}
/* bad file => resync*/
memcpy(sh_audio->a_in_buffer, sh_audio->a_in_buffer + 1, 11);
--sh_audio->a_in_buffer_len;
}
mp_msg(MSGT_DECAUDIO, MSGL_DBG2, "ac3dts: %s len=%d flags=0x%X %d Hz %d bit/s\n", isdts == 1 ? "DTS" : isdts == 0 ? "AC3" : "unknown", length, flags, sample_rate, bit_rate);
sh_audio->samplerate = sample_rate;
sh_audio->i_bps = bit_rate / 8;
demux_read_data(sh_audio->ds, sh_audio->a_in_buffer + 12, length - 12);
sh_audio->a_in_buffer_len = length;
return length;
}
static int preinit(sh_audio_t *sh)
{
/* Dolby AC3 audio: */
sh->audio_out_minsize = 128 * 32 * 2 * 2; // DTS seems to need more than AC3
sh->audio_in_minsize = 8192;
sh->channels = 2;
sh->samplesize = 2;
sh->sample_format = AF_FORMAT_AC3_BE;
// HACK for DTS where useless swapping can't easily be removed
if (sh->format == 0x2001)
sh->sample_format = AF_FORMAT_AC3_NE;
return 1;
}
static int init(sh_audio_t *sh_audio)
{
/* Dolby AC3 passthrough:*/
if(ac3dts_fillbuff(sh_audio) < 0)
{
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "AC3/DTS sync failed\n");
return 0;
}
return 1;
}
static void uninit(sh_audio_t *sh)
{
}
static int control(sh_audio_t *sh,int cmd,void* arg, ...)
{
switch(cmd)
{
case ADCTRL_RESYNC_STREAM:
case ADCTRL_SKIP_FRAME:
ac3dts_fillbuff(sh);
return CONTROL_TRUE;
}
return CONTROL_UNKNOWN;
}
static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
{
int len = sh_audio->a_in_buffer_len;
if(len <= 0)
if((len = ac3dts_fillbuff(sh_audio)) <= 0)
return len; /*EOF*/
sh_audio->a_in_buffer_len = 0;
if(isdts == 1)
{
return decode_audio_dts(sh_audio->a_in_buffer, len, buf);
}
else if(isdts == 0)
{
AV_WB16(buf, 0xF872); // iec 61937 syncword 1
AV_WB16(buf + 2, 0x4E1F); // iec 61937 syncword 2
buf[4] = sh_audio->a_in_buffer[5] & 0x7; // bsmod
buf[5] = 0x01; // data-type ac3
AV_WB16(buf + 6, len << 3); // number of bits in payload
memcpy(buf + 8, sh_audio->a_in_buffer, len);
memset(buf + 8 + len, 0, 6144 - 8 - len);
return 6144;
}
else
return -1;
}
static const int DTS_SAMPLEFREQS[16] =
{
0,
8000,
16000,
32000,
64000,
128000,
11025,
22050,
44100,
88200,
176400,
12000,
24000,
48000,
96000,
192000
};
static const int DTS_BITRATES[30] =
{
32000,
56000,
64000,
96000,
112000,
128000,
192000,
224000,
256000,
320000,
384000,
448000,
512000,
576000,
640000,
768000,
896000,
1024000,
1152000,
1280000,
1344000,
1408000,
1411200,
1472000,
1536000,
1920000,
2048000,
3072000,
3840000,
4096000
};
static int dts_decode_header(uint8_t *indata_ptr, int *rate, int *nblks, int *sfreq)
{
int ftype;
int surp;
int unknown_bit av_unused;
int fsize;
int amode av_unused;
int word_mode;
int le_mode;
unsigned int first4bytes = indata_ptr[0] << 24 | indata_ptr[1] << 16
| indata_ptr[2] << 8 | indata_ptr[3];
switch(first4bytes)
{
/* 14 bits LE */
case 0xff1f00e8:
/* Also make sure frame type is 1. */
if ((indata_ptr[4]&0xf0) != 0xf0 || indata_ptr[5] != 0x07)
return -1;
word_mode = 0;
le_mode = 1;
break;
/* 14 bits BE */
case 0x1fffe800:
/* Also make sure frame type is 1. */
if (indata_ptr[4] != 0x07 || (indata_ptr[5]&0xf0) != 0xf0)
return -1;
word_mode = 0;
le_mode = 0;
break;
/* 16 bits LE */
case 0xfe7f0180:
word_mode = 1;
le_mode = 1;
break;
/* 16 bits BE */
case 0x7ffe8001:
word_mode = 1;
le_mode = 0;
break;
default:
return -1;
}
if(word_mode)
{
/* First bit after first 32 bits:
Frame type ( 1: Normal frame; 0: Termination frame ) */
ftype = indata_ptr[4+le_mode] >> 7;
if(ftype != 1)
{
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "DTS: Termination frames not handled, REPORT BUG\n");
return -1;
}
/* Next 5 bits: Surplus Sample Count V SURP 5 bits */
surp = indata_ptr[4+le_mode] >> 2 & 0x1f;
/* Number of surplus samples */
surp = (surp + 1) % 32;
/* One unknown bit, crc? */
unknown_bit = indata_ptr[4+le_mode] >> 1 & 0x01;
/* NBLKS 7 bits: Valid Range=5-127, Invalid Range=0-4 */
*nblks = (indata_ptr[4+le_mode] & 0x01) << 6 | indata_ptr[5-le_mode] >> 2;
/* NBLKS+1 indicates the number of 32 sample PCM audio blocks per channel
encoded in the current frame per channel. */
++(*nblks);
/* Frame Byte Size V FSIZE 14 bits: 0-94=Invalid, 95-8191=Valid range-1
(ie. 96 bytes to 8192 bytes), 8192-16383=Invalid
FSIZE defines the byte size of the current audio frame. */
fsize = (indata_ptr[5-le_mode] & 0x03) << 12 | indata_ptr[6+le_mode] << 4
| indata_ptr[7-le_mode] >> 4;
++fsize;
/* Audio Channel Arrangement ACC AMODE 6 bits */
amode = (indata_ptr[7-le_mode] & 0x0f) << 2 | indata_ptr[8+le_mode] >> 6;
/* Source Sampling rate ACC SFREQ 4 bits */
*sfreq = indata_ptr[8+le_mode] >> 2 & 0x0f;
/* Transmission Bit Rate ACC RATE 5 bits */
*rate = (indata_ptr[8+le_mode] & 0x03) << 3
| (indata_ptr[9-le_mode] >> 5 & 0x07);
}
else
{
/* in the case judgement, we assure this */
ftype = 1;
surp = 0;
/* 14 bits support, every 2 bytes, & 0x3fff, got used 14 bits */
/* Bits usage:
32 bits: Sync code (28 + 4) 1th and 2th word, 4 bits in 3th word
1 bits: Frame type 1 bits in 3th word
5 bits: SURP 5 bits in 3th word
1 bits: crc? 1 bits in 3th word
7 bits: NBLKS 3 bits in 3th word, 4 bits in 4th word
14 bits: FSIZE 10 bits in 4th word, 4 bits in 5th word
in 14 bits mode, FSIZE = FSIZE*8/14*2
6 bits: AMODE 6 bits in 5th word
4 bits: SFREQ 4 bits in 5th word
5 bits: RATE 5 bits in 6th word
total bits: 75 bits */
/* NBLKS 7 bits: Valid Range=5-127, Invalid Range=0-4 */
*nblks = (indata_ptr[5-le_mode] & 0x07) << 4
| (indata_ptr[6+le_mode] & 0x3f) >> 2;
/* NBLKS+1 indicates the number of 32 sample PCM audio blocks per channel
encoded in the current frame per channel. */
++(*nblks);
/* Frame Byte Size V FSIZE 14 bits: 0-94=Invalid, 95-8191=Valid range-1
(ie. 96 bytes to 8192 bytes), 8192-16383=Invalid
FSIZE defines the byte size of the current audio frame. */
fsize = (indata_ptr[6+le_mode] & 0x03) << 12 | indata_ptr[7-le_mode] << 4
| (indata_ptr[8+le_mode] & 0x3f) >> 2;
++fsize;
fsize = fsize * 8 / 14 * 2;
/* Audio Channel Arrangement ACC AMODE 6 bits */
amode = (indata_ptr[8+le_mode] & 0x03) << 4
| (indata_ptr[9-le_mode] & 0xf0) >> 4;
/* Source Sampling rate ACC SFREQ 4 bits */
*sfreq = indata_ptr[9-le_mode] & 0x0f;
/* Transmission Bit Rate ACC RATE 5 bits */
*rate = (indata_ptr[10+le_mode] & 0x3f) >> 1;
}
#if 0
if(*sfreq != 13)
{
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "DTS: Only 48kHz supported, REPORT BUG\n");
return -1;
}
#endif
if((fsize > 8192) || (fsize < 96))
{
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "DTS: fsize: %d invalid, REPORT BUG\n", fsize);
return -1;
}
if(*nblks != 8 &&
*nblks != 16 &&
*nblks != 32 &&
*nblks != 64 &&
*nblks != 128 &&
ftype == 1)
{
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "DTS: nblks %d not valid for normal frame, REPORT BUG\n", *nblks);
return -1;
}
return fsize;
}
static int dts_syncinfo(uint8_t *indata_ptr, int *flags, int *sample_rate, int *bit_rate)
{
int nblks;
int fsize;
int rate;
int sfreq;
fsize = dts_decode_header(indata_ptr, &rate, &nblks, &sfreq);
if(fsize >= 0)
{
if(rate >= 0 && rate <= 29)
*bit_rate = DTS_BITRATES[rate];
else
*bit_rate = 0;
if(sfreq >= 1 && sfreq <= 15)
*sample_rate = DTS_SAMPLEFREQS[sfreq];
else
*sample_rate = 0;
}
return fsize;
}
static int convert_14bits_to_16bits(const unsigned char *src,
unsigned char *dest,
int len,
int is_le)
{
uint16_t *p = (uint16_t *)dest;
uint16_t buf = 0;
int spacebits = 16;
if (len <= 0) return 0;
while (len > 0) {
uint16_t v;
if (len == 1)
v = is_le ? src[0] : src[0] << 8;
else
v = is_le ? src[1] << 8 | src[0] : src[0] << 8 | src[1];
v <<= 2;
src += 2;
len -= 2;
buf |= v >> (16 - spacebits);
spacebits -= 14;
if (spacebits < 0) {
*p++ = buf;
spacebits += 16;
buf = v << (spacebits - 2);
}
}
*p++ = buf;
return (unsigned char *)p - dest;
}
static int decode_audio_dts(unsigned char *indata_ptr, int len, unsigned char *buf)
{
int nblks;
int fsize;
int rate;
int sfreq;
int nr_samples;
int convert_16bits = 0;
uint16_t *buf16 = (uint16_t *)buf;
fsize = dts_decode_header(indata_ptr, &rate, &nblks, &sfreq);
if(fsize < 0)
return -1;
nr_samples = nblks * 32;
buf16[0] = 0xf872; /* iec 61937 */
buf16[1] = 0x4e1f; /* syncword */
switch(nr_samples)
{
case 512:
buf16[2] = 0x000b; /* DTS-1 (512-sample bursts) */
break;
case 1024:
buf16[2] = 0x000c; /* DTS-2 (1024-sample bursts) */
break;
case 2048:
buf16[2] = 0x000d; /* DTS-3 (2048-sample bursts) */
break;
default:
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "DTS: %d-sample bursts not supported\n", nr_samples);
buf16[2] = 0x0000;
break;
}
if(fsize + 8 > nr_samples * 2 * 2)
{
// dts wav (14bits LE) match this condition, one way to passthrough
// is not add iec 61937 header, decoders will notice the dts header
// and identify the dts stream. Another way here is convert
// the stream from 14 bits to 16 bits.
if ((indata_ptr[0] == 0xff || indata_ptr[0] == 0x1f)
&& fsize * 14 / 16 + 8 <= nr_samples * 2 * 2) {
// The input stream is 14 bits, we can shrink it to 16 bits
// to save space for add the 61937 header
fsize = convert_14bits_to_16bits(indata_ptr,
&buf[8],
fsize,
indata_ptr[0] == 0xff /* is LE */
);
mp_msg(MSGT_DECAUDIO, MSGL_DBG3, "DTS: shrink 14 bits stream to "
"16 bits %02x%02x%02x%02x => %02x%02x%02x%02x, new size %d.\n",
indata_ptr[0], indata_ptr[1], indata_ptr[2], indata_ptr[3],
buf[8], buf[9], buf[10], buf[11], fsize);
convert_16bits = 1;
}
else
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "DTS: more data than fits\n");
}
buf16[3] = fsize << 3;
if (!convert_16bits) {
#ifdef BIG_ENDIAN
/* BE stream */
if (indata_ptr[0] == 0x1f || indata_ptr[0] == 0x7f)
#else
/* LE stream */
if (indata_ptr[0] == 0xff || indata_ptr[0] == 0xfe)
#endif
memcpy(&buf[8], indata_ptr, fsize);
else
{
swab(indata_ptr, &buf[8], fsize);
if (fsize & 1) {
buf[8+fsize-1] = 0;
buf[8+fsize] = indata_ptr[fsize-1];
fsize++;
}
}
}
memset(&buf[fsize + 8], 0, nr_samples * 2 * 2 - (fsize + 8));
return nr_samples * 2 * 2;
}

166
libmpcodecs/ad_hwmpa.c
View File

@ -1,166 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "config.h"
#include "mp_msg.h"
#include "libaf/af_format.h"
#include "ad_internal.h"
#include "libmpdemux/mp3_hdr.h"
//based on ad_hwac3.c and ad_libmad.c
static const ad_info_t info =
{
"MPEG audio pass-through (fake decoder)",
"hwmpa",
"NicoDVB",
"NicoDVB",
"For hardware decoders"
};
LIBAD_EXTERN(hwmpa)
static int mpa_sync(sh_audio_t *sh, int no_frames, int *n, int *chans, int *srate, int *spf, int *mpa_layer, int *br)
{
int cnt = 0, x = 0, len, frames_count;
frames_count = 0;
do
{
while(cnt + 4 < sh->a_in_buffer_len)
{
x = mp_get_mp3_header(&(sh->a_in_buffer[cnt]), chans, srate, spf, mpa_layer, br);
if(x > 0)
{
frames_count++;
if(frames_count == no_frames)
{
*n = x;
return cnt;
}
}
cnt++;
}
len = demux_read_data(sh->ds,&sh->a_in_buffer[sh->a_in_buffer_len],sh->a_in_buffer_size-sh->a_in_buffer_len);
if(len > 0)
sh->a_in_buffer_len += len;
} while(len > 0);
mp_msg(MSGT_DECAUDIO,MSGL_INFO,"Cannot sync MPA frame: %d\r\n", len);
return -1;
}
static int preinit(sh_audio_t *sh)
{
sh->audio_out_minsize = 4608;//check
sh->audio_in_minsize = 4608;//check
sh->sample_format = AF_FORMAT_MPEG2;
return 1;
}
static int init(sh_audio_t *sh)
{
int cnt, chans, srate, spf, mpa_layer, br, len;
if((cnt = mpa_sync(sh, 1, &len, &chans, &srate, &spf, &mpa_layer, &br)) < 0)
return 0;
sh->channels = chans;
sh->samplerate = srate;
sh->i_bps = br * 125;
sh->samplesize = 2;
mp_msg(MSGT_DECAUDIO,MSGL_V,"AC_HWMPA initialized, bitrate: %d kb/s\r\n", len);
return 1;
}
static int decode_audio(sh_audio_t *sh,unsigned char *buf,int minlen,int maxlen)
{
int len, start, tot;
int chans, srate, spf, mpa_layer, br;
int tot2;
tot = tot2 = 0;
while(tot2 < maxlen)
{
start = mpa_sync(sh, 1, &len, &chans, &srate, &spf, &mpa_layer, &br);
if(start < 0 || tot2 + spf * 2 * chans > maxlen)
break;
if(start + len > sh->a_in_buffer_len)
{
int l;
l = FFMIN(sh->a_in_buffer_size - sh->a_in_buffer_len, start + len);
l = demux_read_data(sh->ds,&sh->a_in_buffer[sh->a_in_buffer_len], l);
if(! l)
break;
sh->a_in_buffer_len += l;
continue;
}
memcpy(&buf[tot], &(sh->a_in_buffer[start]), len);
tot += len;
sh->a_in_buffer_len -= start + len;
memmove(sh->a_in_buffer, &(sh->a_in_buffer[start + len]), sh->a_in_buffer_len);
tot2 += spf * 2 * chans;
/* HACK: seems to fix most A/V sync issues */
break;
}
memset(&buf[tot], 0, tot2-tot);
return tot2;
}
static int control(sh_audio_t *sh,int cmd,void* arg, ...)
{
int start, len;
switch(cmd)
{
case ADCTRL_RESYNC_STREAM:
if(mpa_sync(sh, 1, &len, NULL, NULL, NULL, NULL, NULL) >= 0)
return CONTROL_TRUE;
else
return CONTROL_FALSE;
case ADCTRL_SKIP_FRAME:
start = mpa_sync(sh, 2, &len, NULL, NULL, NULL, NULL, NULL);
if(start < 0)
return CONTROL_FALSE;
sh->a_in_buffer_len -= start;
memmove(sh->a_in_buffer, &(sh->a_in_buffer[start]), sh->a_in_buffer_len);
return CONTROL_TRUE;
}
return CONTROL_UNKNOWN;
}
static void uninit(sh_audio_t *sh)
{
}

340
libmpcodecs/ad_imaadpcm.c
View File

@ -1,340 +0,0 @@
/*
* IMA ADPCM decoder
*
* This file is in charge of decoding all of the various IMA ADPCM data
* formats that various entities have created. Details about the data
* formats can be found here:
* http://www.pcisys.net/~melanson/codecs/
*
* So far, this file handles these formats:
* 'ima4': IMA ADPCM found in QT files
* 0x11: IMA ADPCM found in MS AVI/ASF/WAV files
* 0x61: DK4 ADPCM found in certain AVI files on Sega Saturn CD-ROMs;
* note that this is a 'rogue' format number in that it was
* never officially registered with Microsoft
* 0x1100736d: IMA ADPCM coded like in MS AVI/ASF/WAV found in QT files
*
* Copyright (c) 2002 Mike Melanson
*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <inttypes.h>
#include <libavutil/intreadwrite.h>
#include "config.h"
#include "mpbswap.h"
#include "ad_internal.h"
#define MS_IMA_ADPCM_PREAMBLE_SIZE 4
#define QT_IMA_ADPCM_PREAMBLE_SIZE 2
#define QT_IMA_ADPCM_BLOCK_SIZE 0x22
#define QT_IMA_ADPCM_SAMPLES_PER_BLOCK 64
// pertinent tables for IMA ADPCM
static const int16_t adpcm_step[89] =
{
7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
};
static const int8_t adpcm_index[8] =
{
-1, -1, -1, -1, 2, 4, 6, 8,
};
// useful macros
// clamp a number between 0 and 88
#define CLAMP_0_TO_88(x) x = av_clip(x, 0, 88);
// clamp a number within a signed 16-bit range
#define CLAMP_S16(x) x = av_clip_int16(x);
// clamp a number above 16
#define CLAMP_ABOVE_16(x) if (x < 16) x = 16;
static const ad_info_t info =
{
"IMA ADPCM audio decoder",
"imaadpcm",
"Nick Kurshev",
"Mike Melanson",
""
};
LIBAD_EXTERN(imaadpcm)
static int preinit(sh_audio_t *sh_audio)
{
// not exactly sure what this field is for
sh_audio->audio_out_minsize = 8192;
// if format is "ima4", assume the audio is coming from a QT file which
// indicates constant block size, whereas an AVI/ASF/WAV file will fill
// in this field with 0x11
if ((sh_audio->format == 0x11) || (sh_audio->format == 0x61) ||
(sh_audio->format == 0x1100736d))
{
sh_audio->ds->ss_div = (sh_audio->wf->nBlockAlign -
(MS_IMA_ADPCM_PREAMBLE_SIZE * sh_audio->wf->nChannels)) * 2;
sh_audio->ds->ss_mul = sh_audio->wf->nBlockAlign;
}
else
{
sh_audio->ds->ss_div = QT_IMA_ADPCM_SAMPLES_PER_BLOCK;
sh_audio->ds->ss_mul = QT_IMA_ADPCM_BLOCK_SIZE * sh_audio->wf->nChannels;
}
sh_audio->audio_in_minsize=sh_audio->ds->ss_mul;
return 1;
}
static int init(sh_audio_t *sh_audio)
{
/* IMA-ADPCM 4:1 audio codec:*/
sh_audio->channels=sh_audio->wf->nChannels;
sh_audio->samplerate=sh_audio->wf->nSamplesPerSec;
/* decodes 34 byte -> 64 short*/
sh_audio->i_bps =
(sh_audio->ds->ss_mul * sh_audio->samplerate) / sh_audio->ds->ss_div;
sh_audio->samplesize=2;
return 1;
}
static void uninit(sh_audio_t *sh_audio)
{
}
static int control(sh_audio_t *sh_audio,int cmd,void* arg, ...)
{
if(cmd==ADCTRL_SKIP_FRAME){
demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
return CONTROL_TRUE;
}
return CONTROL_UNKNOWN;
}
static void decode_nibbles(unsigned short *output,
int output_size, int channels,
int predictor[2], int index[2])
{
int step[2];
int i;
int sign;
int delta;
int channel_number = 0;
step[0] = adpcm_step[index[0]];
step[1] = adpcm_step[index[1]];
for (i = 0; i < output_size; i++)
{
delta = output[i];
sign = delta & 8;
delta = delta & 7;
index[channel_number] += adpcm_index[delta];
CLAMP_0_TO_88(index[channel_number]);
delta = 2 * delta + 1;
if (sign) delta = -delta;
predictor[channel_number] += (delta * step[channel_number]) >> 3;
CLAMP_S16(predictor[channel_number]);
output[i] = predictor[channel_number];
step[channel_number] = adpcm_step[index[channel_number]];
// toggle channel
channel_number ^= channels - 1;
}
}
static int qt_ima_adpcm_decode_block(unsigned short *output,
unsigned char *input, int channels, int block_size)
{
int initial_predictor[2] = {0};
int initial_index[2] = {0};
int i;
if (channels != 1) channels = 2;
if (block_size < channels * QT_IMA_ADPCM_BLOCK_SIZE)
return -1;
for (i = 0; i < channels; i++) {
initial_index[i] = initial_predictor[i] = (int16_t)AV_RB16(&input[i * QT_IMA_ADPCM_BLOCK_SIZE]);
// mask, sign-extend, and clamp the predictor portion
initial_predictor[i] &= ~0x7F;
CLAMP_S16(initial_predictor[i]);
// mask and clamp the index portion
initial_index[i] &= 0x7F;
CLAMP_0_TO_88(initial_index[i]);
}
// break apart all of the nibbles in the block
if (channels == 1)
for (i = 0; i < QT_IMA_ADPCM_SAMPLES_PER_BLOCK / 2; i++)
{
output[i * 2 + 0] = input[2 + i] & 0x0F;
output[i * 2 + 1] = input[2 + i] >> 4;
}
else
for (i = 0; i < QT_IMA_ADPCM_SAMPLES_PER_BLOCK / 2; i++)
{
output[i * 4 + 0] = input[2 + i] & 0x0F;
output[i * 4 + 1] = input[2 + QT_IMA_ADPCM_BLOCK_SIZE + i] & 0x0F;
output[i * 4 + 2] = input[2 + i] >> 4;
output[i * 4 + 3] = input[2 + QT_IMA_ADPCM_BLOCK_SIZE + i] >> 4;
}
decode_nibbles(output,
QT_IMA_ADPCM_SAMPLES_PER_BLOCK * channels, channels,
initial_predictor, initial_index);
return QT_IMA_ADPCM_SAMPLES_PER_BLOCK * channels;
}
static int ms_ima_adpcm_decode_block(unsigned short *output,
unsigned char *input, int channels, int block_size)
{
int predictor[2];
int index[2];
int i;
int channel_counter;
int channel_index;
int channel_index_l;
int channel_index_r;
if (channels != 1) channels = 2;
if (block_size < MS_IMA_ADPCM_PREAMBLE_SIZE * channels)
return -1;
for (i = 0; i < channels; i++) {
predictor[i] = (int16_t)AV_RL16(&input[i * 4]);
index[i] = input[i * 4 + 2];
}
if (channels == 1)
for (i = 0;
i < (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels); i++)
{
output[i * 2 + 0] = input[MS_IMA_ADPCM_PREAMBLE_SIZE + i] & 0x0F;
output[i * 2 + 1] = input[MS_IMA_ADPCM_PREAMBLE_SIZE + i] >> 4;
}
else
{
// encoded as 8 nibbles (4 bytes) per channel; switch channel every
// 4th byte
channel_counter = 0;
channel_index_l = 0;
channel_index_r = 1;
channel_index = channel_index_l;
for (i = 0;
i < (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels); i++)
{
output[channel_index + 0] =
input[MS_IMA_ADPCM_PREAMBLE_SIZE * 2 + i] & 0x0F;
output[channel_index + 2] =
input[MS_IMA_ADPCM_PREAMBLE_SIZE * 2 + i] >> 4;
channel_index += 4;
channel_counter++;
if (channel_counter == 4)
{
channel_index_l = channel_index;
channel_index = channel_index_r;
}
else if (channel_counter == 8)
{
channel_index_r = channel_index;
channel_index = channel_index_l;
channel_counter = 0;
}
}
}
decode_nibbles(output,
(block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2,
channels,
predictor, index);
return (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2;
}
static int dk4_ima_adpcm_decode_block(unsigned short *output,
unsigned char *input, int channels, int block_size)
{
int i;
int output_ptr;
int predictor[2];
int index[2];
if (channels != 1) channels = 2;
if (block_size < MS_IMA_ADPCM_PREAMBLE_SIZE * channels)
return -1;
for (i = 0; i < channels; i++) {
// the first predictor value goes straight to the output
predictor[i] = output[i] = (int16_t)AV_RL16(&input[i * 4]);
index[i] = input[i * 4 + 2];
}
output_ptr = channels;
for (i = MS_IMA_ADPCM_PREAMBLE_SIZE * channels; i < block_size; i++)
{
output[output_ptr++] = input[i] >> 4;
output[output_ptr++] = input[i] & 0x0F;
}
decode_nibbles(&output[channels],
(block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2 - channels,
channels,
predictor, index);
return (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2 - channels;
}
static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
{
int res = -1;
int (*decode_func)(unsigned short *output, unsigned char *input, int channels, int block_size) = qt_ima_adpcm_decode_block;
if (demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,
sh_audio->ds->ss_mul) !=
sh_audio->ds->ss_mul)
return -1;
if ((sh_audio->format == 0x11) || (sh_audio->format == 0x1100736d))
decode_func = ms_ima_adpcm_decode_block;
else if (sh_audio->format == 0x61)
decode_func = dk4_ima_adpcm_decode_block;
res = decode_func((unsigned short*)buf, sh_audio->a_in_buffer,
sh_audio->wf->nChannels, sh_audio->ds->ss_mul);
return res < 0 ? res : 2 * res;
}

339
libmpcodecs/ad_liba52.c
View File

@ -1,339 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#define _GNU_SOURCE
#define _XOPEN_SOURCE 600
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <math.h>
#include <assert.h>
#include "config.h"
#include "options.h"
#include "mp_msg.h"
#include "mpbswap.h"
#include "ad_internal.h"
#include "cpudetect.h"
#include "libaf/af_format.h"
#include <a52dec/a52.h>
#include <a52dec/mm_accel.h>
int (* a52_resample) (float * _f, int16_t * s16);
static a52_state_t *a52_state;
static uint32_t a52_flags=0;
/** Used by a52_resample_float, it defines the mapping between liba52
* channels and output channels. The ith nibble from the right in the
* hex representation of channel_map is the index of the source
* channel corresponding to the ith output channel. Source channels are
* indexed 1-6. Silent output channels are marked by 0xf. */
static uint32_t channel_map;
#define DRC_NO_ACTION 0
#define DRC_NO_COMPRESSION 1
#define DRC_CALLBACK 2
/** The output is multiplied by this var. Used for volume control */
static sample_t a52_level = 1;
static int a52_drc_action = DRC_NO_ACTION;
static const ad_info_t info =
{
"AC3 decoding with liba52",
"liba52",
"Nick Kurshev",
"Michel LESPINASSE",
""
};
LIBAD_EXTERN(liba52)
static int a52_fillbuff(sh_audio_t *sh_audio)
{
int length=0;
int flags=0;
int sample_rate=0;
int bit_rate=0;
sh_audio->a_in_buffer_len=0;
/* sync frame:*/
while(1){
while(sh_audio->a_in_buffer_len<8){
int c=demux_getc(sh_audio->ds);
if(c<0) return -1; /* EOF*/
sh_audio->a_in_buffer[sh_audio->a_in_buffer_len++]=c;
}
if(sh_audio->format==MKTAG('d','n','e','t')) swab(sh_audio->a_in_buffer,sh_audio->a_in_buffer,8);
length = a52_syncinfo (sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
if(length>=7 && length<=3840) break; /* we're done.*/
/* bad file => resync*/
if(sh_audio->format==MKTAG('d','n','e','t')) swab(sh_audio->a_in_buffer,sh_audio->a_in_buffer,8);
memmove(sh_audio->a_in_buffer,sh_audio->a_in_buffer+1,7);
--sh_audio->a_in_buffer_len;
}
mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"a52: len=%d flags=0x%X %d Hz %d bit/s\n",length,flags,sample_rate,bit_rate);
sh_audio->samplerate=sample_rate;
sh_audio->i_bps=bit_rate/8;
sh_audio->samplesize=sh_audio->sample_format==AF_FORMAT_FLOAT_NE ? 4 : 2;
demux_read_data(sh_audio->ds,sh_audio->a_in_buffer+8,length-8);
if(sh_audio->format==MKTAG('d','n','e','t'))
swab(sh_audio->a_in_buffer+8,sh_audio->a_in_buffer+8,length-8);
#ifdef CONFIG_LIBA52_INTERNAL
if(crc16_block(sh_audio->a_in_buffer+2,length-2)!=0)
mp_msg(MSGT_DECAUDIO,MSGL_STATUS,"a52: CRC check failed! \n");
#endif
return length;
}
/* returns: number of available channels*/
static int a52_printinfo(sh_audio_t *sh_audio){
int flags, sample_rate, bit_rate;
char* mode="unknown";
int channels=0;
a52_syncinfo (sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);
switch(flags&A52_CHANNEL_MASK){
case A52_CHANNEL: mode="channel"; channels=2; break;
case A52_MONO: mode="mono"; channels=1; break;
case A52_STEREO: mode="stereo"; channels=2; break;
case A52_3F: mode="3f";channels=3;break;
case A52_2F1R: mode="2f+1r";channels=3;break;
case A52_3F1R: mode="3f+1r";channels=4;break;
case A52_2F2R: mode="2f+2r";channels=4;break;
case A52_3F2R: mode="3f+2r";channels=5;break;
case A52_CHANNEL1: mode="channel1"; channels=2; break;
case A52_CHANNEL2: mode="channel2"; channels=2; break;
case A52_DOLBY: mode="dolby"; channels=2; break;
}
mp_msg(MSGT_DECAUDIO,MSGL_V,"AC3: %d.%d (%s%s) %d Hz %3.1f kbit/s\n",
channels, (flags&A52_LFE)?1:0,
mode, (flags&A52_LFE)?"+lfe":"",
sample_rate, bit_rate*0.001f);
return (flags&A52_LFE) ? (channels+1) : channels;
}
static sample_t dynrng_call (sample_t c, void *data)
{
struct MPOpts *opts = data;
//fprintf(stderr, "(%f, %f): %f\n", (double)c, (double)drc_level, (double)pow((double)c, drc_level));
//fprintf(stderr, "(%lf, %lf): %lf\n", (double)c, opts->drc_level, pow(c, opts->drc_level));
return pow(c, opts->drc_level);
}
static int preinit(sh_audio_t *sh)
{
struct MPOpts *opts = sh->opts;
/* Dolby AC3 audio: */
/* however many channels, 2 bytes in a word, 256 samples in a block, 6 blocks in a frame */
if (sh->samplesize < 4) sh->samplesize = 4;
sh->audio_out_minsize=opts->audio_output_channels*sh->samplesize*256*6;
sh->audio_in_minsize=3840;
a52_level = 1.0;
return 1;
}
/**
* \brief Function to convert the "planar" float format used by liba52
* into the interleaved float format used by libaf/libao2.
* \param in the input buffer containing the planar samples.
* \param out the output buffer where the interleaved result is stored.
*/
static int a52_resample_float(float *in, int16_t *out)
{
unsigned long i;
float *p = (float*) out;
for (i = 0; i != 256; i++) {
unsigned long map = channel_map;
do {
unsigned long ch = map & 15;
if (ch == 15)
*p = 0;
else
*p = in[i + ((ch-1)<<8)];
p++;
} while ((map >>= 4));
}
return (int16_t*) p - out;
}
static int init(sh_audio_t *sh_audio)
{
struct MPOpts *opts = sh_audio->opts;
uint32_t a52_accel=0;
sample_t level=a52_level, bias=384;
int flags=0;
/* Dolby AC3 audio:*/
#ifdef MM_ACCEL_X86_SSE
if(gCpuCaps.hasSSE) a52_accel|=MM_ACCEL_X86_SSE;
#endif
if(gCpuCaps.hasMMX) a52_accel|=MM_ACCEL_X86_MMX;
if(gCpuCaps.hasMMX2) a52_accel|=MM_ACCEL_X86_MMXEXT;
a52_state=a52_init (a52_accel);
if (a52_state == NULL) {
mp_msg(MSGT_DECAUDIO,MSGL_ERR,"A52 init failed\n");
return 0;
}
sh_audio->sample_format = AF_FORMAT_FLOAT_NE;
if(a52_fillbuff(sh_audio)<0){
mp_msg(MSGT_DECAUDIO,MSGL_ERR,"A52 sync failed\n");
return 0;
}
/* Init a52 dynrng */
if (opts->drc_level < 0.001) {
/* level == 0 --> no compression, init library without callback */
a52_drc_action = DRC_NO_COMPRESSION;
} else if (opts->drc_level > 0.999 && opts->drc_level < 1.001) {
/* level == 1 --> full compression, do nothing at all (library default = full compression) */
a52_drc_action = DRC_NO_ACTION;
} else {
a52_drc_action = DRC_CALLBACK;
}
/* Library init for dynrng has to be done for each frame, see decode_audio() */
/* 'a52 cannot upmix' hotfix:*/
a52_printinfo(sh_audio);
sh_audio->channels=opts->audio_output_channels;
while(sh_audio->channels>0){
switch(sh_audio->channels){
case 1: a52_flags=A52_MONO; break;
/* case 2: a52_flags=A52_STEREO; break;*/
case 2: a52_flags=A52_DOLBY; break;
/* case 3: a52_flags=A52_3F; break;*/
case 3: a52_flags=A52_2F1R; break;
case 4: a52_flags=A52_2F2R; break; /* 2+2*/
case 5: a52_flags=A52_3F2R; break;
case 6: a52_flags=A52_3F2R|A52_LFE; break; /* 5.1*/
}
/* test:*/
flags=a52_flags|A52_ADJUST_LEVEL;
mp_msg(MSGT_DECAUDIO,MSGL_V,"A52 flags before a52_frame: 0x%X\n",flags);
if (a52_frame (a52_state, sh_audio->a_in_buffer, &flags, &level, bias)){
mp_msg(MSGT_DECAUDIO,MSGL_ERR,"a52: error decoding frame -> nosound\n");
return 0;
}
mp_msg(MSGT_DECAUDIO,MSGL_V,"A52 flags after a52_frame: 0x%X\n",flags);
/* frame decoded, let's init resampler:*/
channel_map = 0;
if (sh_audio->sample_format == AF_FORMAT_FLOAT_NE) {
if (!(flags & A52_LFE)) {
switch ((flags<<3) | sh_audio->channels) {
case (A52_MONO << 3) | 1: channel_map = 0x1; break;
case (A52_CHANNEL << 3) | 2:
case (A52_STEREO << 3) | 2:
case (A52_DOLBY << 3) | 2: channel_map = 0x21; break;
case (A52_2F1R << 3) | 3: channel_map = 0x321; break;
case (A52_2F2R << 3) | 4: channel_map = 0x4321; break;
case (A52_3F << 3) | 5: channel_map = 0x2ff31; break;
case (A52_3F2R << 3) | 5: channel_map = 0x25431; break;
}
} else if (sh_audio->channels == 6) {
switch (flags & ~A52_LFE) {
case A52_MONO : channel_map = 0x12ffff; break;
case A52_CHANNEL:
case A52_STEREO :
case A52_DOLBY : channel_map = 0x1fff32; break;
case A52_3F : channel_map = 0x13ff42; break;
case A52_2F1R : channel_map = 0x1f4432; break;
case A52_2F2R : channel_map = 0x1f5432; break;
case A52_3F2R : channel_map = 0x136542; break;
}
}
if (channel_map) {
a52_resample = a52_resample_float;
break;
}
} else
break;
}
if(sh_audio->channels<=0){
mp_msg(MSGT_DECAUDIO,MSGL_ERR,"a52: no resampler. try different channel setup!\n");
return 0;
}
return 1;
}
static void uninit(sh_audio_t *sh)
{
a52_free(a52_state);
}
static int control(sh_audio_t *sh,int cmd,void* arg, ...)
{
switch(cmd)
{
case ADCTRL_RESYNC_STREAM:
case ADCTRL_SKIP_FRAME:
a52_fillbuff(sh);
return CONTROL_TRUE;
case ADCTRL_SET_VOLUME: {
float vol = *(float*)arg;
if (vol > 60.0) vol = 60.0;
a52_level = vol <= -200.0 ? 0 : pow(10.0,vol/20.0);
return CONTROL_TRUE;
}
case ADCTRL_QUERY_FORMAT:
if (*(int*)arg == AF_FORMAT_S16_NE ||
*(int*)arg == AF_FORMAT_FLOAT_NE)
return CONTROL_TRUE;
return CONTROL_FALSE;
}
return CONTROL_UNKNOWN;
}
static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
{
sample_t level=a52_level, bias=384;
int flags=a52_flags|A52_ADJUST_LEVEL;
int i,len=-1;
if (sh_audio->sample_format == AF_FORMAT_FLOAT_NE)
bias = 0;
if(!sh_audio->a_in_buffer_len)
if(a52_fillbuff(sh_audio)<0) return len; /* EOF */
sh_audio->a_in_buffer_len=0;
if (a52_frame (a52_state, sh_audio->a_in_buffer, &flags, &level, bias)){
mp_msg(MSGT_DECAUDIO,MSGL_WARN,"a52: error decoding frame\n");
return len;
}
/* handle dynrng */
if (a52_drc_action != DRC_NO_ACTION) {
if (a52_drc_action == DRC_NO_COMPRESSION)
a52_dynrng(a52_state, NULL, NULL);
else
a52_dynrng(a52_state, dynrng_call, sh_audio->opts);
}
len=0;
for (i = 0; i < 6; i++) {
if (a52_block (a52_state)){
mp_msg(MSGT_DECAUDIO,MSGL_WARN,"a52: error at resampling\n");
break;
}
len+=2*a52_resample(a52_samples(a52_state),(int16_t *)&buf[len]);
}
assert(len <= maxlen);
return len;
}

353
libmpcodecs/ad_libdca.c
View File

@ -1,353 +0,0 @@
/*
* DTS Coherent Acoustics stream decoder using libdca
* This file is partially based on dtsdec.c r9036 from FFmpeg and ad_liba52.c
*
* Copyright (C) 2007 Roberto Togni
*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include "config.h"
#include "options.h"
#include "mp_msg.h"
#include "ad_internal.h"
#include <dts.h>
static const ad_info_t info =
{
"DTS decoding with libdca",
"libdca",
"Roberto Togni",
"",
""
};
LIBAD_EXTERN(libdca)
#define DTSBUFFER_SIZE 18726
#define HEADER_SIZE 14
#define CONVERT_LEVEL 1
#define CONVERT_BIAS 0
static const char ch2flags[6] = {
DTS_MONO,
DTS_STEREO,
DTS_3F,
DTS_2F2R,
DTS_3F2R,
DTS_3F2R | DTS_LFE
};
static inline int16_t convert(sample_t s)
{
int i = s * 0x7fff;
return (i > 32767) ? 32767 : ((i < -32768) ? -32768 : i);
}
static void convert2s16_multi(sample_t *f, int16_t *s16, int flags, int ch_out)
{
int i;
switch(flags & (DTS_CHANNEL_MASK | DTS_LFE)){
case DTS_MONO:
if (ch_out == 1)
for(i = 0; i < 256; i++)
s16[i] = convert(f[i]);
else
for(i = 0; i < 256; i++){
s16[5*i] = s16[5*i+1] = s16[5*i+2] = s16[5*i+3] = 0;
s16[5*i+4] = convert(f[i]);
}
break;
case DTS_CHANNEL:
case DTS_STEREO:
case DTS_DOLBY:
for(i = 0; i < 256; i++){
s16[2*i] = convert(f[i]);
s16[2*i+1] = convert(f[i+256]);
}
break;
case DTS_3F:
for(i = 0; i < 256; i++){
s16[3*i] = convert(f[i+256]);
s16[3*i+1] = convert(f[i+512]);
s16[3*i+2] = convert(f[i]);
}
break;
case DTS_2F2R:
for(i = 0; i < 256; i++){
s16[4*i] = convert(f[i]);
s16[4*i+1] = convert(f[i+256]);
s16[4*i+2] = convert(f[i+512]);
s16[4*i+3] = convert(f[i+768]);
}
break;
case DTS_3F2R:
for(i = 0; i < 256; i++){
s16[5*i] = convert(f[i+256]);
s16[5*i+1] = convert(f[i+512]);
s16[5*i+2] = convert(f[i+768]);
s16[5*i+3] = convert(f[i+1024]);
s16[5*i+4] = convert(f[i]);
}
break;
case DTS_MONO | DTS_LFE:
for(i = 0; i < 256; i++){
s16[6*i] = s16[6*i+1] = s16[6*i+2] = s16[6*i+3] = 0;
s16[6*i+4] = convert(f[i]);
s16[6*i+5] = convert(f[i+256]);
}
break;
case DTS_CHANNEL | DTS_LFE:
case DTS_STEREO | DTS_LFE:
case DTS_DOLBY | DTS_LFE:
for(i = 0; i < 256; i++){
s16[6*i] = convert(f[i]);
s16[6*i+1] = convert(f[i+256]);
s16[6*i+2] = s16[6*i+3] = s16[6*i+4] = 0;
s16[6*i+5] = convert(f[i+512]);
}
break;
case DTS_3F | DTS_LFE:
for(i = 0; i < 256; i++){
s16[6*i] = convert(f[i+256]);
s16[6*i+1] = convert(f[i+512]);
s16[6*i+2] = s16[6*i+3] = 0;
s16[6*i+4] = convert(f[i]);
s16[6*i+5] = convert(f[i+768]);
}
break;
case DTS_2F2R | DTS_LFE:
for(i = 0; i < 256; i++){
s16[6*i] = convert(f[i]);
s16[6*i+1] = convert(f[i+256]);
s16[6*i+2] = convert(f[i+512]);
s16[6*i+3] = convert(f[i+768]);
s16[6*i+4] = 0;
s16[6*i+5] = convert(f[1024]);
}
break;
case DTS_3F2R | DTS_LFE:
for(i = 0; i < 256; i++){
s16[6*i] = convert(f[i+256]);
s16[6*i+1] = convert(f[i+512]);
s16[6*i+2] = convert(f[i+768]);
s16[6*i+3] = convert(f[i+1024]);
s16[6*i+4] = convert(f[i]);
s16[6*i+5] = convert(f[i+1280]);
}
break;
}
}
static void channels_info(int flags)
{
int lfe = 0;
char lfestr[5] = "";
if (flags & DTS_LFE) {
lfe = 1;
strcpy(lfestr, "+lfe");
}
mp_msg(MSGT_DECAUDIO, MSGL_V, "DTS: ");
switch(flags & DTS_CHANNEL_MASK){
case DTS_MONO:
mp_msg(MSGT_DECAUDIO, MSGL_V, "1.%d (mono%s)", lfe, lfestr);
break;
case DTS_CHANNEL:
mp_msg(MSGT_DECAUDIO, MSGL_V, "2.%d (channel%s)", lfe, lfestr);
break;
case DTS_STEREO:
mp_msg(MSGT_DECAUDIO, MSGL_V, "2.%d (stereo%s)", lfe, lfestr);
break;
case DTS_3F:
mp_msg(MSGT_DECAUDIO, MSGL_V, "3.%d (3f%s)", lfe, lfestr);
break;
case DTS_2F2R:
mp_msg(MSGT_DECAUDIO, MSGL_V, "4.%d (2f+2r%s)", lfe, lfestr);
break;
case DTS_3F2R:
mp_msg(MSGT_DECAUDIO, MSGL_V, "5.%d (3f+2r%s)", lfe, lfestr);
break;
default:
mp_msg(MSGT_DECAUDIO, MSGL_V, "x.%d (unknown%s)", lfe, lfestr);
}
mp_msg(MSGT_DECAUDIO, MSGL_V, "\n");
}
static int dts_sync(sh_audio_t *sh, int *flags)
{
dts_state_t *s = sh->context;
int length;
int sample_rate;
int frame_length;
int bit_rate;
sh->a_in_buffer_len=0;
while(1) {
while(sh->a_in_buffer_len < HEADER_SIZE) {
int c = demux_getc(sh->ds);
if(c < 0)
return -1;
sh->a_in_buffer[sh->a_in_buffer_len++] = c;
}
length = dts_syncinfo(s, sh->a_in_buffer, flags, &sample_rate,
&bit_rate, &frame_length);
if(length >= HEADER_SIZE)
break;
// mp_msg(MSGT_DECAUDIO, MSGL_V, "skip\n");
memmove(sh->a_in_buffer, sh->a_in_buffer+1, HEADER_SIZE-1);
--sh->a_in_buffer_len;
}
demux_read_data(sh->ds, sh->a_in_buffer + HEADER_SIZE, length - HEADER_SIZE);
sh->samplerate = sample_rate;
sh->i_bps = bit_rate/8;
return length;
}
static int decode_audio(sh_audio_t *sh, unsigned char *buf, int minlen, int maxlen)
{
dts_state_t *s = sh->context;
int16_t *out_samples = (int16_t*)buf;
int flags;
level_t level;
sample_t bias;
int nblocks;
int i;
int data_size = 0;
if(!sh->a_in_buffer_len)
if(dts_sync(sh, &flags) < 0) return -1; /* EOF */
sh->a_in_buffer_len=0;
flags &= ~(DTS_CHANNEL_MASK | DTS_LFE);
flags |= ch2flags[sh->channels - 1];
level = CONVERT_LEVEL;
bias = CONVERT_BIAS;
flags |= DTS_ADJUST_LEVEL;
if(dts_frame(s, sh->a_in_buffer, &flags, &level, bias)) {
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "dts_frame() failed\n");
goto end;
}
nblocks = dts_blocks_num(s);
for(i = 0; i < nblocks; i++) {
if(dts_block(s)) {
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "dts_block() failed\n");
goto end;
}
convert2s16_multi(dts_samples(s), out_samples, flags, sh->channels);
out_samples += 256 * sh->channels;
data_size += 256 * sizeof(int16_t) * sh->channels;
}
end:
return data_size;
}
static int preinit(sh_audio_t *sh)
{
struct MPOpts *opts = sh->opts;
/* 256 = samples per block, 16 = max number of blocks */
int channels = opts->audio_output_channels;
if (channels > 6)
channels = 6;
sh->audio_out_minsize = channels * sizeof(int16_t) * 256 * 16;
sh->audio_in_minsize = DTSBUFFER_SIZE;
sh->samplesize=2;
return 1;
}
static int init(sh_audio_t *sh)
{
struct MPOpts *opts = sh->opts;
dts_state_t *s;
int flags;
int decoded_bytes;
s = dts_init(0);
if(s == NULL) {
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "dts_init() failed\n");
return 0;
}
sh->context = s;
if(dts_sync(sh, &flags) < 0) {
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "dts sync failed\n");
dts_free(s);
return 0;
}
channels_info(flags);
int channels = opts->audio_output_channels;
if (channels > 6)
channels = 6;
assert(channels >= 1 && channels <= 6);
sh->channels = channels;
decoded_bytes = decode_audio(sh, sh->a_buffer, 1, sh->a_buffer_size);
if(decoded_bytes > 0)
sh->a_buffer_len = decoded_bytes;
else {
mp_msg(MSGT_DECAUDIO, MSGL_ERR, "dts decode failed on first frame (up/downmix problem?)\n");
dts_free(s);
return 0;
}
return 1;
}
static void uninit(sh_audio_t *sh)
{
dts_state_t *s = sh->context;
dts_free(s);
}
static int control(sh_audio_t *sh,int cmd,void* arg, ...)
{
int flags;
switch(cmd){
case ADCTRL_RESYNC_STREAM:
dts_sync(sh, &flags);
return CONTROL_TRUE;
}
return CONTROL_UNKNOWN;
}

187
libmpcodecs/ad_libmad.c
View File

@ -1,187 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "config.h"
#include "ad_internal.h"
static const ad_info_t info = {
"libmad mpeg audio decoder",
"libmad",
"A'rpi",
"libmad...",
"based on Xine's libmad/xine_decoder.c"
};
LIBAD_EXTERN(libmad)
#include <mad.h>
typedef struct mad_decoder_s {
struct mad_synth synth;
struct mad_stream stream;
struct mad_frame frame;
int have_frame;
int output_sampling_rate;
int output_open;
int output_mode;
} mad_decoder_t;
static int preinit(sh_audio_t *sh){
mad_decoder_t *this = calloc(1, sizeof(mad_decoder_t));
sh->context = this;
mad_synth_init (&this->synth);
mad_stream_init (&this->stream);
mad_frame_init (&this->frame);
sh->audio_out_minsize=2*4608;
sh->audio_in_minsize=4096;
return 1;
}
static int read_frame(sh_audio_t *sh){
mad_decoder_t *this = sh->context;
int len;
while((len=demux_read_data(sh->ds,&sh->a_in_buffer[sh->a_in_buffer_len],
sh->a_in_buffer_size-sh->a_in_buffer_len))>0){
sh->a_in_buffer_len+=len;
while(1){
int ret;
mad_stream_buffer (&this->stream, sh->a_in_buffer, sh->a_in_buffer_len);
ret=mad_frame_decode (&this->frame, &this->stream);
if (this->stream.next_frame) {
int num_bytes =
(char*)sh->a_in_buffer+sh->a_in_buffer_len - (char*)this->stream.next_frame;
memmove(sh->a_in_buffer, this->stream.next_frame, num_bytes);
mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"libmad: %d bytes processed\n",sh->a_in_buffer_len-num_bytes);
sh->a_in_buffer_len = num_bytes;
}
if (ret == 0) return 1; // OK!!!
// error! try to resync!
if(this->stream.error==MAD_ERROR_BUFLEN) break;
}
}
mp_msg(MSGT_DECAUDIO,MSGL_INFO,"Cannot sync MAD frame\n");
return 0;
}
static int init(sh_audio_t *sh){
mad_decoder_t *this = sh->context;
this->have_frame=read_frame(sh);
if(!this->have_frame) return 0; // failed to sync...
sh->channels=(this->frame.header.mode == MAD_MODE_SINGLE_CHANNEL) ? 1 : 2;
sh->samplerate=this->frame.header.samplerate;
if (sh->i_bps < 1)
sh->i_bps=this->frame.header.bitrate/8;
sh->samplesize=2;
return 1;
}
static void uninit(sh_audio_t *sh){
mad_decoder_t *this = sh->context;
mad_synth_finish (&this->synth);
mad_frame_finish (&this->frame);
mad_stream_finish(&this->stream);
free(sh->context);
}
/* utility to scale and round samples to 16 bits */
static inline signed int scale(mad_fixed_t sample) {
/* round */
sample += (1L << (MAD_F_FRACBITS - 16));
/* clip */
if (sample >= MAD_F_ONE)
sample = MAD_F_ONE - 1;
else if (sample < -MAD_F_ONE)
sample = -MAD_F_ONE;
/* quantize */
return sample >> (MAD_F_FRACBITS + 1 - 16);
}
static int decode_audio(sh_audio_t *sh,unsigned char *buf,int minlen,int maxlen){
mad_decoder_t *this = sh->context;
int len=0;
while(len<minlen && len+4608<=maxlen){
if(!this->have_frame) this->have_frame=read_frame(sh);
if(!this->have_frame) break; // failed to sync... or EOF
this->have_frame=0;
mad_synth_frame (&this->synth, &this->frame);
{ unsigned int nchannels, nsamples;
mad_fixed_t const *left_ch, *right_ch;
struct mad_pcm *pcm = &this->synth.pcm;
uint16_t *output = (uint16_t*) buf;
nchannels = pcm->channels;
nsamples = pcm->length;
left_ch = pcm->samples[0];
right_ch = pcm->samples[1];
len+=2*nchannels*nsamples;
buf+=2*nchannels*nsamples;
while (nsamples--) {
/* output sample(s) in 16-bit signed little-endian PCM */
*output++ = scale(*left_ch++);
if (nchannels == 2)
*output++ = scale(*right_ch++);
}
}
}
return len?len:-1;
}
static int control(sh_audio_t *sh,int cmd,void* arg, ...){
mad_decoder_t *this = sh->context;
// various optional functions you MAY implement:
switch(cmd){
case ADCTRL_RESYNC_STREAM:
this->have_frame=0;
mad_synth_init (&this->synth);
mad_stream_init (&this->stream);
mad_frame_init (&this->frame);
return CONTROL_TRUE;
case ADCTRL_SKIP_FRAME:
this->have_frame=read_frame(sh);
return CONTROL_TRUE;
}
return CONTROL_UNKNOWN;
}

237
libmpcodecs/ad_msadpcm.c
View File

@ -1,237 +0,0 @@
/*
* MS ADPCM decoder
*
* This file is responsible for decoding Microsoft ADPCM data.
* Details about the data format can be found here:
* http://www.pcisys.net/~melanson/codecs/
*
* Copyright (c) 2002 Mike Melanson
*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <libavutil/common.h>
#include <libavutil/intreadwrite.h>
#include "config.h"
#include "mpbswap.h"
#include "ad_internal.h"
static const ad_info_t info =
{
"MS ADPCM audio decoder",
"msadpcm",
"Nick Kurshev",
"Mike Melanson",
""
};
LIBAD_EXTERN(msadpcm)
static const int ms_adapt_table[] =
{
230, 230, 230, 230, 307, 409, 512, 614,
768, 614, 512, 409, 307, 230, 230, 230
};
static const uint8_t ms_adapt_coeff1[] =
{
64, 128, 0, 48, 60, 115, 98
};
static const int8_t ms_adapt_coeff2[] =
{
0, -64, 0, 16, 0, -52, -58
};
#define MS_ADPCM_PREAMBLE_SIZE 6
#define LE_16(x) ((int16_t)AV_RL16(x))
// clamp a number between 0 and 88
#define CLAMP_0_TO_88(x) x = av_clip(x, 0, 88);
// clamp a number within a signed 16-bit range
#define CLAMP_S16(x) x = av_clip_int16(x);
// clamp a number above 16
#define CLAMP_ABOVE_16(x) if (x < 16) x = 16;
// sign extend a 4-bit value
#define SE_4BIT(x) if (x & 0x8) x -= 0x10;
static int preinit(sh_audio_t *sh_audio)
{
sh_audio->audio_out_minsize = sh_audio->wf->nBlockAlign * 4;
sh_audio->ds->ss_div =
(sh_audio->wf->nBlockAlign - MS_ADPCM_PREAMBLE_SIZE) * 2;
sh_audio->audio_in_minsize =
sh_audio->ds->ss_mul = sh_audio->wf->nBlockAlign;
return 1;
}
static int init(sh_audio_t *sh_audio)
{
sh_audio->channels=sh_audio->wf->nChannels;
sh_audio->samplerate=sh_audio->wf->nSamplesPerSec;
sh_audio->i_bps = sh_audio->wf->nBlockAlign *
(sh_audio->channels*sh_audio->samplerate) / sh_audio->ds->ss_div;
sh_audio->samplesize=2;
return 1;
}
static void uninit(sh_audio_t *sh_audio)
{
}
static int control(sh_audio_t *sh_audio,int cmd,void* arg, ...)
{
if(cmd==ADCTRL_SKIP_FRAME){
demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
return CONTROL_TRUE;
}
return CONTROL_UNKNOWN;
}
static inline int check_coeff(uint8_t c) {
if (c > 6) {
mp_msg(MSGT_DECAUDIO, MSGL_WARN,
"MS ADPCM: coefficient (%d) out of range (should be [0..6])\n",
c);
c = 6;
}
return c;
}
static int ms_adpcm_decode_block(unsigned short *output, unsigned char *input,
int channels, int block_size)
{
int current_channel = 0;
int coeff_idx;
int idelta[2];
int sample1[2];
int sample2[2];
int coeff1[2];
int coeff2[2];
int stream_ptr = 0;
int out_ptr = 0;
int upper_nibble = 1;
int nibble;
int snibble; // signed nibble
int predictor;
if (channels != 1) channels = 2;
if (block_size < 7 * channels)
return -1;
// fetch the header information, in stereo if both channels are present
coeff_idx = check_coeff(input[stream_ptr]);
coeff1[0] = ms_adapt_coeff1[coeff_idx];
coeff2[0] = ms_adapt_coeff2[coeff_idx];
stream_ptr++;
if (channels == 2)
{
coeff_idx = check_coeff(input[stream_ptr]);
coeff1[1] = ms_adapt_coeff1[coeff_idx];
coeff2[1] = ms_adapt_coeff2[coeff_idx];
stream_ptr++;
}
idelta[0] = LE_16(&input[stream_ptr]);
stream_ptr += 2;
if (channels == 2)
{
idelta[1] = LE_16(&input[stream_ptr]);
stream_ptr += 2;
}
sample1[0] = LE_16(&input[stream_ptr]);
stream_ptr += 2;
if (channels == 2)
{
sample1[1] = LE_16(&input[stream_ptr]);
stream_ptr += 2;
}
sample2[0] = LE_16(&input[stream_ptr]);
stream_ptr += 2;
if (channels == 2)
{
sample2[1] = LE_16(&input[stream_ptr]);
stream_ptr += 2;
}
if (channels == 1)
{
output[out_ptr++] = sample2[0];
output[out_ptr++] = sample1[0];
} else {
output[out_ptr++] = sample2[0];
output[out_ptr++] = sample2[1];
output[out_ptr++] = sample1[0];
output[out_ptr++] = sample1[1];
}
while (stream_ptr < block_size)
{
// get the next nibble
if (upper_nibble)
nibble = snibble = input[stream_ptr] >> 4;
else
nibble = snibble = input[stream_ptr++] & 0x0F;
upper_nibble ^= 1;
SE_4BIT(snibble);
// should this really be a division and not a shift?
// coefficients were originally scaled by for, which might have
// been an optimization for 8-bit CPUs _if_ a shift is correct
predictor = (
((sample1[current_channel] * coeff1[current_channel]) +
(sample2[current_channel] * coeff2[current_channel])) / 64) +
(snibble * idelta[current_channel]);
CLAMP_S16(predictor);
sample2[current_channel] = sample1[current_channel];
sample1[current_channel] = predictor;
output[out_ptr++] = predictor;
// compute the next adaptive scale factor (a.k.a. the variable idelta)
idelta[current_channel] =
(ms_adapt_table[nibble] * idelta[current_channel]) / 256;
CLAMP_ABOVE_16(idelta[current_channel]);
// toggle the channel
current_channel ^= channels - 1;
}
return (block_size - (MS_ADPCM_PREAMBLE_SIZE * channels)) * 2;
}
static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
{
int res;
if (demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,
sh_audio->ds->ss_mul) !=
sh_audio->ds->ss_mul)
return -1; /* EOF */
res = ms_adpcm_decode_block(
(unsigned short*)buf, sh_audio->a_in_buffer,
sh_audio->wf->nChannels, sh_audio->wf->nBlockAlign);
return res < 0 ? res : 2 * res;
}

214
libmpcodecs/ad_pcm.c
View File

@ -1,214 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include "talloc.h"
#include "config.h"
#include "ad_internal.h"
#include "libaf/af_format.h"
#include "libaf/reorder_ch.h"
static const ad_info_t info = {
"Uncompressed PCM audio decoder",
"pcm",
"Nick Kurshev",
"A'rpi",
""
};
struct ad_pcm_context {
unsigned char *buffer;
int buffer_pos;
int buffer_len;
int buffer_size;
};
LIBAD_EXTERN(pcm)
static int init(sh_audio_t * sh_audio)
{
WAVEFORMATEX *h = sh_audio->wf;
if (!h)
return 0;
sh_audio->i_bps = h->nAvgBytesPerSec;
sh_audio->channels = h->nChannels;
sh_audio->samplerate = h->nSamplesPerSec;
sh_audio->samplesize = (h->wBitsPerSample + 7) / 8;
sh_audio->sample_format = AF_FORMAT_S16_LE; // default
switch (sh_audio->format) { /* hardware formats: */
case 0x0:
case 0x1: // Microsoft PCM
case 0xfffe: // Extended
switch (sh_audio->samplesize) {
case 1: sh_audio->sample_format = AF_FORMAT_U8; break;
case 2: sh_audio->sample_format = AF_FORMAT_S16_LE; break;
case 3: sh_audio->sample_format = AF_FORMAT_S24_LE; break;
case 4: sh_audio->sample_format = AF_FORMAT_S32_LE; break;
}
break;
case 0x3: // IEEE float
sh_audio->sample_format = AF_FORMAT_FLOAT_LE;
break;
case 0x6: sh_audio->sample_format = AF_FORMAT_A_LAW; break;
case 0x7: sh_audio->sample_format = AF_FORMAT_MU_LAW; break;
case 0x11: sh_audio->sample_format = AF_FORMAT_IMA_ADPCM; break;
case 0x50: sh_audio->sample_format = AF_FORMAT_MPEG2; break;
/* case 0x2000: sh_audio->sample_format=AFMT_AC3; */
case 0x20776172: // 'raw '
sh_audio->sample_format = AF_FORMAT_S16_BE;
if (sh_audio->samplesize == 1)
sh_audio->sample_format = AF_FORMAT_U8;
break;
case 0x736F7774: // 'twos'
sh_audio->sample_format = AF_FORMAT_S16_BE;
// intended fall-through
case 0x74776F73: // 'sowt'
if (sh_audio->samplesize == 1)
sh_audio->sample_format = AF_FORMAT_S8;
break;
case 0x32336c66: // 'fl32', bigendian float32
case 0x32334C46: // 'FL32', bigendian float32 in aiff
sh_audio->sample_format = AF_FORMAT_FLOAT_BE;
sh_audio->samplesize = 4;
break;
case 0x666c3332: // '23lf', little endian float32, MPlayer internal fourCC
case 0x6D63706C: // 'lpcm'
sh_audio->sample_format = AF_FORMAT_FLOAT_LE;
sh_audio->samplesize = 4;
break;
/* case 0x34366c66: // 'fl64', bigendian float64
sh_audio->sample_format=AF_FORMAT_FLOAT_BE;
sh_audio->samplesize=8;
break;
case 0x666c3634: // '46lf', little endian float64, MPlayer internal fourCC
sh_audio->sample_format=AF_FORMAT_FLOAT_LE;
sh_audio->samplesize=8;
break;*/
case 0x34326e69: // 'in24', bigendian int24
sh_audio->sample_format = AF_FORMAT_S24_BE;
sh_audio->samplesize = 3;
break;
case 0x696e3234: // '42ni', little endian int24, MPlayer internal fourCC
sh_audio->sample_format = AF_FORMAT_S24_LE;
sh_audio->samplesize = 3;
break;
case 0x32336e69: // 'in32', bigendian int32
sh_audio->sample_format = AF_FORMAT_S32_BE;
sh_audio->samplesize = 4;
break;
case 0x696e3332: // '23ni', little endian int32, MPlayer internal fourCC
sh_audio->sample_format = AF_FORMAT_S32_LE;
sh_audio->samplesize = 4;
break;
default:
if (sh_audio->samplesize != 2)
sh_audio->sample_format = AF_FORMAT_U8;
}
if (!sh_audio->samplesize) // this would cause MPlayer to hang later
sh_audio->samplesize = 2;
sh_audio->context = talloc_zero(NULL, struct ad_pcm_context);
return 1;
}
static int preinit(sh_audio_t *sh)
{
sh->audio_out_minsize = 2048;
return 1;
}
static void uninit(sh_audio_t *sh)
{
talloc_free(sh->context);
}
static int control(sh_audio_t *sh, int cmd, void *arg, ...)
{
struct ad_pcm_context *ctx = sh->context;
int skip;
switch (cmd) {
case ADCTRL_RESYNC_STREAM:
ctx->buffer_len = 0;
return true;
case ADCTRL_SKIP_FRAME:
skip = sh->i_bps / 16;
skip = skip & (~3);
demux_read_data(sh->ds, NULL, skip);
return CONTROL_TRUE;
}
return CONTROL_UNKNOWN;
}
static int decode_audio(sh_audio_t *sh_audio, unsigned char *buf, int minlen,
int maxlen)
{
int unitsize = sh_audio->channels * sh_audio->samplesize;
minlen = (minlen + unitsize - 1) / unitsize * unitsize;
if (minlen > maxlen)
// if someone needs hundreds of channels adjust audio_out_minsize
// based on channels in preinit()
return -1;
int len = 0;
struct ad_pcm_context *ctx = sh_audio->context;
while (len < minlen) {
if (ctx->buffer_len - ctx->buffer_pos <= 0) {
double pts;
unsigned char *ptr;
int plen = ds_get_packet_pts(sh_audio->ds, &ptr, &pts);
if (plen < 0)
break;
if (ctx->buffer_size < plen) {
talloc_free(ctx->buffer);
ctx->buffer = talloc_size(ctx, plen);
ctx->buffer_size = plen;
}
memcpy(ctx->buffer, ptr, plen);
ctx->buffer_len = plen;
ctx->buffer_pos = 0;
if (pts != MP_NOPTS_VALUE) {
sh_audio->pts = pts;
sh_audio->pts_bytes = 0;
}
}
int from_stored = ctx->buffer_len - ctx->buffer_pos;
if (from_stored > minlen - len)
from_stored = minlen - len;
memcpy(buf + len, ctx->buffer + ctx->buffer_pos, from_stored);
ctx->buffer_pos += from_stored;
sh_audio->pts_bytes += from_stored;
len += from_stored;
}
if (len % unitsize) {
mp_msg(MSGT_DECAUDIO, MSGL_WARN, "[ad_pcm] discarding partial sample "
"at end\n");
len -= len % unitsize;
}
if (len == 0)
len = -1; // The loop above only exits at error/EOF
if (len > 0 && sh_audio->channels >= 5) {
reorder_channel_nch(buf, AF_CHANNEL_LAYOUT_WAVEEX_DEFAULT,
AF_CHANNEL_LAYOUT_MPLAYER_DEFAULT,
sh_audio->channels, len / sh_audio->samplesize,
sh_audio->samplesize);
}
return len;
}

145
libmpcodecs/ad_sample.c
View File

@ -1,145 +0,0 @@
// SAMPLE audio decoder - you can use this file as template when creating new codec!
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "config.h"
#include "ad_internal.h"
static const ad_info_t info = {
"Sample audio decoder", // name of the driver
"sample", // driver name. should be the same as filename without ad_
"A'rpi", // writer/maintainer of _this_ file
"", // writer/maintainer/site of the _codec_
"" // comments
};
LIBAD_EXTERN(sample)
#include "libsample/sample.h" // include your codec's .h files here
static int preinit(sh_audio_t *sh){
// let's check if the driver is available, return 0 if not.
// (you should do that if you use external lib(s) which is optional)
...
// there are default values set for buffering, but you can override them:
// minimum output buffer size (should be the uncompressed max. frame size)
sh->audio_out_minsize=4*2*1024; // in this sample, we assume max 4 channels,
// 2 bytes/sample and 1024 samples/frame
// Default: 8192
// minimum input buffer size (set only if you need input buffering)
// (should be the max compressed frame size)
sh->audio_in_minsize=2048; // Default: 0 (no input buffer)
// if you set audio_in_minsize non-zero, the buffer will be allocated
// before the init() call by the core, and you can access it via
// pointer: sh->audio_in_buffer
// it will free'd after uninit(), so you don't have to use malloc/free here!
// the next few parameters define the audio format (channels, sample type,
// in/out bitrate etc.). it's OK to move these to init() if you can set
// them only after some initialization:
sh->samplesize=2; // bytes (not bits!) per sample per channel
sh->channels=2; // number of channels
sh->samplerate=44100; // samplerate
sh->sample_format=AF_FORMAT_S16_LE; // sample format, see libao2/afmt.h
sh->i_bps=64000/8; // input data rate (compressed bytes per second)
// Note: if you have VBR or unknown input rate, set it to some common or
// average value, instead of zero. it's used to predict time delay of
// buffered compressed bytes, so it must be more-or-less real!
//sh->o_bps=... // output data rate (uncompressed bytes per second)
// Note: you DON'T need to set o_bps in most cases, as it defaults to:
// sh->samplesize*sh->channels*sh->samplerate;
// for constant rate compressed QuickTime (.mov files) codecs you MUST
// set the compressed and uncompressed packet size (used by the demuxer):
sh->ds->ss_mul = 34; // compressed packet size
sh->ds->ss_div = 64; // samples per packet
return 1; // return values: 1=OK 0=ERROR
}
static int init(sh_audio_t *sh_audio){
// initialize the decoder, set tables etc...
// you can store HANDLE or private struct pointer at sh->context
// you can access WAVEFORMATEX header at sh->wf
// set sample format/rate parameters if you didn't do it in preinit() yet.
return 1; // return values: 1=OK 0=ERROR
}
static void uninit(sh_audio_t *sh){
// uninit the decoder etc...
// again: you don't have to free() a_in_buffer here! it's done by the core.
}
static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen){
// audio decoding. the most important thing :)
// parameters you get:
// buf = pointer to the output buffer, you have to store uncompressed
// samples there
// minlen = requested minimum size (in bytes!) of output. it's just a
// _recommendation_, you can decode more or less, it just tell you that
// the caller process needs 'minlen' bytes. if it gets less, it will
// call decode_audio() again.
// maxlen = maximum size (bytes) of output. you MUST NOT write more to the
// buffer, it's the upper-most limit!
// note: maxlen will be always greater or equal to sh->audio_out_minsize
// now, let's decode...
// you can read the compressed stream using the demux stream functions:
// demux_read_data(sh->ds, buffer, length) - read 'length' bytes to 'buffer'
// ds_get_packet(sh->ds, &buffer) - set ptr buffer to next data packet
// (both func return number of bytes or 0 for error)
return len; // return value: number of _bytes_ written to output buffer,
// or -1 for EOF (or uncorrectable error)
}
static int control(sh_audio_t *sh,int cmd,void* arg, ...){
// various optional functions you MAY implement:
switch(cmd){
case ADCTRL_RESYNC_STREAM:
// it is called once after seeking, to resync.
// Note: sh_audio->a_in_buffer_len=0; is done _before_ this call!
...
return CONTROL_TRUE;
case ADCTRL_SKIP_FRAME:
// it is called to skip (jump over) small amount (1/10 sec or 1 frame)
// of audio data - used to sync audio to video after seeking
// if you don't return CONTROL_TRUE, it will defaults to:
// ds_fill_buffer(sh_audio->ds); // skip 1 demux packet
...
return CONTROL_TRUE;
}
return CONTROL_UNKNOWN;
}

76
libmpcodecs/native/alaw.h
View File

@ -1,76 +0,0 @@
// Generated by TOOLS/alaw-gen.c
#ifndef MPLAYER_ALAW_H
#define MPLAYER_ALAW_H
const short alaw2short[]={
-5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
-7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
-2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
-3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
-22016, -20992, -24064, -23040, -17920, -16896, -19968, -18944,
-30208, -29184, -32256, -31232, -26112, -25088, -28160, -27136,
-11008, -10496, -12032, -11520, -8960, -8448, -9984, -9472,
-15104, -14592, -16128, -15616, -13056, -12544, -14080, -13568,
-344, -328, -376, -360, -280, -264, -312, -296,
-472, -456, -504, -488, -408, -392, -440, -424,
-88, -72, -120, -104, -24, -8, -56, -40,
-216, -200, -248, -232, -152, -136, -184, -168,
-1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
-1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
-688, -656, -752, -720, -560, -528, -624, -592,
-944, -912, -1008, -976, -816, -784, -880, -848,
5504, 5248, 6016, 5760, 4480, 4224, 4992, 4736,
7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784,
2752, 2624, 3008, 2880, 2240, 2112, 2496, 2368,
3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392,
22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
11008, 10496, 12032, 11520, 8960, 8448, 9984, 9472,
15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
344, 328, 376, 360, 280, 264, 312, 296,
472, 456, 504, 488, 408, 392, 440, 424,
88, 72, 120, 104, 24, 8, 56, 40,
216, 200, 248, 232, 152, 136, 184, 168,
1376, 1312, 1504, 1440, 1120, 1056, 1248, 1184,
1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696,
688, 656, 752, 720, 560, 528, 624, 592,
944, 912, 1008, 976, 816, 784, 880, 848
};
const short ulaw2short[]={
-32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956,
-23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764,
-15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412,
-11900, -11388, -10876, -10364, -9852, -9340, -8828, -8316,
-7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
-5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
-3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
-2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
-1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
-1372, -1308, -1244, -1180, -1116, -1052, -988, -924,
-876, -844, -812, -780, -748, -716, -684, -652,
-620, -588, -556, -524, -492, -460, -428, -396,
-372, -356, -340, -324, -308, -292, -276, -260,
-244, -228, -212, -196, -180, -164, -148, -132,
-120, -112, -104, -96, -88, -80, -72, -64,
-56, -48, -40, -32, -24, -16, -8, 0,
32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316,
7932, 7676, 7420, 7164, 6908, 6652, 6396, 6140,
5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
876, 844, 812, 780, 748, 716, 684, 652,
620, 588, 556, 524, 492, 460, 428, 396,
372, 356, 340, 324, 308, 292, 276, 260,
244, 228, 212, 196, 180, 164, 148, 132,
120, 112, 104, 96, 88, 80, 72, 64,
56, 48, 40, 32, 24, 16, 8, 0
};
#endif /* MPLAYER_ALAW_H */

20
libmpcodecs/vd.c
View File

@ -37,34 +37,14 @@
#include "vf.h"
#include "libvo/video_out.h"
extern const vd_functions_t mpcodecs_vd_null;
extern const vd_functions_t mpcodecs_vd_ffmpeg;
extern const vd_functions_t mpcodecs_vd_raw;
extern const vd_functions_t mpcodecs_vd_hmblck;
extern const vd_functions_t mpcodecs_vd_mpng;
extern const vd_functions_t mpcodecs_vd_ijpg;
extern const vd_functions_t mpcodecs_vd_mtga;
extern const vd_functions_t mpcodecs_vd_realvid;
extern const vd_functions_t mpcodecs_vd_lzo;
extern const vd_functions_t mpcodecs_vd_qtvideo;
/* Please do not add any new decoders here. If you want to implement a new
* decoder, add it to libavcodec, except for wrappers around external
* libraries and decoders requiring binary support. */
const vd_functions_t * const mpcodecs_vd_drivers[] = {
&mpcodecs_vd_null,
&mpcodecs_vd_ffmpeg,
&mpcodecs_vd_lzo,
&mpcodecs_vd_raw,
&mpcodecs_vd_hmblck,
#ifdef CONFIG_PNG
&mpcodecs_vd_mpng,
#endif
#ifdef CONFIG_JPEG
&mpcodecs_vd_ijpg,
#endif
&mpcodecs_vd_mtga,
/* Please do not add any new decoders here. If you want to implement a new
* decoder, add it to libavcodec, except for wrappers around external
* libraries and decoders requiring binary support. */

151
libmpcodecs/vd_hmblck.c
View File

@ -1,151 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#include "mp_msg.h"
#include "vd_internal.h"
static const vd_info_t info = {
"Hauppauge Macroblock/NV12/NV21 Decoder",
"hmblck",
"Alex <d18c7db@hotmail.com>, A'rpi, Alex Beregszaszi",
"Alex <d18c7db@hotmail.com>",
"uncompressed"
};
LIBVD_EXTERN(hmblck)
static void de_macro_y(unsigned char* dst,unsigned char* src,int dstride,int w,int h){
unsigned int y;
// descramble Y plane
for (y=0; y<h; y+=16) {
unsigned int x;
for (x=0; x<w; x+=16) {
unsigned int i;
for (i=0; i<16; i++) {
memcpy(dst + x + (y+i)*dstride, src, 16);
src+=16;
}
}
}
}
static void de_macro_uv(unsigned char* dstu,unsigned char* dstv,unsigned char* src,int dstride,int w,int h){
unsigned int y;
// descramble U/V plane
for (y=0; y<h; y+=16) {
unsigned int x;
for (x=0; x<w; x+=8) {
unsigned int i;
for (i=0; i<16; i++) {
int idx=x + (y+i)*dstride;
dstu[idx+0]=src[0]; dstv[idx+0]=src[1];
dstu[idx+1]=src[2]; dstv[idx+1]=src[3];
dstu[idx+2]=src[4]; dstv[idx+2]=src[5];
dstu[idx+3]=src[6]; dstv[idx+3]=src[7];
dstu[idx+4]=src[8]; dstv[idx+4]=src[9];
dstu[idx+5]=src[10]; dstv[idx+5]=src[11];
dstu[idx+6]=src[12]; dstv[idx+6]=src[13];
dstu[idx+7]=src[14]; dstv[idx+7]=src[15];
src+=16;
}
}
}
}
/*************************************************************************
* convert a nv12 buffer to yv12
*/
static int nv12_to_yv12(unsigned char *data, int len, mp_image_t* mpi, int swapped) {
unsigned int Y_size = mpi->width * mpi->height;
unsigned int UV_size = mpi->chroma_width * mpi->chroma_height;
unsigned int idx;
unsigned char *dst_Y = mpi->planes[0];
unsigned char *dst_U = mpi->planes[1];
unsigned char *dst_V = mpi->planes[2];
unsigned char *src = data + Y_size;
// sanity check raw stream
if ( (len != (Y_size + (UV_size<<1))) ) {
mp_msg(MSGT_DECVIDEO, MSGL_ERR,
"hmblck: Image size inconsistent with data size.\n");
return 0;
}
if (mpi->num_planes != 3) {
mp_msg(MSGT_DECVIDEO,MSGL_ERR,
"hmblck: Incorrect number of image planes.\n");
return 0;
}
// luma data is easy, just copy it
memcpy(dst_Y, data, Y_size);
// chroma data is interlaced UVUV... so deinterlace it
for(idx=0; idx<UV_size; idx++ ) {
*(dst_U + idx) = *(src + (idx<<1) + (swapped ? 1 : 0));
*(dst_V + idx) = *(src + (idx<<1) + (swapped ? 0 : 1));
}
return 1;
}
/*************************************************************************
* set/get/query special features/parameters
*/
static int control(sh_video_t *sh,int cmd, void *arg,...){
return CONTROL_UNKNOWN;
}
/*************************************************************************
* init driver
*/
static int init(sh_video_t *sh){
return mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,sh->format);
}
/*************************************************************************
* uninit driver
*/
static void uninit(sh_video_t *sh){
}
/*************************************************************************
* decode a frame
*/
static mp_image_t* decode(sh_video_t *sh,void* data,int len,int flags){
mp_image_t* mpi;
if(len<=0) return NULL; // skipped frame
mpi=mpcodecs_get_image(sh, MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE,
sh->disp_w, sh->disp_h);
if(!mpi) return NULL;
if(sh->format == IMGFMT_HM12) {
//if(!de_macro(sh, data, len, flags, mpi)) return NULL;
de_macro_y(mpi->planes[0],data,mpi->stride[0],mpi->w,mpi->h);
de_macro_uv(mpi->planes[1],mpi->planes[2],
(unsigned char *)data+mpi->w*mpi->h,mpi->stride[1],
mpi->w/2,mpi->h/2);
} else {
if(!nv12_to_yv12(data, len, mpi,(sh->format == IMGFMT_NV21))) return NULL;
}
return mpi;
}
/*************************************************************************/

197
libmpcodecs/vd_ijpg.c
View File

@ -1,197 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
#include "mp_msg.h"
#include <jpeglib.h>
#define UINT16 IJPG_UINT16
#define INT16 IJPG_INT16
#include <setjmp.h>
#include "mpbswap.h"
#include "vd_internal.h"
static const vd_info_t info = {
"JPEG Images decoder",
"ijpg",
"Pontscho",
"based on vd_mpng.c",
"uses Independent JPEG Group's jpeglib"
};
LIBVD_EXTERN(ijpg)
static int last_w=-1;
static int last_h=-1;
static int last_depth=-1;
// to set/get/query special features/parameters
static int control(sh_video_t *sh,int cmd,void* arg,...){
if (cmd == VDCTRL_QUERY_FORMAT) {
int format = *(int *)arg;
if ((last_depth == 24 && format == IMGFMT_RGB24) ||
(last_depth == 8 && format == IMGFMT_Y8 ))
return CONTROL_TRUE;
return CONTROL_FALSE;
}
return CONTROL_UNKNOWN;
}
// init driver
static int init(sh_video_t *sh){
last_w=-1;
return 1;
}
// uninit driver
static void uninit(sh_video_t *sh){
}
//mp_image_t* mpcodecs_get_image(sh_video_t *sh, int mp_imgtype, int mp_imgflag, int w, int h);
typedef struct
{
struct jpeg_source_mgr pub;
unsigned char * inbuf;
int bufsize;
} my_source_mgr;
typedef my_source_mgr * my_src_ptr;
METHODDEF(void) init_source (j_decompress_ptr cinfo)
{
}
METHODDEF(boolean) fill_input_buffer (j_decompress_ptr cinfo)
{
my_src_ptr src = (my_src_ptr) cinfo->src;
src->pub.next_input_byte = src->inbuf;
src->pub.bytes_in_buffer = src->bufsize;
return TRUE;
}
METHODDEF(void) skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
my_src_ptr src = (my_src_ptr) cinfo->src;
if (num_bytes > 0)
{
while (num_bytes > (long) src->pub.bytes_in_buffer)
{
num_bytes -= (long) src->pub.bytes_in_buffer;
(void) fill_input_buffer(cinfo);
}
src->pub.next_input_byte += (size_t) num_bytes;
src->pub.bytes_in_buffer -= (size_t) num_bytes;
}
}
METHODDEF(void) term_source (j_decompress_ptr cinfo) { }
static void jpeg_buf_src (j_decompress_ptr cinfo, char * inbuf, int bufsize)
{
my_src_ptr src;
if (cinfo->src == NULL) cinfo->src=malloc( sizeof( my_source_mgr ) );
src = (my_src_ptr) cinfo->src;
src->pub.init_source = init_source;
src->pub.fill_input_buffer = fill_input_buffer;
src->pub.skip_input_data = skip_input_data;
src->pub.resync_to_restart = jpeg_resync_to_restart;
src->pub.term_source = term_source;
src->inbuf = inbuf;
src->bufsize=bufsize;
src->pub.bytes_in_buffer = 0;
src->pub.next_input_byte = NULL;
}
struct my_error_mgr
{
struct jpeg_error_mgr pub;
jmp_buf setjmp_buffer;
};
typedef struct my_error_mgr * my_error_ptr;
METHODDEF(void) my_error_exit (j_common_ptr cinfo)
{
my_error_ptr myerr=(my_error_ptr) cinfo->err;
(*cinfo->err->output_message) (cinfo);
longjmp(myerr->setjmp_buffer, 1);
}
// decode a frame
static mp_image_t* decode(sh_video_t *sh,void* data,int len,int flags){
struct jpeg_decompress_struct cinfo;
struct my_error_mgr jerr;
mp_image_t * mpi = NULL;
int width,height,depth,i;
if ( len <= 0 ) return NULL; // skipped frame
memset(&cinfo, 0, sizeof(cinfo));
memset(&jerr, 0, sizeof(jerr));
cinfo.err=jpeg_std_error( &jerr.pub );
jerr.pub.error_exit=my_error_exit;
if( setjmp( jerr.setjmp_buffer ) )
{
mp_msg( MSGT_DECVIDEO,MSGL_ERR,"[ijpg] setjmp error ...\n" );
return NULL;
}
jpeg_create_decompress( &cinfo );
jpeg_buf_src( &cinfo,data,len );
jpeg_read_header( &cinfo,TRUE );
sh->disp_w=width=cinfo.image_width;
sh->disp_h=height=cinfo.image_height;
jpeg_start_decompress( &cinfo );
depth=cinfo.output_components * 8;
switch( depth ) {
case 8:
case 24: break;
default: mp_msg( MSGT_DECVIDEO,MSGL_ERR,"Sorry, unsupported JPEG colorspace: %d.\n",depth ); return NULL;
}
if ( last_w!=width || last_h!=height || last_depth != depth )
{
last_depth = depth;
if(!mpcodecs_config_vo( sh,width,height, depth == 8 ? IMGFMT_Y8 : IMGFMT_RGB24 )) return NULL;
last_w=width; last_h=height;
}
mpi=mpcodecs_get_image( sh,MP_IMGTYPE_TEMP,MP_IMGFLAG_ACCEPT_STRIDE,width,height );
if ( !mpi ) return NULL;
for ( i=0;i < height;i++ )
{
unsigned char * drow = mpi->planes[0] + mpi->stride[0] * i;
jpeg_read_scanlines( &cinfo,(JSAMPLE**)&drow,1 );
}
jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
return mpi;
}

166
libmpcodecs/vd_lzo.c
View File

@ -1,166 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#include "mp_msg.h"
#include "vd_internal.h"
#include "libavutil/lzo.h"
#define MOD_NAME "DecLZO"
static const vd_info_t info = {
"LZO compressed Video",
"lzo",
"Tilmann Bitterberg",
"Transcode development team <http://www.theorie.physik.uni-goettingen.de/~ostreich/transcode/>",
"based on liblzo: http://www.oberhumer.com/opensource/lzo/"
};
LIBVD_EXTERN(lzo)
typedef struct {
uint8_t *buffer;
int bufsz;
int codec;
} lzo_context_t;
// to set/get/query special features/parameters
static int control (sh_video_t *sh, int cmd, void* arg, ...)
{
lzo_context_t *priv = sh->context;
switch(cmd){
case VDCTRL_QUERY_FORMAT:
if (*(int *)arg == priv->codec) return CONTROL_TRUE;
return CONTROL_FALSE;
}
return CONTROL_UNKNOWN;
}
// init driver
static int init(sh_video_t *sh)
{
lzo_context_t *priv;
if (sh->bih->biSizeImage <= 0) {
mp_msg (MSGT_DECVIDEO, MSGL_ERR, "[%s] Invalid frame size\n", MOD_NAME);
return 0;
}
priv = malloc(sizeof(lzo_context_t));
if (!priv)
{
mp_msg (MSGT_DECVIDEO, MSGL_ERR, "[%s] memory allocation failed\n", MOD_NAME);
return 0;
}
priv->bufsz = sh->bih->biSizeImage;
priv->buffer = malloc(priv->bufsz + AV_LZO_OUTPUT_PADDING);
priv->codec = -1;
sh->context = priv;
return 1;
}
// uninit driver
static void uninit(sh_video_t *sh)
{
lzo_context_t *priv = sh->context;
if (priv)
{
free(priv->buffer);
free(priv);
}
sh->context = NULL;
}
// decode a frame
static mp_image_t* decode(sh_video_t *sh,void* data,int len,int flags)
{
int r;
mp_image_t* mpi;
lzo_context_t *priv = sh->context;
int w = priv->bufsz;
if (len <= 0) {
return NULL; // skipped frame
}
r = av_lzo1x_decode(priv->buffer, &w, data, &len);
if (r) {
/* this should NEVER happen */
mp_msg (MSGT_DECVIDEO, MSGL_ERR,
"[%s] internal error - decompression failed: %d\n", MOD_NAME, r);
return NULL;
}
if (priv->codec == -1) {
// detect RGB24 vs. YV12 via decoded size
mp_msg (MSGT_DECVIDEO, MSGL_V, "[%s] 2 depth %d, format %d data %p len (%d) (%d)\n",
MOD_NAME, sh->bih->biBitCount, sh->format, data, len, sh->bih->biSizeImage
);
if (w == 0) {
priv->codec = IMGFMT_BGR24;
mp_msg (MSGT_DECVIDEO, MSGL_V, "[%s] codec chosen is BGR24\n", MOD_NAME);
} else if (w == (sh->bih->biSizeImage)/2) {
priv->codec = IMGFMT_YV12;
mp_msg (MSGT_DECVIDEO, MSGL_V, "[%s] codec chosen is YV12\n", MOD_NAME);
} else {
priv->codec = -1;
mp_msg(MSGT_DECVIDEO,MSGL_ERR,"[%s] Unsupported out_fmt\n", MOD_NAME);
return NULL;
}
if(!mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,priv->codec)) {
priv->codec = -1;
return NULL;
}
}
mpi = mpcodecs_get_image(sh, MP_IMGTYPE_EXPORT, 0,
sh->disp_w, sh->disp_h);
if (!mpi) {
mp_msg (MSGT_DECVIDEO, MSGL_ERR, "[%s] mpcodecs_get_image failed\n", MOD_NAME);
return NULL;
}
mpi->planes[0] = priv->buffer;
if (priv->codec == IMGFMT_BGR24)
mpi->stride[0] = 3 * sh->disp_w;
else {
mpi->stride[0] = sh->disp_w;
mpi->planes[2] = priv->buffer + sh->disp_w*sh->disp_h;
mpi->stride[2] = sh->disp_w / 2;
mpi->planes[1] = priv->buffer + sh->disp_w*sh->disp_h*5/4;
mpi->stride[1] = sh->disp_w / 2;
}
mp_msg (MSGT_DECVIDEO, MSGL_DBG2,
"[%s] decompressed %lu bytes into %lu bytes\n", MOD_NAME,
(long) len, (long)w);
return mpi;
}

182
libmpcodecs/vd_mpng.c
View File

@ -1,182 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#include "mp_msg.h"
#include <png.h>
#include "libavutil/common.h"
#include "mpbswap.h"
#include "libvo/fastmemcpy.h"
#include "vd_internal.h"
static const vd_info_t info = {
"PNG Images decoder",
"mpng",
"A'rpi",
".so, based on mpng.c",
"uses libpng, 8bpp modes not supported yet"
};
LIBVD_EXTERN(mpng)
static unsigned int out_fmt=0;
static int last_w=-1;
static int last_h=-1;
static int last_c=-1;
// to set/get/query special features/parameters
static int control(sh_video_t *sh,int cmd,void* arg,...){
switch (cmd)
{
case VDCTRL_QUERY_FORMAT:
if (*((int *) arg) == out_fmt) return CONTROL_TRUE;
return CONTROL_FALSE;
}
return CONTROL_UNKNOWN;
}
// init driver
static int init(sh_video_t *sh){
last_w=-1;
return 1;
}
// uninit driver
static void uninit(sh_video_t *sh){
}
//mp_image_t* mpcodecs_get_image(sh_video_t *sh, int mp_imgtype, int mp_imgflag, int w, int h);
static int pngPointer;
static int pngLength;
static void pngReadFN( png_structp pngstr,png_bytep buffer,png_size_t size )
{
char * p = png_get_io_ptr(pngstr);
if(size>pngLength-pngPointer && pngLength>=pngPointer) size=pngLength-pngPointer;
fast_memcpy( buffer,(char *)&p[pngPointer],size );
pngPointer+=size;
}
// decode a frame
static mp_image_t* decode(sh_video_t *sh,void* data,int len,int flags){
png_structp png;
png_infop info;
png_infop endinfo;
// png_bytep data;
png_bytep * row_p;
png_uint_32 png_width=0,png_height=0;
int depth,color;
png_uint_32 i;
png_byte color_type;
mp_image_t* mpi;
int cols;
png_colorp pal;
unsigned char *p;
if(len<=0) return NULL; // skipped frame
png=png_create_read_struct( PNG_LIBPNG_VER_STRING,NULL,NULL,NULL );
info=png_create_info_struct( png );
endinfo=png_create_info_struct( png );
pngPointer=8;
pngLength=len;
png_set_read_fn( png,data,pngReadFN );
png_set_strip_16( png );
png_set_sig_bytes( png,8 );
png_read_info( png,info );
png_get_IHDR( png,info,&png_width,&png_height,&depth,&color,NULL,NULL,NULL );
png_set_bgr( png );
color_type=png_get_color_type(png, info);
switch( color_type ) {
case PNG_COLOR_TYPE_GRAY_ALPHA:
mp_msg( MSGT_DECVIDEO,MSGL_INFO,"Sorry gray scaled png with alpha channel not supported at moment.\n" );
break;
case PNG_COLOR_TYPE_GRAY:
out_fmt=IMGFMT_Y800;
break;
case PNG_COLOR_TYPE_PALETTE:
out_fmt=IMGFMT_BGR8;
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
out_fmt=IMGFMT_BGR32;
break;
case PNG_COLOR_TYPE_RGB:
out_fmt=IMGFMT_BGR24;
break;
default:
mp_msg( MSGT_DECVIDEO,MSGL_INFO,"Sorry, unsupported PNG colorspace: %d.\n" ,color_type);
}
// (re)init libvo if image parameters changed (width/height/colorspace)
if(last_w!=png_width || last_h!=png_height || last_c!=out_fmt){
last_w=png_width; last_h=png_height; last_c=out_fmt;
if(!out_fmt) return NULL;
if(!mpcodecs_config_vo(sh,png_width,png_height,out_fmt)) return NULL;
}
#if 0
switch( info->color_type )
{
case PNG_COLOR_TYPE_GRAY_ALPHA: printf( "[png] used GrayA -> stripping alpha channel\n" ); break;
case PNG_COLOR_TYPE_GRAY: printf( "[png] used Gray -> rgb\n" ); break;
case PNG_COLOR_TYPE_PALETTE: printf( "[png] used palette -> rgb\n" ); break;
case PNG_COLOR_TYPE_RGB_ALPHA: printf( "[png] used RGBA -> stripping alpha channel\n" ); break;
case PNG_COLOR_TYPE_RGB: printf( "[png] read rgb datas.\n" ); break;
}
#endif
mpi=mpcodecs_get_image(sh, MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE,
png_width,png_height);
if(!mpi) return NULL;
// Let's DECODE!
row_p=malloc( sizeof( png_bytep ) * png_height );
//png_get_rowbytes( png,info )
for ( i=0; i < png_height; i++ ) row_p[i]=mpi->planes[0] + mpi->stride[0]*i;
png_read_image( png,row_p );
free( row_p );
if (out_fmt==IMGFMT_BGR8) {
png_get_PLTE( png,info,&pal,&cols );
mpi->planes[1] = realloc(mpi->planes[1], 4*cols);
p = mpi->planes[1];
for (i = 0; i < cols; i++) {
*p++ = pal[i].blue;
*p++ = pal[i].green;
*p++ = pal[i].red;
*p++ = 0;
}
}
png_read_end( png,endinfo );
png_destroy_read_struct( &png,&info,&endinfo );
return mpi;
}

252
libmpcodecs/vd_mtga.c
View File

@ -1,252 +0,0 @@
/*
* based on: XreaL's x_r_img_tga.* (http://www.sourceforge.net/projects/xreal/)
* libtarga.*
* xli's tga.*
*
* Copyright (c) 2002 Tilman Sauerbeck <tsauerbeck@users.sourceforge.net>
*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libavutil/intreadwrite.h>
#include "config.h"
#include "mp_msg.h"
#include "libvo/fastmemcpy.h"
#include "vd_internal.h"
static const vd_info_t info =
{
"TGA Images decoder",
"mtga",
"Tilman Sauerbeck, A'rpi",
"Tilman Sauerbeck",
"only 24bpp and 32bpp RGB targa files support so far"
};
LIBVD_EXTERN(mtga)
typedef enum
{
TGA_NO_DATA,
TGA_UNCOMP_PALETTED,
TGA_UNCOMP_TRUECOLOR,
TGA_UNCOMP_GRAYSCALE,
TGA_RLE_PALETTED = 9,
TGA_RLE_TRUECOLOR,
TGA_RLE_GRAYSCALE
} TGAImageType;
typedef struct
{
unsigned char id_len;
unsigned short img_type;
unsigned short width;
unsigned short height;
unsigned char bpp;
unsigned char origin; /* 0 = lower left, 1 = upper left */
unsigned short start_row;
short increment;
} TGAInfo;
static unsigned int out_fmt = 0;
static int last_w = -1;
static int last_h = -1;
static int last_c = -1;
/* to set/get/query special features/parameters */
static int control(sh_video_t *sh, int cmd, void *arg, ...)
{
switch (cmd)
{
case VDCTRL_QUERY_FORMAT:
if (*((int *) arg) == out_fmt) return CONTROL_TRUE;
return CONTROL_FALSE;
}
return CONTROL_UNKNOWN;
}
/* init driver */
static int init(sh_video_t *sh)
{
sh->context = calloc(1, sizeof(TGAInfo));
last_w = -1;
return 1;
}
/* uninit driver */
static void uninit(sh_video_t *sh)
{
TGAInfo *info = sh->context;
free(info);
return;
}
/* decode a runlength-encoded tga */
static void decode_rle_tga(TGAInfo *info, unsigned char *data, mp_image_t *mpi)
{
int row, col, replen, i, num_bytes = info->bpp / 8;
unsigned char repetitions, packet_header, *final;
/* see line 207 to see why this loop is set up like this */
for (row = info->start_row; (!info->origin && row) || (info->origin && row < info->height); row += info->increment)
{
final = mpi->planes[0] + mpi->stride[0] * row;
for (col = 0; col < info->width; col += repetitions)
{
packet_header = *data++;
repetitions = (1 + (packet_header & 0x7f));
replen = repetitions * num_bytes;
if (packet_header & 0x80) /* runlength encoded packet */
{
memcpy(final, data, num_bytes);
// Note: this will be slow when DR to vram!
i=num_bytes;
while(2*i<=replen){
memcpy(final+i,final,i);
i*=2;
}
memcpy(final+i,final,replen-i);
data += num_bytes;
}
else /* raw packet */
{
fast_memcpy(final, data, replen);
data += replen;
}
final += replen;
}
}
return;
}
static void decode_uncompressed_tga(TGAInfo *info, unsigned char *data, mp_image_t *mpi)
{
unsigned char *final;
int row, num_bytes = info->bpp / 8;
/* see line 207 to see why this loop is set up like this */
for (row = info->start_row; (!info->origin && row) || (info->origin && row < info->height); row += info->increment)
{
final = mpi->planes[0] + mpi->stride[0] * row;
fast_memcpy(final, data, info->width * num_bytes);
data += info->width * num_bytes;
}
return;
}
static short read_tga_header(unsigned char *buf, TGAInfo *info)
{
info->id_len = buf[0];
info->img_type = buf[2];
/* targa data is always stored in little endian byte order */
info->width = AV_RL16(&buf[12]);
info->height = AV_RL16(&buf[14]);
info->bpp = buf[16];
info->origin = (buf[17] & 0x20) >> 5;
/* FIXME check for valid targa data */
return 0;
}
/* decode a frame */
static mp_image_t *decode(sh_video_t *sh, void *raw, int len, int flags)
{
TGAInfo *info = sh->context;
unsigned char *data = raw;
mp_image_t *mpi;
if (len <= 0)
return NULL; /* skip frame */
read_tga_header(data, info); /* read information about the file */
if (info->bpp == 24)
out_fmt = IMGFMT_BGR24;
else if (info->bpp == 32)
out_fmt = IMGFMT_BGR32;
else
{
mp_msg(MSGT_DECVIDEO, MSGL_INFO, "Unsupported TGA type! depth=%d\n",info->bpp);
return NULL;
}
if (info->img_type != TGA_UNCOMP_TRUECOLOR && info->img_type != TGA_RLE_TRUECOLOR) /* not a true color image */
{
mp_msg(MSGT_DECVIDEO, MSGL_INFO, "Unsupported TGA type: %i!\n", info->img_type);
return NULL;
}
/* if img.origin is 0, we decode from bottom to top. if it's 1, we decode from top to bottom */
info->start_row = (info->origin) ? 0 : info->height - 1;
info->increment = (info->origin) ? 1 : -1;
/* set data to the beginning of the image data */
data += 18 + info->id_len;
/* (re)init libvo if image parameters changed (width/height/colorspace) */
if (last_w != info->width || last_h != info->height || last_c != out_fmt)
{
last_w = info->width;
last_h = info->height;
last_c = out_fmt;
if (!out_fmt || !mpcodecs_config_vo(sh, info->width, info->height, out_fmt))
return NULL;
}
if (!(mpi = mpcodecs_get_image(sh, MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE, info->width, info->height)))
return NULL;
/* finally decode the image */
if (info->img_type == TGA_UNCOMP_TRUECOLOR)
decode_uncompressed_tga(info, data, mpi);
else if (info->img_type == TGA_RLE_TRUECOLOR)
decode_rle_tga(info, data, mpi);
// else
// mpi = NULL;
return mpi;
}

142
libmpcodecs/vd_raw.c
View File

@ -1,142 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#include "mp_msg.h"
#include "vd_internal.h"
static const vd_info_t info = {
"RAW Uncompressed Video",
"raw",
"A'rpi",
"A'rpi & Alex",
"uncompressed"
};
LIBVD_EXTERN(raw)
// to set/get/query special features/parameters
static int control(sh_video_t *sh,int cmd,void* arg,...){
int format = sh->bih ? sh->bih->biCompression : sh->format;
switch(cmd){
case VDCTRL_QUERY_FORMAT:
if (*(int *)arg == format) return CONTROL_TRUE;
if (*(int *)arg == IMGFMT_YUY2 && format == MKTAG('y', 'u', 'v', '2')) return CONTROL_TRUE;
return CONTROL_FALSE;
}
return CONTROL_UNKNOWN;
}
// init driver
static int init(sh_video_t *sh){
// set format fourcc for raw RGB:
if(sh->bih && sh->bih->biCompression==0){ // set based on bit depth
switch(sh->bih->biBitCount){
case 1: sh->bih->biCompression=IMGFMT_BGR1; break;
case 4: sh->bih->biCompression=IMGFMT_BGR4; break;
case 8: sh->bih->biCompression=IMGFMT_BGR8; break;
case 15: sh->bih->biCompression=IMGFMT_BGR15; break;
// workaround bitcount==16 => bgr15 case for avi files:
case 16: sh->bih->biCompression=(sh->format)?IMGFMT_BGR16:IMGFMT_BGR15; break;
case 24: sh->bih->biCompression=IMGFMT_BGR24; break;
case 32: sh->bih->biCompression=IMGFMT_BGR32; break;
default:
mp_msg(MSGT_DECVIDEO,MSGL_WARN,"RAW: depth %d not supported\n",sh->bih->biBitCount);
}
}
return mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,sh->bih ? sh->bih->biCompression : sh->format);
}
// uninit driver
static void uninit(sh_video_t *sh){
}
//mp_image_t* mpcodecs_get_image(sh_video_t *sh, int mp_imgtype, int mp_imgflag, int w, int h);
// decode a frame
static mp_image_t* decode(sh_video_t *sh,void* data,int len,int flags){
mp_image_t* mpi;
int frame_size;
int format = sh->bih ? sh->bih->biCompression : sh->format;
if(len<=0) return NULL; // skipped frame
mpi=mpcodecs_get_image(sh, MP_IMGTYPE_EXPORT, 0,
sh->disp_w, sh->disp_h);
if(!mpi) return NULL;
if(mpi->flags&MP_IMGFLAG_PLANAR){
// TODO !!!
mpi->planes[0]=data;
mpi->stride[0]=mpi->width;
frame_size=mpi->stride[0]*mpi->h;
if((mpi->imgfmt == IMGFMT_NV12) || (mpi->imgfmt == IMGFMT_NV21))
{
mpi->planes[1]=mpi->planes[0]+mpi->width*mpi->height;
mpi->stride[1]=mpi->chroma_width;
frame_size+=mpi->chroma_width*mpi->chroma_height;
} else if(mpi->flags&MP_IMGFLAG_YUV) {
int cb=2, cr=1;
if(mpi->flags&MP_IMGFLAG_SWAPPED) {
cb=1; cr=2;
}
// Support for some common Planar YUV formats
/* YV12,I420,IYUV */
mpi->planes[cb]=mpi->planes[0]+mpi->width*mpi->height;
mpi->stride[cb]=mpi->chroma_width;
mpi->planes[cr]=mpi->planes[cb]+mpi->chroma_width*mpi->chroma_height;
mpi->stride[cr]=mpi->chroma_width;
frame_size+=2*mpi->chroma_width*mpi->chroma_height;
}
} else {
mpi->planes[0]=data;
mpi->stride[0]=mpi->width*(mpi->bpp/8);
// .AVI files has uncompressed lines 4-byte aligned:
if(sh->format==0 || sh->format==3) mpi->stride[0]=(mpi->stride[0]+3)&(~3);
if(mpi->imgfmt==IMGFMT_RGB8 || mpi->imgfmt==IMGFMT_BGR8){
// export palette:
mpi->planes[1]=sh->bih ? (unsigned char*)(sh->bih+1) : NULL;
#if 0
printf("Exporting palette: %p !!\n",mpi->planes[1]);
{ unsigned char* p=mpi->planes[1];
int i;
for(i=0;i<64;i++) printf("%3d: %02X %02X %02X (%02X)\n",i,p[4*i],p[4*i+1],p[4*i+2],p[4*i+3]);
}
#endif
}
frame_size=mpi->stride[0]*mpi->h;
if (len >= frame_size && format == MKTAG('y', 'u', 'v', '2')) {
int i;
for (i = 1; i < frame_size; i += 2)
mpi->planes[0][i] ^= 128;
}
if(mpi->bpp<8) frame_size=frame_size*mpi->bpp/8;
}
if(len<frame_size){
mp_msg(MSGT_DECVIDEO,MSGL_WARN,"Frame too small! (%d<%d) Wrong format?\n",
len,frame_size);
return NULL;
}
return mpi;
}

122
libmpdemux/mp3_hdr.c
View File

@ -1,122 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stdio.h>
#include <stdint.h>
#include "config.h"
#include "mp3_hdr.h"
#include "mp_msg.h"
//----------------------- mp3 audio frame header parser -----------------------
static const uint16_t tabsel_123[2][3][16] = {
{ {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0},
{0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,0},
{0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,0} },
{ {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,0},
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0},
{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0} }
};
static const int freqs[9] = { 44100, 48000, 32000, // MPEG 1.0
22050, 24000, 16000, // MPEG 2.0
11025, 12000, 8000}; // MPEG 2.5
/*
* return frame size or -1 (bad frame)
*/
int mp_get_mp3_header(unsigned char* hbuf,int* chans, int* srate, int* spf, int* mpa_layer, int* br){
int stereo,lsf,framesize,padding,bitrate_index,sampling_frequency, divisor;
int bitrate;
int layer;
static const int mult[3] = { 12000, 144000, 144000 };
uint32_t newhead =
hbuf[0] << 24 |
hbuf[1] << 16 |
hbuf[2] << 8 |
hbuf[3];
// head_check:
if( (newhead & 0xffe00000) != 0xffe00000 ){
mp_msg(MSGT_DEMUXER,MSGL_DBG2,"head_check failed\n");
return -1;
}
layer = 4-((newhead>>17)&3);
if(layer==4){
mp_msg(MSGT_DEMUXER,MSGL_DBG2,"not layer-1/2/3\n");
return -1;
}
sampling_frequency = (newhead>>10)&0x3; // valid: 0..2
if(sampling_frequency==3){
mp_msg(MSGT_DEMUXER,MSGL_DBG2,"invalid sampling_frequency\n");
return -1;
}
if( newhead & (1<<20) ) {
// MPEG 1.0 (lsf==0) or MPEG 2.0 (lsf==1)
lsf = !(newhead & (1<<19));
sampling_frequency += lsf*3;
} else {
// MPEG 2.5
lsf = 1;
sampling_frequency += 6;
}
bitrate_index = (newhead>>12)&0xf; // valid: 1..14
padding = (newhead>>9)&0x1;
stereo = ( ((newhead>>6)&0x3) == 3) ? 1 : 2;
bitrate = tabsel_123[lsf][layer-1][bitrate_index];
framesize = bitrate * mult[layer-1];
mp_msg(MSGT_DEMUXER,MSGL_DBG2,"FRAMESIZE: %d, layer: %d, bitrate: %d, mult: %d\n",
framesize, layer, tabsel_123[lsf][layer-1][bitrate_index], mult[layer-1]);
if(!framesize){
mp_msg(MSGT_DEMUXER,MSGL_DBG2,"invalid framesize/bitrate_index\n");
return -1;
}
divisor = layer == 3 ? (freqs[sampling_frequency] << lsf) : freqs[sampling_frequency];
framesize /= divisor;
framesize += padding;
if(layer==1)
framesize *= 4;
if(srate)
*srate = freqs[sampling_frequency];
if(spf) {
if(layer == 1)
*spf = 384;
else if(layer == 2)
*spf = 1152;
else if(sampling_frequency > 2) // not 1.0
*spf = 576;
else
*spf = 1152;
}
if(mpa_layer) *mpa_layer = layer;
if(chans) *chans = stereo;
if(br) *br = bitrate;
return framesize;
}

36
libmpdemux/mp3_hdr.h
View File

@ -1,36 +0,0 @@
/*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef MPLAYER_MP3_HDR_H
#define MPLAYER_MP3_HDR_H
#include <stddef.h>
int mp_get_mp3_header(unsigned char* hbuf,int* chans, int* freq, int* spf, int* mpa_layer, int* br);
#define mp_decode_mp3_header(hbuf) mp_get_mp3_header(hbuf,NULL,NULL,NULL,NULL,NULL)
static inline int mp_check_mp3_header(unsigned int head){
unsigned char tmp[4] = {head >> 24, head >> 16, head >> 8, head};
if( (head & 0xffe00000) != 0xffe00000 ||
(head & 0x00000c00) == 0x00000c00) return 0;
if(mp_decode_mp3_header(tmp)<=0) return 0;
return 1;
}
#endif /* MPLAYER_MP3_HDR_H */

589
libmpdemux/qtpalette.h
View File

@ -1,589 +0,0 @@
/*
* default palettes for QuickTime files
* Automatically generated from a utility derived from XAnim:
* http://xanim.va.pubnix.com/home.html
*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef MPLAYER_QTPALETTE_H
#define MPLAYER_QTPALETTE_H
static const unsigned char qt_default_palette_4[4 * 4] = {
0x5E, 0x65, 0x93, 0x00,
0xFF, 0xFF, 0xFF, 0x00,
0xAB, 0xD0, 0xDF, 0x00,
0x00, 0x00, 0x00, 0x00
};
static const unsigned char qt_default_palette_16[16 * 4] = {
0xFF, 0xFB, 0xFF, 0x00,
0xBB, 0xD9, 0xEF, 0x00,
0xB1, 0xC9, 0xE8, 0x00,
0x5E, 0x65, 0x93, 0x00,
0xE8, 0xDE, 0xFC, 0x00,
0x91, 0x88, 0x9D, 0x00,
0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00,
0xFF, 0xFF, 0xFF, 0x00,
0x37, 0x48, 0x47, 0x00,
0x55, 0x5E, 0x7A, 0x00,
0xAB, 0xD0, 0xDF, 0x00,
0xF9, 0xFB, 0xFF, 0x00,
0xC5, 0xCA, 0xE8, 0x00,
0x77, 0x7C, 0x8A, 0x00,
0x00, 0x00, 0x00, 0x00
};
static const unsigned char qt_default_palette_256[256 * 4] = {
/* 0, 0x00 */ 0xFF, 0xFF, 0xFF, 0x00,
/* 1, 0x01 */ 0xCC, 0xFF, 0xFF, 0x00,
/* 2, 0x02 */ 0x99, 0xFF, 0xFF, 0x00,
/* 3, 0x03 */ 0x66, 0xFF, 0xFF, 0x00,
/* 4, 0x04 */ 0x33, 0xFF, 0xFF, 0x00,
/* 5, 0x05 */ 0x00, 0xFF, 0xFF, 0x00,
/* 6, 0x06 */ 0xFF, 0xCC, 0xFF, 0x00,
/* 7, 0x07 */ 0xCC, 0xCC, 0xFF, 0x00,
/* 8, 0x08 */ 0x99, 0xCC, 0xFF, 0x00,
/* 9, 0x09 */ 0x66, 0xCC, 0xFF, 0x00,
/* 10, 0x0A */ 0x33, 0xCC, 0xFF, 0x00,
/* 11, 0x0B */ 0x00, 0xCC, 0xFF, 0x00,
/* 12, 0x0C */ 0xFF, 0x99, 0xFF, 0x00,
/* 13, 0x0D */ 0xCC, 0x99, 0xFF, 0x00,
/* 14, 0x0E */ 0x99, 0x99, 0xFF, 0x00,
/* 15, 0x0F */ 0x66, 0x99, 0xFF, 0x00,
/* 16, 0x10 */ 0x33, 0x99, 0xFF, 0x00,
/* 17, 0x11 */ 0x00, 0x99, 0xFF, 0x00,
/* 18, 0x12 */ 0xFF, 0x66, 0xFF, 0x00,
/* 19, 0x13 */ 0xCC, 0x66, 0xFF, 0x00,
/* 20, 0x14 */ 0x99, 0x66, 0xFF, 0x00,
/* 21, 0x15 */ 0x66, 0x66, 0xFF, 0x00,
/* 22, 0x16 */ 0x33, 0x66, 0xFF, 0x00,
/* 23, 0x17 */ 0x00, 0x66, 0xFF, 0x00,
/* 24, 0x18 */ 0xFF, 0x33, 0xFF, 0x00,
/* 25, 0x19 */ 0xCC, 0x33, 0xFF, 0x00,
/* 26, 0x1A */ 0x99, 0x33, 0xFF, 0x00,
/* 27, 0x1B */ 0x66, 0x33, 0xFF, 0x00,
/* 28, 0x1C */ 0x33, 0x33, 0xFF, 0x00,
/* 29, 0x1D */ 0x00, 0x33, 0xFF, 0x00,
/* 30, 0x1E */ 0xFF, 0x00, 0xFF, 0x00,
/* 31, 0x1F */ 0xCC, 0x00, 0xFF, 0x00,
/* 32, 0x20 */ 0x99, 0x00, 0xFF, 0x00,
/* 33, 0x21 */ 0x66, 0x00, 0xFF, 0x00,
/* 34, 0x22 */ 0x33, 0x00, 0xFF, 0x00,
/* 35, 0x23 */ 0x00, 0x00, 0xFF, 0x00,
/* 36, 0x24 */ 0xFF, 0xFF, 0xCC, 0x00,
/* 37, 0x25 */ 0xCC, 0xFF, 0xCC, 0x00,
/* 38, 0x26 */ 0x99, 0xFF, 0xCC, 0x00,
/* 39, 0x27 */ 0x66, 0xFF, 0xCC, 0x00,
/* 40, 0x28 */ 0x33, 0xFF, 0xCC, 0x00,
/* 41, 0x29 */ 0x00, 0xFF, 0xCC, 0x00,
/* 42, 0x2A */ 0xFF, 0xCC, 0xCC, 0x00,
/* 43, 0x2B */ 0xCC, 0xCC, 0xCC, 0x00,
/* 44, 0x2C */ 0x99, 0xCC, 0xCC, 0x00,
/* 45, 0x2D */ 0x66, 0xCC, 0xCC, 0x00,
/* 46, 0x2E */ 0x33, 0xCC, 0xCC, 0x00,
/* 47, 0x2F */ 0x00, 0xCC, 0xCC, 0x00,
/* 48, 0x30 */ 0xFF, 0x99, 0xCC, 0x00,
/* 49, 0x31 */ 0xCC, 0x99, 0xCC, 0x00,
/* 50, 0x32 */ 0x99, 0x99, 0xCC, 0x00,
/* 51, 0x33 */ 0x66, 0x99, 0xCC, 0x00,
/* 52, 0x34 */ 0x33, 0x99, 0xCC, 0x00,
/* 53, 0x35 */ 0x00, 0x99, 0xCC, 0x00,
/* 54, 0x36 */ 0xFF, 0x66, 0xCC, 0x00,
/* 55, 0x37 */ 0xCC, 0x66, 0xCC, 0x00,
/* 56, 0x38 */ 0x99, 0x66, 0xCC, 0x00,
/* 57, 0x39 */ 0x66, 0x66, 0xCC, 0x00,
/* 58, 0x3A */ 0x33, 0x66, 0xCC, 0x00,
/* 59, 0x3B */ 0x00, 0x66, 0xCC, 0x00,
/* 60, 0x3C */ 0xFF, 0x33, 0xCC, 0x00,
/* 61, 0x3D */ 0xCC, 0x33, 0xCC, 0x00,
/* 62, 0x3E */ 0x99, 0x33, 0xCC, 0x00,
/* 63, 0x3F */ 0x66, 0x33, 0xCC, 0x00,
/* 64, 0x40 */ 0x33, 0x33, 0xCC, 0x00,
/* 65, 0x41 */ 0x00, 0x33, 0xCC, 0x00,
/* 66, 0x42 */ 0xFF, 0x00, 0xCC, 0x00,
/* 67, 0x43 */ 0xCC, 0x00, 0xCC, 0x00,
/* 68, 0x44 */ 0x99, 0x00, 0xCC, 0x00,
/* 69, 0x45 */ 0x66, 0x00, 0xCC, 0x00,
/* 70, 0x46 */ 0x33, 0x00, 0xCC, 0x00,
/* 71, 0x47 */ 0x00, 0x00, 0xCC, 0x00,
/* 72, 0x48 */ 0xFF, 0xFF, 0x99, 0x00,
/* 73, 0x49 */ 0xCC, 0xFF, 0x99, 0x00,
/* 74, 0x4A */ 0x99, 0xFF, 0x99, 0x00,
/* 75, 0x4B */ 0x66, 0xFF, 0x99, 0x00,
/* 76, 0x4C */ 0x33, 0xFF, 0x99, 0x00,
/* 77, 0x4D */ 0x00, 0xFF, 0x99, 0x00,
/* 78, 0x4E */ 0xFF, 0xCC, 0x99, 0x00,
/* 79, 0x4F */ 0xCC, 0xCC, 0x99, 0x00,
/* 80, 0x50 */ 0x99, 0xCC, 0x99, 0x00,
/* 81, 0x51 */ 0x66, 0xCC, 0x99, 0x00,
/* 82, 0x52 */ 0x33, 0xCC, 0x99, 0x00,
/* 83, 0x53 */ 0x00, 0xCC, 0x99, 0x00,
/* 84, 0x54 */ 0xFF, 0x99, 0x99, 0x00,
/* 85, 0x55 */ 0xCC, 0x99, 0x99, 0x00,
/* 86, 0x56 */ 0x99, 0x99, 0x99, 0x00,
/* 87, 0x57 */ 0x66, 0x99, 0x99, 0x00,
/* 88, 0x58 */ 0x33, 0x99, 0x99, 0x00,
/* 89, 0x59 */ 0x00, 0x99, 0x99, 0x00,
/* 90, 0x5A */ 0xFF, 0x66, 0x99, 0x00,
/* 91, 0x5B */ 0xCC, 0x66, 0x99, 0x00,
/* 92, 0x5C */ 0x99, 0x66, 0x99, 0x00,
/* 93, 0x5D */ 0x66, 0x66, 0x99, 0x00,
/* 94, 0x5E */ 0x33, 0x66, 0x99, 0x00,
/* 95, 0x5F */ 0x00, 0x66, 0x99, 0x00,
/* 96, 0x60 */ 0xFF, 0x33, 0x99, 0x00,
/* 97, 0x61 */ 0xCC, 0x33, 0x99, 0x00,
/* 98, 0x62 */ 0x99, 0x33, 0x99, 0x00,
/* 99, 0x63 */ 0x66, 0x33, 0x99, 0x00,
/* 100, 0x64 */ 0x33, 0x33, 0x99, 0x00,
/* 101, 0x65 */ 0x00, 0x33, 0x99, 0x00,
/* 102, 0x66 */ 0xFF, 0x00, 0x99, 0x00,
/* 103, 0x67 */ 0xCC, 0x00, 0x99, 0x00,
/* 104, 0x68 */ 0x99, 0x00, 0x99, 0x00,
/* 105, 0x69 */ 0x66, 0x00, 0x99, 0x00,
/* 106, 0x6A */ 0x33, 0x00, 0x99, 0x00,
/* 107, 0x6B */ 0x00, 0x00, 0x99, 0x00,
/* 108, 0x6C */ 0xFF, 0xFF, 0x66, 0x00,
/* 109, 0x6D */ 0xCC, 0xFF, 0x66, 0x00,
/* 110, 0x6E */ 0x99, 0xFF, 0x66, 0x00,
/* 111, 0x6F */ 0x66, 0xFF, 0x66, 0x00,
/* 112, 0x70 */ 0x33, 0xFF, 0x66, 0x00,
/* 113, 0x71 */ 0x00, 0xFF, 0x66, 0x00,
/* 114, 0x72 */ 0xFF, 0xCC, 0x66, 0x00,
/* 115, 0x73 */ 0xCC, 0xCC, 0x66, 0x00,
/* 116, 0x74 */ 0x99, 0xCC, 0x66, 0x00,
/* 117, 0x75 */ 0x66, 0xCC, 0x66, 0x00,
/* 118, 0x76 */ 0x33, 0xCC, 0x66, 0x00,
/* 119, 0x77 */ 0x00, 0xCC, 0x66, 0x00,
/* 120, 0x78 */ 0xFF, 0x99, 0x66, 0x00,
/* 121, 0x79 */ 0xCC, 0x99, 0x66, 0x00,
/* 122, 0x7A */ 0x99, 0x99, 0x66, 0x00,
/* 123, 0x7B */ 0x66, 0x99, 0x66, 0x00,
/* 124, 0x7C */ 0x33, 0x99, 0x66, 0x00,
/* 125, 0x7D */ 0x00, 0x99, 0x66, 0x00,
/* 126, 0x7E */ 0xFF, 0x66, 0x66, 0x00,
/* 127, 0x7F */ 0xCC, 0x66, 0x66, 0x00,
/* 128, 0x80 */ 0x99, 0x66, 0x66, 0x00,
/* 129, 0x81 */ 0x66, 0x66, 0x66, 0x00,
/* 130, 0x82 */ 0x33, 0x66, 0x66, 0x00,
/* 131, 0x83 */ 0x00, 0x66, 0x66, 0x00,
/* 132, 0x84 */ 0xFF, 0x33, 0x66, 0x00,
/* 133, 0x85 */ 0xCC, 0x33, 0x66, 0x00,
/* 134, 0x86 */ 0x99, 0x33, 0x66, 0x00,
/* 135, 0x87 */ 0x66, 0x33, 0x66, 0x00,
/* 136, 0x88 */ 0x33, 0x33, 0x66, 0x00,
/* 137, 0x89 */ 0x00, 0x33, 0x66, 0x00,
/* 138, 0x8A */ 0xFF, 0x00, 0x66, 0x00,
/* 139, 0x8B */ 0xCC, 0x00, 0x66, 0x00,
/* 140, 0x8C */ 0x99, 0x00, 0x66, 0x00,
/* 141, 0x8D */ 0x66, 0x00, 0x66, 0x00,
/* 142, 0x8E */ 0x33, 0x00, 0x66, 0x00,
/* 143, 0x8F */ 0x00, 0x00, 0x66, 0x00,
/* 144, 0x90 */ 0xFF, 0xFF, 0x33, 0x00,
/* 145, 0x91 */ 0xCC, 0xFF, 0x33, 0x00,
/* 146, 0x92 */ 0x99, 0xFF, 0x33, 0x00,
/* 147, 0x93 */ 0x66, 0xFF, 0x33, 0x00,
/* 148, 0x94 */ 0x33, 0xFF, 0x33, 0x00,
/* 149, 0x95 */ 0x00, 0xFF, 0x33, 0x00,
/* 150, 0x96 */ 0xFF, 0xCC, 0x33, 0x00,
/* 151, 0x97 */ 0xCC, 0xCC, 0x33, 0x00,
/* 152, 0x98 */ 0x99, 0xCC, 0x33, 0x00,
/* 153, 0x99 */ 0x66, 0xCC, 0x33, 0x00,
/* 154, 0x9A */ 0x33, 0xCC, 0x33, 0x00,
/* 155, 0x9B */ 0x00, 0xCC, 0x33, 0x00,
/* 156, 0x9C */ 0xFF, 0x99, 0x33, 0x00,
/* 157, 0x9D */ 0xCC, 0x99, 0x33, 0x00,
/* 158, 0x9E */ 0x99, 0x99, 0x33, 0x00,
/* 159, 0x9F */ 0x66, 0x99, 0x33, 0x00,
/* 160, 0xA0 */ 0x33, 0x99, 0x33, 0x00,
/* 161, 0xA1 */ 0x00, 0x99, 0x33, 0x00,
/* 162, 0xA2 */ 0xFF, 0x66, 0x33, 0x00,
/* 163, 0xA3 */ 0xCC, 0x66, 0x33, 0x00,
/* 164, 0xA4 */ 0x99, 0x66, 0x33, 0x00,
/* 165, 0xA5 */ 0x66, 0x66, 0x33, 0x00,
/* 166, 0xA6 */ 0x33, 0x66, 0x33, 0x00,
/* 167, 0xA7 */ 0x00, 0x66, 0x33, 0x00,
/* 168, 0xA8 */ 0xFF, 0x33, 0x33, 0x00,
/* 169, 0xA9 */ 0xCC, 0x33, 0x33, 0x00,
/* 170, 0xAA */ 0x99, 0x33, 0x33, 0x00,
/* 171, 0xAB */ 0x66, 0x33, 0x33, 0x00,
/* 172, 0xAC */ 0x33, 0x33, 0x33, 0x00,
/* 173, 0xAD */ 0x00, 0x33, 0x33, 0x00,
/* 174, 0xAE */ 0xFF, 0x00, 0x33, 0x00,
/* 175, 0xAF */ 0xCC, 0x00, 0x33, 0x00,
/* 176, 0xB0 */ 0x99, 0x00, 0x33, 0x00,
/* 177, 0xB1 */ 0x66, 0x00, 0x33, 0x00,
/* 178, 0xB2 */ 0x33, 0x00, 0x33, 0x00,
/* 179, 0xB3 */ 0x00, 0x00, 0x33, 0x00,
/* 180, 0xB4 */ 0xFF, 0xFF, 0x00, 0x00,
/* 181, 0xB5 */ 0xCC, 0xFF, 0x00, 0x00,
/* 182, 0xB6 */ 0x99, 0xFF, 0x00, 0x00,
/* 183, 0xB7 */ 0x66, 0xFF, 0x00, 0x00,
/* 184, 0xB8 */ 0x33, 0xFF, 0x00, 0x00,
/* 185, 0xB9 */ 0x00, 0xFF, 0x00, 0x00,
/* 186, 0xBA */ 0xFF, 0xCC, 0x00, 0x00,
/* 187, 0xBB */ 0xCC, 0xCC, 0x00, 0x00,
/* 188, 0xBC */ 0x99, 0xCC, 0x00, 0x00,
/* 189, 0xBD */ 0x66, 0xCC, 0x00, 0x00,
/* 190, 0xBE */ 0x33, 0xCC, 0x00, 0x00,
/* 191, 0xBF */ 0x00, 0xCC, 0x00, 0x00,
/* 192, 0xC0 */ 0xFF, 0x99, 0x00, 0x00,
/* 193, 0xC1 */ 0xCC, 0x99, 0x00, 0x00,
/* 194, 0xC2 */ 0x99, 0x99, 0x00, 0x00,
/* 195, 0xC3 */ 0x66, 0x99, 0x00, 0x00,
/* 196, 0xC4 */ 0x33, 0x99, 0x00, 0x00,
/* 197, 0xC5 */ 0x00, 0x99, 0x00, 0x00,
/* 198, 0xC6 */ 0xFF, 0x66, 0x00, 0x00,
/* 199, 0xC7 */ 0xCC, 0x66, 0x00, 0x00,
/* 200, 0xC8 */ 0x99, 0x66, 0x00, 0x00,
/* 201, 0xC9 */ 0x66, 0x66, 0x00, 0x00,
/* 202, 0xCA */ 0x33, 0x66, 0x00, 0x00,
/* 203, 0xCB */ 0x00, 0x66, 0x00, 0x00,
/* 204, 0xCC */ 0xFF, 0x33, 0x00, 0x00,
/* 205, 0xCD */ 0xCC, 0x33, 0x00, 0x00,
/* 206, 0xCE */ 0x99, 0x33, 0x00, 0x00,
/* 207, 0xCF */ 0x66, 0x33, 0x00, 0x00,
/* 208, 0xD0 */ 0x33, 0x33, 0x00, 0x00,
/* 209, 0xD1 */ 0x00, 0x33, 0x00, 0x00,
/* 210, 0xD2 */ 0xFF, 0x00, 0x00, 0x00,
/* 211, 0xD3 */ 0xCC, 0x00, 0x00, 0x00,
/* 212, 0xD4 */ 0x99, 0x00, 0x00, 0x00,
/* 213, 0xD5 */ 0x66, 0x00, 0x00, 0x00,
/* 214, 0xD6 */ 0x33, 0x00, 0x00, 0x00,
/* 215, 0xD7 */ 0x00, 0x00, 0xEE, 0x00,
/* 216, 0xD8 */ 0x00, 0x00, 0xDD, 0x00,
/* 217, 0xD9 */ 0x00, 0x00, 0xBB, 0x00,
/* 218, 0xDA */ 0x00, 0x00, 0xAA, 0x00,
/* 219, 0xDB */ 0x00, 0x00, 0x88, 0x00,
/* 220, 0xDC */ 0x00, 0x00, 0x77, 0x00,
/* 221, 0xDD */ 0x00, 0x00, 0x55, 0x00,
/* 222, 0xDE */ 0x00, 0x00, 0x44, 0x00,
/* 223, 0xDF */ 0x00, 0x00, 0x22, 0x00,
/* 224, 0xE0 */ 0x00, 0x00, 0x11, 0x00,
/* 225, 0xE1 */ 0x00, 0xEE, 0x00, 0x00,
/* 226, 0xE2 */ 0x00, 0xDD, 0x00, 0x00,
/* 227, 0xE3 */ 0x00, 0xBB, 0x00, 0x00,
/* 228, 0xE4 */ 0x00, 0xAA, 0x00, 0x00,
/* 229, 0xE5 */ 0x00, 0x88, 0x00, 0x00,
/* 230, 0xE6 */ 0x00, 0x77, 0x00, 0x00,
/* 231, 0xE7 */ 0x00, 0x55, 0x00, 0x00,
/* 232, 0xE8 */ 0x00, 0x44, 0x00, 0x00,
/* 233, 0xE9 */ 0x00, 0x22, 0x00, 0x00,
/* 234, 0xEA */ 0x00, 0x11, 0x00, 0x00,
/* 235, 0xEB */ 0xEE, 0x00, 0x00, 0x00,
/* 236, 0xEC */ 0xDD, 0x00, 0x00, 0x00,
/* 237, 0xED */ 0xBB, 0x00, 0x00, 0x00,
/* 238, 0xEE */ 0xAA, 0x00, 0x00, 0x00,
/* 239, 0xEF */ 0x88, 0x00, 0x00, 0x00,
/* 240, 0xF0 */ 0x77, 0x00, 0x00, 0x00,
/* 241, 0xF1 */ 0x55, 0x00, 0x00, 0x00,
/* 242, 0xF2 */ 0x44, 0x00, 0x00, 0x00,
/* 243, 0xF3 */ 0x22, 0x00, 0x00, 0x00,
/* 244, 0xF4 */ 0x11, 0x00, 0x00, 0x00,
/* 245, 0xF5 */ 0xEE, 0xEE, 0xEE, 0x00,
/* 246, 0xF6 */ 0xDD, 0xDD, 0xDD, 0x00,
/* 247, 0xF7 */ 0xBB, 0xBB, 0xBB, 0x00,
/* 248, 0xF8 */ 0xAA, 0xAA, 0xAA, 0x00,
/* 249, 0xF9 */ 0x88, 0x88, 0x88, 0x00,
/* 250, 0xFA */ 0x77, 0x77, 0x77, 0x00,
/* 251, 0xFB */ 0x55, 0x55, 0x55, 0x00,
/* 252, 0xFC */ 0x44, 0x44, 0x44, 0x00,
/* 253, 0xFD */ 0x22, 0x22, 0x22, 0x00,
/* 254, 0xFE */ 0x11, 0x11, 0x11, 0x00,
/* 255, 0xFF */ 0x00, 0x00, 0x00, 0x00
};
static const unsigned char qt_default_grayscale_palette_16[16 * 4] = {
0xFF, 0xFF, 0xFF, 0xFF,
0xEE, 0xEE, 0xEE, 0xEE,
0xDD, 0xDD, 0xDD, 0xDD,
0xCC, 0xCC, 0xCC, 0xCC,
0xBB, 0xBB, 0xBB, 0xBB,
0xAA, 0xAA, 0xAA, 0xAA,
0x99, 0x99, 0x99, 0x99,
0x88, 0x88, 0x88, 0x88,
0x77, 0x77, 0x77, 0x77,
0x66, 0x66, 0x66, 0x66,
0x55, 0x55, 0x55, 0x55,
0x44, 0x44, 0x44, 0x44,
0x33, 0x33, 0x33, 0x33,
0x22, 0x22, 0x22, 0x22,
0x11, 0x11, 0x11, 0x11,
0x00, 0x00, 0x00, 0x00
};
static const unsigned char qt_default_grayscale_palette_256[256 * 4] = {
/* 0, 0x00 */ 0xFF, 0xFF, 0xFF, 0xFF,
/* 1, 0x01 */ 0xFE, 0xFE, 0xFE, 0xFE,
/* 2, 0x02 */ 0xFD, 0xFD, 0xFD, 0xFD,
/* 3, 0x03 */ 0xFC, 0xFC, 0xFC, 0xFC,
/* 4, 0x04 */ 0xFB, 0xFB, 0xFB, 0xFB,
/* 5, 0x05 */ 0xFA, 0xFA, 0xFA, 0xFA,
/* 6, 0x06 */ 0xF9, 0xF9, 0xF9, 0xF9,
/* 7, 0x07 */ 0xF8, 0xF8, 0xF8, 0xF8,
/* 8, 0x08 */ 0xF7, 0xF7, 0xF7, 0xF7,
/* 9, 0x09 */ 0xF6, 0xF6, 0xF6, 0xF6,
/* 10, 0x0A */ 0xF5, 0xF5, 0xF5, 0xF5,
/* 11, 0x0B */ 0xF4, 0xF4, 0xF4, 0xF4,
/* 12, 0x0C */ 0xF3, 0xF3, 0xF3, 0xF3,
/* 13, 0x0D */ 0xF2, 0xF2, 0xF2, 0xF2,
/* 14, 0x0E */ 0xF1, 0xF1, 0xF1, 0xF1,
/* 15, 0x0F */ 0xF0, 0xF0, 0xF0, 0xF0,
/* 16, 0x10 */ 0xEF, 0xEF, 0xEF, 0xEF,
/* 17, 0x11 */ 0xEE, 0xEE, 0xEE, 0xEE,
/* 18, 0x12 */ 0xED, 0xED, 0xED, 0xED,
/* 19, 0x13 */ 0xEC, 0xEC, 0xEC, 0xEC,
/* 20, 0x14 */ 0xEB, 0xEB, 0xEB, 0xEB,
/* 21, 0x15 */ 0xEA, 0xEA, 0xEA, 0xEA,
/* 22, 0x16 */ 0xE9, 0xE9, 0xE9, 0xE9,
/* 23, 0x17 */ 0xE8, 0xE8, 0xE8, 0xE8,
/* 24, 0x18 */ 0xE7, 0xE7, 0xE7, 0xE7,
/* 25, 0x19 */ 0xE6, 0xE6, 0xE6, 0xE6,
/* 26, 0x1A */ 0xE5, 0xE5, 0xE5, 0xE5,
/* 27, 0x1B */ 0xE4, 0xE4, 0xE4, 0xE4,
/* 28, 0x1C */ 0xE3, 0xE3, 0xE3, 0xE3,
/* 29, 0x1D */ 0xE2, 0xE2, 0xE2, 0xE2,
/* 30, 0x1E */ 0xE1, 0xE1, 0xE1, 0xE1,
/* 31, 0x1F */ 0xE0, 0xE0, 0xE0, 0xE0,
/* 32, 0x20 */ 0xDF, 0xDF, 0xDF, 0xDF,
/* 33, 0x21 */ 0xDE, 0xDE, 0xDE, 0xDE,
/* 34, 0x22 */ 0xDD, 0xDD, 0xDD, 0xDD,
/* 35, 0x23 */ 0xDC, 0xDC, 0xDC, 0xDC,
/* 36, 0x24 */ 0xDB, 0xDB, 0xDB, 0xDB,
/* 37, 0x25 */ 0xDA, 0xDA, 0xDA, 0xDA,
/* 38, 0x26 */ 0xD9, 0xD9, 0xD9, 0xD9,
/* 39, 0x27 */ 0xD8, 0xD8, 0xD8, 0xD8,
/* 40, 0x28 */ 0xD7, 0xD7, 0xD7, 0xD7,
/* 41, 0x29 */ 0xD6, 0xD6, 0xD6, 0xD6,
/* 42, 0x2A */ 0xD5, 0xD5, 0xD5, 0xD5,
/* 43, 0x2B */ 0xD4, 0xD4, 0xD4, 0xD4,
/* 44, 0x2C */ 0xD3, 0xD3, 0xD3, 0xD3,
/* 45, 0x2D */ 0xD2, 0xD2, 0xD2, 0xD2,
/* 46, 0x2E */ 0xD1, 0xD1, 0xD1, 0xD1,
/* 47, 0x2F */ 0xD0, 0xD0, 0xD0, 0xD0,
/* 48, 0x30 */ 0xCF, 0xCF, 0xCF, 0xCF,
/* 49, 0x31 */ 0xCE, 0xCE, 0xCE, 0xCE,
/* 50, 0x32 */ 0xCD, 0xCD, 0xCD, 0xCD,
/* 51, 0x33 */ 0xCC, 0xCC, 0xCC, 0xCC,
/* 52, 0x34 */ 0xCB, 0xCB, 0xCB, 0xCB,
/* 53, 0x35 */ 0xCA, 0xCA, 0xCA, 0xCA,
/* 54, 0x36 */ 0xC9, 0xC9, 0xC9, 0xC9,
/* 55, 0x37 */ 0xC8, 0xC8, 0xC8, 0xC8,
/* 56, 0x38 */ 0xC7, 0xC7, 0xC7, 0xC7,
/* 57, 0x39 */ 0xC6, 0xC6, 0xC6, 0xC6,
/* 58, 0x3A */ 0xC5, 0xC5, 0xC5, 0xC5,
/* 59, 0x3B */ 0xC4, 0xC4, 0xC4, 0xC4,
/* 60, 0x3C */ 0xC3, 0xC3, 0xC3, 0xC3,
/* 61, 0x3D */ 0xC2, 0xC2, 0xC2, 0xC2,
/* 62, 0x3E */ 0xC1, 0xC1, 0xC1, 0xC1,
/* 63, 0x3F */ 0xC0, 0xC0, 0xC0, 0xC0,
/* 64, 0x40 */ 0xBF, 0xBF, 0xBF, 0xBF,
/* 65, 0x41 */ 0xBE, 0xBE, 0xBE, 0xBE,
/* 66, 0x42 */ 0xBD, 0xBD, 0xBD, 0xBD,
/* 67, 0x43 */ 0xBC, 0xBC, 0xBC, 0xBC,
/* 68, 0x44 */ 0xBB, 0xBB, 0xBB, 0xBB,
/* 69, 0x45 */ 0xBA, 0xBA, 0xBA, 0xBA,
/* 70, 0x46 */ 0xB9, 0xB9, 0xB9, 0xB9,
/* 71, 0x47 */ 0xB8, 0xB8, 0xB8, 0xB8,
/* 72, 0x48 */ 0xB7, 0xB7, 0xB7, 0xB7,
/* 73, 0x49 */ 0xB6, 0xB6, 0xB6, 0xB6,
/* 74, 0x4A */ 0xB5, 0xB5, 0xB5, 0xB5,
/* 75, 0x4B */ 0xB4, 0xB4, 0xB4, 0xB4,
/* 76, 0x4C */ 0xB3, 0xB3, 0xB3, 0xB3,
/* 77, 0x4D */ 0xB2, 0xB2, 0xB2, 0xB2,
/* 78, 0x4E */ 0xB1, 0xB1, 0xB1, 0xB1,
/* 79, 0x4F */ 0xB0, 0xB0, 0xB0, 0xB0,
/* 80, 0x50 */ 0xAF, 0xAF, 0xAF, 0xAF,
/* 81, 0x51 */ 0xAE, 0xAE, 0xAE, 0xAE,
/* 82, 0x52 */ 0xAD, 0xAD, 0xAD, 0xAD,
/* 83, 0x53 */ 0xAC, 0xAC, 0xAC, 0xAC,
/* 84, 0x54 */ 0xAB, 0xAB, 0xAB, 0xAB,
/* 85, 0x55 */ 0xAA, 0xAA, 0xAA, 0xAA,
/* 86, 0x56 */ 0xA9, 0xA9, 0xA9, 0xA9,
/* 87, 0x57 */ 0xA8, 0xA8, 0xA8, 0xA8,
/* 88, 0x58 */ 0xA7, 0xA7, 0xA7, 0xA7,
/* 89, 0x59 */ 0xA6, 0xA6, 0xA6, 0xA6,
/* 90, 0x5A */ 0xA5, 0xA5, 0xA5, 0xA5,
/* 91, 0x5B */ 0xA4, 0xA4, 0xA4, 0xA4,
/* 92, 0x5C */ 0xA3, 0xA3, 0xA3, 0xA3,
/* 93, 0x5D */ 0xA2, 0xA2, 0xA2, 0xA2,
/* 94, 0x5E */ 0xA1, 0xA1, 0xA1, 0xA1,
/* 95, 0x5F */ 0xA0, 0xA0, 0xA0, 0xA0,
/* 96, 0x60 */ 0x9F, 0x9F, 0x9F, 0x9F,
/* 97, 0x61 */ 0x9E, 0x9E, 0x9E, 0x9E,
/* 98, 0x62 */ 0x9D, 0x9D, 0x9D, 0x9D,
/* 99, 0x63 */ 0x9C, 0x9C, 0x9C, 0x9C,
/* 100, 0x64 */ 0x9B, 0x9B, 0x9B, 0x9B,
/* 101, 0x65 */ 0x9A, 0x9A, 0x9A, 0x9A,
/* 102, 0x66 */ 0x99, 0x99, 0x99, 0x99,
/* 103, 0x67 */ 0x98, 0x98, 0x98, 0x98,
/* 104, 0x68 */ 0x97, 0x97, 0x97, 0x97,
/* 105, 0x69 */ 0x96, 0x96, 0x96, 0x96,
/* 106, 0x6A */ 0x95, 0x95, 0x95, 0x95,
/* 107, 0x6B */ 0x94, 0x94, 0x94, 0x94,
/* 108, 0x6C */ 0x93, 0x93, 0x93, 0x93,
/* 109, 0x6D */ 0x92, 0x92, 0x92, 0x92,
/* 110, 0x6E */ 0x91, 0x91, 0x91, 0x91,
/* 111, 0x6F */ 0x90, 0x90, 0x90, 0x90,
/* 112, 0x70 */ 0x8F, 0x8F, 0x8F, 0x8F,
/* 113, 0x71 */ 0x8E, 0x8E, 0x8E, 0x8E,
/* 114, 0x72 */ 0x8D, 0x8D, 0x8D, 0x8D,
/* 115, 0x73 */ 0x8C, 0x8C, 0x8C, 0x8C,
/* 116, 0x74 */ 0x8B, 0x8B, 0x8B, 0x8B,
/* 117, 0x75 */ 0x8A, 0x8A, 0x8A, 0x8A,
/* 118, 0x76 */ 0x89, 0x89, 0x89, 0x89,
/* 119, 0x77 */ 0x88, 0x88, 0x88, 0x88,
/* 120, 0x78 */ 0x87, 0x87, 0x87, 0x87,
/* 121, 0x79 */ 0x86, 0x86, 0x86, 0x86,
/* 122, 0x7A */ 0x85, 0x85, 0x85, 0x85,
/* 123, 0x7B */ 0x84, 0x84, 0x84, 0x84,
/* 124, 0x7C */ 0x83, 0x83, 0x83, 0x83,
/* 125, 0x7D */ 0x82, 0x82, 0x82, 0x82,
/* 126, 0x7E */ 0x81, 0x81, 0x81, 0x81,
/* 127, 0x7F */ 0x80, 0x80, 0x80, 0x80,
/* 128, 0x80 */ 0x7F, 0x7F, 0x7F, 0x7F,
/* 129, 0x81 */ 0x7E, 0x7E, 0x7E, 0x7E,
/* 130, 0x82 */ 0x7D, 0x7D, 0x7D, 0x7D,
/* 131, 0x83 */ 0x7C, 0x7C, 0x7C, 0x7C,
/* 132, 0x84 */ 0x7B, 0x7B, 0x7B, 0x7B,
/* 133, 0x85 */ 0x7A, 0x7A, 0x7A, 0x7A,
/* 134, 0x86 */ 0x79, 0x79, 0x79, 0x79,
/* 135, 0x87 */ 0x78, 0x78, 0x78, 0x78,
/* 136, 0x88 */ 0x77, 0x77, 0x77, 0x77,
/* 137, 0x89 */ 0x76, 0x76, 0x76, 0x76,
/* 138, 0x8A */ 0x75, 0x75, 0x75, 0x75,
/* 139, 0x8B */ 0x74, 0x74, 0x74, 0x74,
/* 140, 0x8C */ 0x73, 0x73, 0x73, 0x73,
/* 141, 0x8D */ 0x72, 0x72, 0x72, 0x72,
/* 142, 0x8E */ 0x71, 0x71, 0x71, 0x71,
/* 143, 0x8F */ 0x70, 0x70, 0x70, 0x70,
/* 144, 0x90 */ 0x6F, 0x6F, 0x6F, 0x6F,
/* 145, 0x91 */ 0x6E, 0x6E, 0x6E, 0x6E,
/* 146, 0x92 */ 0x6D, 0x6D, 0x6D, 0x6D,
/* 147, 0x93 */ 0x6C, 0x6C, 0x6C, 0x6C,
/* 148, 0x94 */ 0x6B, 0x6B, 0x6B, 0x6B,
/* 149, 0x95 */ 0x6A, 0x6A, 0x6A, 0x6A,
/* 150, 0x96 */ 0x69, 0x69, 0x69, 0x69,
/* 151, 0x97 */ 0x68, 0x68, 0x68, 0x68,
/* 152, 0x98 */ 0x67, 0x67, 0x67, 0x67,
/* 153, 0x99 */ 0x66, 0x66, 0x66, 0x66,
/* 154, 0x9A */ 0x65, 0x65, 0x65, 0x65,
/* 155, 0x9B */ 0x64, 0x64, 0x64, 0x64,
/* 156, 0x9C */ 0x63, 0x63, 0x63, 0x63,
/* 157, 0x9D */ 0x62, 0x62, 0x62, 0x62,
/* 158, 0x9E */ 0x61, 0x61, 0x61, 0x61,
/* 159, 0x9F */ 0x60, 0x60, 0x60, 0x60,
/* 160, 0xA0 */ 0x5F, 0x5F, 0x5F, 0x5F,
/* 161, 0xA1 */ 0x5E, 0x5E, 0x5E, 0x5E,
/* 162, 0xA2 */ 0x5D, 0x5D, 0x5D, 0x5D,
/* 163, 0xA3 */ 0x5C, 0x5C, 0x5C, 0x5C,
/* 164, 0xA4 */ 0x5B, 0x5B, 0x5B, 0x5B,
/* 165, 0xA5 */ 0x5A, 0x5A, 0x5A, 0x5A,
/* 166, 0xA6 */ 0x59, 0x59, 0x59, 0x59,
/* 167, 0xA7 */ 0x58, 0x58, 0x58, 0x58,
/* 168, 0xA8 */ 0x57, 0x57, 0x57, 0x57,
/* 169, 0xA9 */ 0x56, 0x56, 0x56, 0x56,
/* 170, 0xAA */ 0x55, 0x55, 0x55, 0x55,
/* 171, 0xAB */ 0x54, 0x54, 0x54, 0x54,
/* 172, 0xAC */ 0x53, 0x53, 0x53, 0x53,
/* 173, 0xAD */ 0x52, 0x52, 0x52, 0x52,
/* 174, 0xAE */ 0x51, 0x51, 0x51, 0x51,
/* 175, 0xAF */ 0x50, 0x50, 0x50, 0x50,
/* 176, 0xB0 */ 0x4F, 0x4F, 0x4F, 0x4F,
/* 177, 0xB1 */ 0x4E, 0x4E, 0x4E, 0x4E,
/* 178, 0xB2 */ 0x4D, 0x4D, 0x4D, 0x4D,
/* 179, 0xB3 */ 0x4C, 0x4C, 0x4C, 0x4C,
/* 180, 0xB4 */ 0x4B, 0x4B, 0x4B, 0x4B,
/* 181, 0xB5 */ 0x4A, 0x4A, 0x4A, 0x4A,
/* 182, 0xB6 */ 0x49, 0x49, 0x49, 0x49,
/* 183, 0xB7 */ 0x48, 0x48, 0x48, 0x48,
/* 184, 0xB8 */ 0x47, 0x47, 0x47, 0x47,
/* 185, 0xB9 */ 0x46, 0x46, 0x46, 0x46,
/* 186, 0xBA */ 0x45, 0x45, 0x45, 0x45,
/* 187, 0xBB */ 0x44, 0x44, 0x44, 0x44,
/* 188, 0xBC */ 0x43, 0x43, 0x43, 0x43,
/* 189, 0xBD */ 0x42, 0x42, 0x42, 0x42,
/* 190, 0xBE */ 0x41, 0x41, 0x41, 0x41,
/* 191, 0xBF */ 0x40, 0x40, 0x40, 0x40,
/* 192, 0xC0 */ 0x3F, 0x3F, 0x3F, 0x3F,
/* 193, 0xC1 */ 0x3E, 0x3E, 0x3E, 0x3E,
/* 194, 0xC2 */ 0x3D, 0x3D, 0x3D, 0x3D,
/* 195, 0xC3 */ 0x3C, 0x3C, 0x3C, 0x3C,
/* 196, 0xC4 */ 0x3B, 0x3B, 0x3B, 0x3B,
/* 197, 0xC5 */ 0x3A, 0x3A, 0x3A, 0x3A,
/* 198, 0xC6 */ 0x39, 0x39, 0x39, 0x39,
/* 199, 0xC7 */ 0x38, 0x38, 0x38, 0x38,
/* 200, 0xC8 */ 0x37, 0x37, 0x37, 0x37,
/* 201, 0xC9 */ 0x36, 0x36, 0x36, 0x36,
/* 202, 0xCA */ 0x35, 0x35, 0x35, 0x35,
/* 203, 0xCB */ 0x34, 0x34, 0x34, 0x34,
/* 204, 0xCC */ 0x33, 0x33, 0x33, 0x33,
/* 205, 0xCD */ 0x32, 0x32, 0x32, 0x32,
/* 206, 0xCE */ 0x31, 0x31, 0x31, 0x31,
/* 207, 0xCF */ 0x30, 0x30, 0x30, 0x30,
/* 208, 0xD0 */ 0x2F, 0x2F, 0x2F, 0x2F,
/* 209, 0xD1 */ 0x2E, 0x2E, 0x2E, 0x2E,
/* 210, 0xD2 */ 0x2D, 0x2D, 0x2D, 0x2D,
/* 211, 0xD3 */ 0x2C, 0x2C, 0x2C, 0x2C,
/* 212, 0xD4 */ 0x2B, 0x2B, 0x2B, 0x2B,
/* 213, 0xD5 */ 0x2A, 0x2A, 0x2A, 0x2A,
/* 214, 0xD6 */ 0x29, 0x29, 0x29, 0x29,
/* 215, 0xD7 */ 0x28, 0x28, 0x28, 0x28,
/* 216, 0xD8 */ 0x27, 0x27, 0x27, 0x27,
/* 217, 0xD9 */ 0x26, 0x26, 0x26, 0x26,
/* 218, 0xDA */ 0x25, 0x25, 0x25, 0x25,
/* 219, 0xDB */ 0x24, 0x24, 0x24, 0x24,
/* 220, 0xDC */ 0x23, 0x23, 0x23, 0x23,
/* 221, 0xDD */ 0x22, 0x22, 0x22, 0x22,
/* 222, 0xDE */ 0x21, 0x21, 0x21, 0x21,
/* 223, 0xDF */ 0x20, 0x20, 0x20, 0x20,
/* 224, 0xE0 */ 0x1F, 0x1F, 0x1F, 0x1F,
/* 225, 0xE1 */ 0x1E, 0x1E, 0x1E, 0x1E,
/* 226, 0xE2 */ 0x1D, 0x1D, 0x1D, 0x1D,
/* 227, 0xE3 */ 0x1C, 0x1C, 0x1C, 0x1C,
/* 228, 0xE4 */ 0x1B, 0x1B, 0x1B, 0x1B,
/* 229, 0xE5 */ 0x1A, 0x1A, 0x1A, 0x1A,
/* 230, 0xE6 */ 0x19, 0x19, 0x19, 0x19,
/* 231, 0xE7 */ 0x18, 0x18, 0x18, 0x18,
/* 232, 0xE8 */ 0x17, 0x17, 0x17, 0x17,
/* 233, 0xE9 */ 0x16, 0x16, 0x16, 0x16,
/* 234, 0xEA */ 0x15, 0x15, 0x15, 0x15,
/* 235, 0xEB */ 0x14, 0x14, 0x14, 0x14,
/* 236, 0xEC */ 0x13, 0x13, 0x13, 0x13,
/* 237, 0xED */ 0x12, 0x12, 0x12, 0x12,
/* 238, 0xEE */ 0x11, 0x11, 0x11, 0x11,
/* 239, 0xEF */ 0x10, 0x10, 0x10, 0x10,
/* 240, 0xF0 */ 0x0F, 0x0F, 0x0F, 0x0F,
/* 241, 0xF1 */ 0x0E, 0x0E, 0x0E, 0x0E,
/* 242, 0xF2 */ 0x0D, 0x0D, 0x0D, 0x0D,
/* 243, 0xF3 */ 0x0C, 0x0C, 0x0C, 0x0C,
/* 244, 0xF4 */ 0x0B, 0x0B, 0x0B, 0x0B,
/* 245, 0xF5 */ 0x0A, 0x0A, 0x0A, 0x0A,
/* 246, 0xF6 */ 0x09, 0x09, 0x09, 0x09,
/* 247, 0xF7 */ 0x08, 0x08, 0x08, 0x08,
/* 248, 0xF8 */ 0x07, 0x07, 0x07, 0x07,
/* 249, 0xF9 */ 0x06, 0x06, 0x06, 0x06,
/* 250, 0xFA */ 0x05, 0x05, 0x05, 0x05,
/* 251, 0xFB */ 0x04, 0x04, 0x04, 0x04,
/* 252, 0xFC */ 0x03, 0x03, 0x03, 0x03,
/* 253, 0xFD */ 0x02, 0x02, 0x02, 0x02,
/* 254, 0xFE */ 0x01, 0x01, 0x01, 0x01,
/* 255, 0xFF */ 0x00, 0x00, 0x00, 0x00
};
#endif /* MPLAYER_QTPALETTE_H */