contrib/lib/libogg.a contrib/lib/libsamplerate.a
contrib/lib/libx264.a contrib/lib/libxvidcore.a
contrib/lib/libmkv.a contrib/lib/libswscale.a
- contrib/lib/libtheora.a ;
+ contrib/lib/libtheora.a contrib/lib/libfaad.a ;
if $(OS) = UNKNOWN
{
CXX="g++"
CCFLAGS="$CCFLAGS -Wall -g"
OPTIM="$OPTIM -O3 -funroll-loops"
-LINKLIBS="-lz"
+LINKLIBS="-lz -lbz2"
MAKE=make
# System-specific flags
Wget $(SUBDIR)/a52dec.tar.gz : $(SUBDIR)/version_a52dec.txt ;
LibA52 $(SUBDIR)/lib/liba52.a : $(SUBDIR)/a52dec.tar.gz ;
+# FAAD2
+rule LibFaad2
+{
+ Depends $(<) : $(>) ;
+ Depends lib : $(<) ;
+}
+
+actions LibFaad2
+{
+ cd `dirname $(>)` && CONTRIB=`pwd` &&
+ rm -rf faad2 && (gzip -dc faad2.tar.gz | tar xf -) &&
+ cd faad2 &&
+ ./bootstrap && ./configure --prefix=$CONTRIB --cache-file=$CONTRIB/config.cache --disable-shared && $(MAKE) && $(MAKE) install
+}
+Wget $(SUBDIR)/faad2.tar.gz : $(SUBDIR)/version_faad2.txt ;
+LibFaad2 $(SUBDIR)/lib/libfaad.a : $(SUBDIR)/faad2.tar.gz ;
+
# libavcodec
rule LibAvCodec
{
cd `dirname $(>)` && CONTRIB=`pwd` &&
rm -rf ffmpeg && (gzip -dc ffmpeg.tar.gz | tar xf -) &&
cd ffmpeg && $(FFMPEG_PATCH) &&
- ./configure --prefix=$CONTRIB --enable-gpl --enable-pthreads --enable-swscaler --disable-audio-beos --disable-shared --enable-static \
- --disable-decoders --enable-decoder=mp2 --disable-parsers --enable-parser=mpegaudio \
- --disable-encoders --enable-encoder=mpeg4 --enable-encoder=ac3 --enable-encoder=snow \
- --disable-muxers --enable-muxer=ipod --disable-demuxers --disable-protocols --disable-bsfs &&
+ ./configure --prefix=$CONTRIB --enable-gpl --enable-pthreads --enable-swscale \
+ --disable-shared --enable-static --disable-encoders \
+ --enable-encoder=mpeg4 --enable-encoder=ac3 --enable-encoder=snow \
+ --enable-libfaad --disable-ffmpeg --disable-ffserver \
+ --disable-muxers --enable-muxer=ipod --disable-bsfs \
+ --extra-cflags="-I$CONTRIB/include" \
+ --extra-ldflags="-L$CONTRIB/lib" &&
$(MAKE) && $(MAKE) install &&
$(STRIP) $CONTRIB/lib/libavcodec.a
}
-Index: configure
-===================================================================
---- configure (revision 9814)
-+++ configure (working copy)
-@@ -1095,7 +1095,7 @@
- 2.9-beos-991026*|2.9-beos-000224*) echo "R5/GG gcc"
- mmx="no"
- ;;
-- *20010315*) echo "BeBits gcc"
-+ *20010315*|2.95.3*) echo "BeBits gcc"
- add_cflags "-fno-expensive-optimizations"
- ;;
- esac
-Index: libavformat/Makefile
-===================================================================
---- libavformat/Makefile (revision 9814)
-+++ libavformat/Makefile (working copy)
-@@ -69,6 +69,7 @@
- OBJS-$(CONFIG_IMAGE2PIPE_MUXER) += img2.o
- OBJS-$(CONFIG_INGENIENT_DEMUXER) += raw.o
- OBJS-$(CONFIG_IPMOVIE_DEMUXER) += ipmovie.o
-+OBJS-$(CONFIG_IPOD_MUXER) += movenc.o riff.o isom.o
- OBJS-$(CONFIG_M4V_DEMUXER) += raw.o
- OBJS-$(CONFIG_M4V_MUXER) += raw.o
- OBJS-$(CONFIG_MATROSKA_DEMUXER) += matroskadec.o matroska.o riff.o
Index: libavformat/tcp.c
===================================================================
--- libavformat/tcp.c (revision 9814)
}
s->fd = fd;
return 0;
-Index: libavformat/movenc.c
-===================================================================
---- libavformat/movenc.c (revision 9814)
-+++ libavformat/movenc.c (working copy)
-@@ -36,6 +36,7 @@
- #define MODE_PSP 3 // example working PSP command line:
- // ffmpeg -i testinput.avi -f psp -r 14.985 -s 320x240 -b 768 -ar 24000 -ab 32 M4V00001.MP4
- #define MODE_3G2 4
-+#define MODE_IPOD 5
-
- typedef struct MOVIentry {
- unsigned int flags, size;
-@@ -54,6 +55,7 @@
- long time;
- int64_t trackDuration;
- long sampleCount;
-+ long sampleDuration;
- long sampleSize;
- int hasKeyframes;
- int hasBframes;
-@@ -572,6 +574,18 @@
- return tag;
- }
-
-+static int mov_write_colr_tag(ByteIOContext *pb)
-+{
-+ put_be32( pb, 0x12 );
-+ put_tag( pb, "colr" );
-+ put_tag( pb, "nclc" );
-+ put_be16( pb, 6 );
-+ put_be16( pb, 1 );
-+ put_be16( pb, 6 );
-+ put_be32( pb, 0 );
-+ return 0x12;
-+}
-+
- static int mov_write_video_tag(ByteIOContext *pb, MOVTrack* track)
- {
- offset_t pos = url_ftell(pb);
-@@ -621,9 +635,22 @@
- mov_write_d263_tag(pb);
- else if(track->enc->codec_id == CODEC_ID_SVQ3)
- mov_write_svq3_tag(pb);
-- else if(track->enc->codec_id == CODEC_ID_H264)
-- mov_write_avcc_tag(pb, track);
-+ else if(track->enc->codec_id == CODEC_ID_H264) {
-+ mov_write_avcc_tag(pb, track);
-+ if (track->mode == MODE_IPOD) {
-+ put_be32(pb, 0x1C); /* size ... reports as 28 in mp4box! */
-+ put_tag(pb, "uuid");
-+ put_be32(pb, 0x6B6840F2);
-+ put_be32(pb, 0x5F244FC5);
-+ put_be32(pb, 0xBA39A51B);
-+ put_be32(pb, 0xCF0323F3);
-+ put_be32(pb, 0x00000001);
-+ put_be32(pb, 0x0000039C);
-+ }
-+ }
-
-+ mov_write_colr_tag(pb);
-+
- return updateSize (pb, pos);
- }
-
-@@ -674,46 +701,18 @@
- return atom_size;
- }
-
-+/* TODO: */
- /* Time to sample atom */
- static int mov_write_stts_tag(ByteIOContext *pb, MOVTrack* track)
- {
-- MOV_stts_t *stts_entries;
-- uint32_t entries = -1;
-- uint32_t atom_size;
-- int i;
--
-- if (track->enc->codec_type == CODEC_TYPE_AUDIO && !track->audio_vbr) {
-- stts_entries = av_malloc(sizeof(*stts_entries)); /* one entry */
-- stts_entries[0].count = track->sampleCount;
-- stts_entries[0].duration = 1;
-- entries = 1;
-- } else {
-- stts_entries = av_malloc(track->entry * sizeof(*stts_entries)); /* worst case */
-- for (i=0; i<track->entry; i++) {
-- int64_t duration = i + 1 == track->entry ?
-- track->trackDuration - track->cluster[i].dts + track->cluster[0].dts : /* readjusting */
-- track->cluster[i+1].dts - track->cluster[i].dts;
-- if (i && duration == stts_entries[entries].duration) {
-- stts_entries[entries].count++; /* compress */
-- } else {
-- entries++;
-- stts_entries[entries].duration = duration;
-- stts_entries[entries].count = 1;
-- }
-- }
-- entries++; /* last one */
-- }
-- atom_size = 16 + (entries * 8);
-- put_be32(pb, atom_size); /* size */
-+ put_be32(pb, 0x18); /* size */
- put_tag(pb, "stts");
- put_be32(pb, 0); /* version & flags */
-- put_be32(pb, entries); /* entry count */
-- for (i=0; i<entries; i++) {
-- put_be32(pb, stts_entries[i].count);
-- put_be32(pb, stts_entries[i].duration);
-- }
-- av_free(stts_entries);
-- return atom_size;
-+ put_be32(pb, 1); /* entry count */
-+
-+ put_be32(pb, track->sampleCount); /* sample count */
-+ put_be32(pb, track->sampleDuration); /* sample duration */
-+ return 0x18;
- }
-
- static int mov_write_dref_tag(ByteIOContext *pb)
-@@ -911,6 +910,10 @@
- /* Track width and height, for visual only */
- if(track->enc->codec_type == CODEC_TYPE_VIDEO) {
- double sample_aspect_ratio = av_q2d(track->enc->sample_aspect_ratio);
-+ if (track->mode == MODE_IPOD) {
-+ /* FIXME , I do not believe this is needed, bad assumption */
-+ sample_aspect_ratio = 1;
-+ }
- if( !sample_aspect_ratio ) sample_aspect_ratio = 1;
- put_be32(pb, sample_aspect_ratio * track->enc->width*0x10000);
- put_be32(pb, track->enc->height*0x10000);
-@@ -1322,6 +1325,8 @@
- for (i=0; i<mov->nb_streams; i++) {
- if(mov->tracks[i].entry <= 0) continue;
-
-+ mov->tracks[i].trackDuration =
-+ (int64_t)mov->tracks[i].sampleCount * mov->tracks[i].sampleDuration;
- mov->tracks[i].time = mov->time;
- mov->tracks[i].trackID = i+1;
- }
-@@ -1369,6 +1374,8 @@
- put_tag(pb, "MSNV");
- else if ( mov->mode == MODE_MP4 )
- put_tag(pb, "isom");
-+ else if ( mov->mode == MODE_IPOD )
-+ put_tag(pb, "isom");
- else
- put_tag(pb, "qt ");
-
-@@ -1380,6 +1387,8 @@
- put_tag(pb, "3g2a");
- else if ( mov->mode == MODE_PSP )
- put_tag(pb, "MSNV");
-+ else if ( mov->mode == MODE_IPOD )
-+ put_tag(pb, "mp41");
- else if ( mov->mode == MODE_MP4 )
- put_tag(pb, "mp41");
- else
-@@ -1466,7 +1475,8 @@
- else if (!strcmp("3g2", s->oformat->name)) mov->mode = MODE_3G2;
- else if (!strcmp("mov", s->oformat->name)) mov->mode = MODE_MOV;
- else if (!strcmp("psp", s->oformat->name)) mov->mode = MODE_PSP;
--
-+ else if (!strcmp("ipod", s->oformat->name)) mov->mode = MODE_IPOD;
-+
- mov_write_ftyp_tag(pb,s);
- if ( mov->mode == MODE_PSP ) {
- if ( s->nb_streams != 2 ) {
-@@ -1487,6 +1497,7 @@
- if(st->codec->codec_type == CODEC_TYPE_VIDEO){
- track->tag = mov_find_video_codec_tag(s, track);
- track->timescale = st->codec->time_base.den;
-+ track->sampleDuration = st->codec->time_base.num;
- av_set_pts_info(st, 64, 1, st->codec->time_base.den);
- if (track->timescale > 100000)
- av_log(NULL, AV_LOG_WARNING,
-@@ -1496,6 +1507,7 @@
- }else if(st->codec->codec_type == CODEC_TYPE_AUDIO){
- track->tag = mov_find_audio_codec_tag(s, track);
- track->timescale = st->codec->sample_rate;
-+ track->sampleDuration = st->codec->frame_size;
- av_set_pts_info(st, 64, 1, st->codec->sample_rate);
- if(!st->codec->frame_size){
- av_log(s, AV_LOG_ERROR, "track %d: codec frame size is not set\n", i);
-@@ -1675,6 +1687,21 @@
- .flags = AVFMT_GLOBALHEADER,
- };
- #endif
-+#ifdef CONFIG_IPOD_MUXER
-+AVOutputFormat ipod_muxer = {
-+ "ipod",
-+ "ipod mp4 format",
-+ "application/mp4",
-+ "mp4,m4v,ipod",
-+ sizeof(MOVContext),
-+ CODEC_ID_AAC,
-+ CODEC_ID_MPEG4,
-+ mov_write_header,
-+ mov_write_packet,
-+ mov_write_trailer,
-+ .flags = AVFMT_GLOBALHEADER,
-+};
-+#endif
- #ifdef CONFIG_PSP_MUXER
- AVOutputFormat psp_muxer = {
- "psp",
-Index: libavformat/allformats.c
-===================================================================
---- libavformat/allformats.c (revision 9814)
-+++ libavformat/allformats.c (working copy)
-@@ -89,6 +89,9 @@
- REGISTER_MUXDEMUX(IMAGE2PIPE, image2pipe);
- REGISTER_DEMUXER (INGENIENT, ingenient);
- REGISTER_DEMUXER (IPMOVIE, ipmovie);
-+#ifdef CONFIG_IPOD_MUXER
-+ REGISTER_MUXER (IPOD, ipod);
-+#endif
- if (!ENABLE_NUT_DEMUXER) REGISTER_DEMUXER (LIBNUT, libnut);
- REGISTER_MUXER (LIBNUT, libnut);
- REGISTER_MUXDEMUX(M4V, m4v);
-Index: libavformat/allformats.h
-===================================================================
---- libavformat/allformats.h (revision 9814)
-+++ libavformat/allformats.h (working copy)
-@@ -142,6 +142,7 @@
- extern AVOutputFormat image2pipe_muxer;
- extern AVOutputFormat image_muxer;
- extern AVOutputFormat imagepipe_muxer;
-+extern AVOutputFormat ipod_muxer;
- extern AVOutputFormat libnut_muxer;
- extern AVOutputFormat m4v_muxer;
- extern AVOutputFormat mjpeg_muxer;
--- /dev/null
+http://download.m0k.org/handbrake/contrib/faad2-2.6.1.tar.gz
-http://download.m0k.org/handbrake/contrib/ffmpeg-9816.tar.gz
+http://download.m0k.org/handbrake/contrib/ffmpeg-r13110.tar.gz
../contrib/lib/libsamplerate.a ../contrib/lib/libx264.a \
../contrib/lib/libxvidcore.a ../contrib/lib/libmp4v2.a \
../contrib/lib/libmkv.a ../contrib/lib/libswscale.a \
- ../contrib/lib/libtheora.a
+ ../contrib/lib/libtheora.a ../contrib/lib/libfaad.a
CFLAGS += -I../contrib/include -D__LIBHB__ -DUSE_PTHREAD -DHB_VERSION=\"$(HB_VERSION)\" -DHB_BUILD=$(HB_BUILD) $(SYSDEF)
t->list_chapter = hb_list_init();
t->list_subtitle = hb_list_init();
strcat( t->dvd, dvd );
+ // default to decoding mpeg2
+ t->video_id = 0xE0;
+ t->video_codec = WORK_DECMPEG2;
return t;
}
#define HB_ACODEC_MPGA 0x001000
#define HB_ACODEC_LPCM 0x002000
#define HB_ACODEC_DCA 0x004000
+#define HB_ACODEC_FFMPEG 0x008000
/* Audio Mixdown */
/* define some masks, used to extract the various information from the HB_AMIXDOWN_XXXX values */
/* Input */
struct
{
- int track; /* Input track number */
- PRIVATE uint32_t codec; /* Input audio codec */
+ int track; /* Input track number */
+ PRIVATE uint32_t codec; /* Input audio codec */
+ PRIVATE uint32_t codec_param; /* per-codec config info */
PRIVATE int samplerate; /* Input sample rate (Hz) */
PRIVATE int bitrate; /* Input bitrate (kbps) */
PRIVATE int channel_layout;
PRIVATE int ac3; /* flags.ac3 is only set when the source audio format is HB_ACODEC_AC3 */
PRIVATE int dca; /* flags.dca is only set when the source audio format is HB_ACODEC_DCA */
} flags;
+#define AUDIO_F_DOLBY (1 << 31) /* set if source uses Dolby Surround */
struct
{
int rate;
int rate_base;
int crop[4];
+ enum { HB_MPEG2_DEMUXER = 0, HB_NULL_DEMUXER } demuxer;
int detected_interlacing;
+ int video_id; /* demuxer stream id for video */
+ int video_codec; /* worker object id of video codec */
+ int video_codec_param; /* codec specific config */
uint32_t palette[16];
} param;
};
+typedef struct hb_work_info_s
+{
+ const char *name;
+ int profile;
+ int level;
+ int bitrate;
+ int rate;
+ int rate_base;
+ int flags;
+ union {
+ struct { // info only valid for video decoders
+ int width;
+ int height;
+ double aspect;
+ };
+ struct { // info only valid for audio decoders
+ int channel_layout;
+ };
+ };
+} hb_work_info_t;
+
struct hb_work_object_s
{
int id;
int (* work) ( hb_work_object_t *, hb_buffer_t **,
hb_buffer_t ** );
void (* close) ( hb_work_object_t * );
+ /* the info entry point is used by scan to get bitstream information
+ * during a decode (i.e., it should only be called after at least one
+ * call to the 'work' entry point). currently it's only called for
+ * video streams & can be null for other work objects. */
+ int (* info) ( hb_work_object_t *, hb_work_info_t * );
+ /* the bitstream info entry point is used by scan to get bitstream
+ * information from a buffer. it doesn't have to be called during a
+ * decode (it can be called even if init & work haven't been).
+ * currently it's only called for audio streams & can be null for
+ * other work objects. */
+ int (* bsinfo) ( hb_work_object_t *, const hb_buffer_t *,
+ hb_work_info_t * );
hb_fifo_t * fifo_in;
hb_fifo_t * fifo_out;
hb_thread_t * thread;
volatile int * done;
int status;
+ int codec_param;
hb_work_object_t * next;
int thread_sleep_interval;
extern hb_work_object_t hb_deca52;
extern hb_work_object_t hb_decdca;
extern hb_work_object_t hb_decavcodec;
+extern hb_work_object_t hb_decavcodecv;
+extern hb_work_object_t hb_decavcodecvi;
+extern hb_work_object_t hb_decavcodecai;
extern hb_work_object_t hb_declpcm;
extern hb_work_object_t hb_encfaac;
extern hb_work_object_t hb_enclame;
*/
#include "hb.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
#include "mpeg2dec/mpeg2.h"
#define PP7_QP_DEFAULT 0
};
-int deca52Init( hb_work_object_t *, hb_job_t * );
-int deca52Work( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
-void deca52Close( hb_work_object_t * );
+static int deca52Init( hb_work_object_t *, hb_job_t * );
+static int deca52Work( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
+static void deca52Close( hb_work_object_t * );
+static int deca52BSInfo( hb_work_object_t * , const hb_buffer_t *,
+ hb_work_info_t * );
hb_work_object_t hb_deca52 =
{
"AC3 decoder",
deca52Init,
deca52Work,
- deca52Close
+ deca52Close,
+ 0,
+ deca52BSInfo
};
/***********************************************************************
***********************************************************************
* Allocate the work object, initialize liba52
**********************************************************************/
-int deca52Init( hb_work_object_t * w, hb_job_t * job )
+static int deca52Init( hb_work_object_t * w, hb_job_t * job )
{
hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
hb_audio_t * audio = w->audio;
***********************************************************************
* Free memory
**********************************************************************/
-void deca52Close( hb_work_object_t * w )
+static void deca52Close( hb_work_object_t * w )
{
hb_work_private_t * pv = w->private_data;
a52_free( pv->state );
* Add the given buffer to the data we already have, and decode as much
* as we can
**********************************************************************/
-int deca52Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
+static int deca52Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out )
{
hb_work_private_t * pv = w->private_data;
return buf;
}
+static int deca52BSInfo( hb_work_object_t *w, const hb_buffer_t *b,
+ hb_work_info_t *info )
+{
+ int i, rate, bitrate, flags;
+
+ memset( info, 0, sizeof(*info) );
+
+ /* since AC3 frames don't line up with MPEG ES frames scan the
+ * entire frame for an AC3 sync pattern. */
+ for ( i = 0; i < b->size - 7; ++i )
+ {
+ if( a52_syncinfo( &b->data[i], &flags, &rate, &bitrate ) != 0 )
+ {
+ break;
+ }
+ }
+ if ( i >= b->size - 7 )
+ {
+ /* didn't find AC3 sync */
+ return 0;
+ }
+
+ info->name = "AC-3";
+ info->rate = rate;
+ info->rate_base = 1;
+ info->bitrate = bitrate;
+ info->flags = flags;
+ if ( (flags & A52_CHANNEL_MASK) == A52_DOLBY )
+ {
+ info->flags |= AUDIO_F_DOLBY;
+ }
+
+ switch( flags & A52_CHANNEL_MASK )
+ {
+ /* mono sources */
+ case A52_MONO:
+ case A52_CHANNEL1:
+ case A52_CHANNEL2:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_MONO;
+ break;
+ /* stereo input */
+ case A52_CHANNEL:
+ case A52_STEREO:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
+ break;
+ /* dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input */
+ case A52_DOLBY:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_DOLBY;
+ break;
+ /* 3F/2R input */
+ case A52_3F2R:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_3F2R;
+ break;
+ /* 3F/1R input */
+ case A52_3F1R:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_3F1R;
+ break;
+ /* other inputs */
+ case A52_3F:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_3F;
+ break;
+ case A52_2F1R:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_2F1R;
+ break;
+ case A52_2F2R:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_2F2R;
+ break;
+ /* unknown */
+ default:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
+ }
+
+ if (flags & A52_LFE)
+ {
+ info->channel_layout |= HB_INPUT_CH_LAYOUT_HAS_LFE;
+ }
+
+ return 1;
+}
#include "hb.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
+#include "libavformat/avformat.h"
-int decavcodecInit( hb_work_object_t *, hb_job_t * );
-int decavcodecWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
-void decavcodecClose( hb_work_object_t * );
+static int decavcodecInit( hb_work_object_t *, hb_job_t * );
+static int decavcodecWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
+static void decavcodecClose( hb_work_object_t * );
+static int decavcodecInfo( hb_work_object_t *, hb_work_info_t * );
+static int decavcodecBSInfo( hb_work_object_t *, const hb_buffer_t *, hb_work_info_t * );
hb_work_object_t hb_decavcodec =
{
"MPGA decoder (libavcodec)",
decavcodecInit,
decavcodecWork,
- decavcodecClose
+ decavcodecClose,
+ decavcodecInfo,
+ decavcodecBSInfo
};
struct hb_work_private_s
{
- hb_job_t * job;
-
- AVCodecContext * context;
- int64_t pts_last;
+ hb_job_t *job;
+ AVCodecContext *context;
AVCodecParserContext *parser;
+ hb_list_t *list;
+ double pts_next; // next pts we expect to generate
+ int64_t pts; // (video) pts passing from parser to decoder
+ int64_t chap_time; // time of next chap mark (if new_chap != 0)
+ int new_chap;
+ int ignore_pts; // workaround M$ bugs
+ int nframes;
+ double duration; // frame duration (for video)
};
+
/***********************************************************************
* hb_work_decavcodec_init
***********************************************************************
*
**********************************************************************/
-int decavcodecInit( hb_work_object_t * w, hb_job_t * job )
+static int decavcodecInit( hb_work_object_t * w, hb_job_t * job )
{
AVCodec * codec;
pv->job = job;
- codec = avcodec_find_decoder( CODEC_ID_MP2 );
- pv->parser = av_parser_init(CODEC_ID_MP2);
+ int codec_id = w->codec_param;
+ /*XXX*/
+ if ( codec_id == 0 )
+ codec_id = CODEC_ID_MP2;
+ codec = avcodec_find_decoder( codec_id );
+ pv->parser = av_parser_init( codec_id );
pv->context = avcodec_alloc_context();
avcodec_open( pv->context, codec );
- pv->pts_last = -1;
return 0;
}
***********************************************************************
*
**********************************************************************/
-void decavcodecClose( hb_work_object_t * w )
+static void decavcodecClose( hb_work_object_t * w )
{
hb_work_private_t * pv = w->private_data;
- av_parser_close(pv->parser);
- avcodec_close( pv->context );
+ if ( pv->parser )
+ {
+ av_parser_close(pv->parser);
+ }
+ if ( pv->context && pv->context->codec )
+ {
+ avcodec_close( pv->context );
+ }
+ if ( pv->list )
+ {
+ hb_list_close( &pv->list );
+ }
}
/***********************************************************************
***********************************************************************
*
**********************************************************************/
-int decavcodecWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
+static int decavcodecWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out )
{
hb_work_private_t * pv = w->private_data;
*buf_out = NULL;
- if( in->start < 0 ||
- ( pv->pts_last > 0 &&
- in->start > pv->pts_last &&
- in->start - pv->pts_last < 5000 ) ) /* Hacky */
- {
- cur = pv->pts_last;
- }
- else
- {
- cur = in->start;
- }
+ cur = ( in->start < 0 )? pv->pts_next : in->start;
pos = 0;
while( pos < in->size )
{
- len = av_parser_parse(pv->parser, pv->context,&parser_output_buffer,&parser_output_buffer_len,in->data + pos,in->size - pos,cur,cur);
-
+ len = av_parser_parse( pv->parser, pv->context,
+ &parser_output_buffer, &parser_output_buffer_len,
+ in->data + pos, in->size - pos, cur, cur );
out_size = 0;
uncompressed_len = 0;
if (parser_output_buffer_len)
- uncompressed_len = avcodec_decode_audio( pv->context, buffer, &out_size,
- parser_output_buffer, parser_output_buffer_len );
+ {
+ out_size = sizeof(buffer);
+ uncompressed_len = avcodec_decode_audio2( pv->context, buffer,
+ &out_size,
+ parser_output_buffer,
+ parser_output_buffer_len );
+ }
if( out_size )
{
short * s16;
pos += len;
}
- pv->pts_last = cur;
+ pv->pts_next = cur;
+
+ return HB_WORK_OK;
+}
+
+static int decavcodecInfo( hb_work_object_t *w, hb_work_info_t *info )
+{
+ hb_work_private_t *pv = w->private_data;
+
+ memset( info, 0, sizeof(*info) );
+
+ if ( pv && pv->context )
+ {
+ AVCodecContext *context = pv->context;
+ info->bitrate = context->bit_rate;
+ info->rate = context->time_base.num;
+ info->rate_base = context->time_base.den;
+ info->profile = context->profile;
+ info->level = context->level;
+ return 1;
+ }
+ return 0;
+}
+
+static int decavcodecBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
+ hb_work_info_t *info )
+{
+ hb_work_private_t *pv = w->private_data;
+
+ memset( info, 0, sizeof(*info) );
+
+ if ( pv && pv->context )
+ {
+ return decavcodecInfo( w, info );
+ }
+ // XXX
+ // We should parse the bitstream to find its parameters but for right
+ // now we just return dummy values if there's a codec that will handle it.
+ AVCodec *codec = avcodec_find_decoder( w->codec_param? w->codec_param :
+ CODEC_ID_MP2 );
+ if ( codec )
+ {
+ static char codec_name[64];
+
+ info->name = strncpy( codec_name, codec->name, sizeof(codec_name)-1 );
+ info->bitrate = 384000;
+ info->rate = 48000;
+ info->rate_base = 1;
+ info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
+ return 1;
+ }
+ return -1;
+}
+
+/* -------------------------------------------------------------
+ * General purpose video decoder using libavcodec
+ */
+
+static uint8_t *copy_plane( uint8_t *dst, uint8_t* src, int dstride, int sstride,
+ int h )
+{
+ if ( dstride == sstride )
+ {
+ memcpy( dst, src, dstride * h );
+ return dst + dstride * h;
+ }
+ int lbytes = dstride <= sstride? dstride : sstride;
+ while ( --h >= 0 )
+ {
+ memcpy( dst, src, lbytes );
+ src += sstride;
+ dst += dstride;
+ }
+ return dst;
+}
+
+/* Note: assumes frame format is PIX_FMT_YUV420P */
+static hb_buffer_t *copy_frame( AVCodecContext *context, AVFrame *frame )
+{
+ int w = context->width, h = context->height;
+ hb_buffer_t *buf = hb_buffer_init( w * h * 3 / 2 );
+ uint8_t *dst = buf->data;
+
+ dst = copy_plane( dst, frame->data[0], w, frame->linesize[0], h );
+ w >>= 1; h >>= 1;
+ dst = copy_plane( dst, frame->data[1], w, frame->linesize[1], h );
+ dst = copy_plane( dst, frame->data[2], w, frame->linesize[2], h );
+
+ return buf;
+}
+
+static int get_frame_buf( AVCodecContext *context, AVFrame *frame )
+{
+ hb_work_private_t *pv = context->opaque;
+ frame->pts = pv->pts;
+ pv->pts = -1;
+
+ return avcodec_default_get_buffer( context, frame );
+}
+
+static void log_chapter( hb_work_private_t *pv, int chap_num, int64_t pts )
+{
+ hb_chapter_t *c = hb_list_item( pv->job->title->list_chapter, chap_num - 1 );
+ hb_log( "%s: \"%s\" (%d) at frame %u time %lld", pv->context->codec->name,
+ c->title, chap_num, pv->nframes, pts );
+}
+
+static int decodeFrame( hb_work_private_t *pv, uint8_t *data, int size )
+{
+ int got_picture;
+ AVFrame frame;
+
+ avcodec_decode_video( pv->context, &frame, &got_picture, data, size );
+ if( got_picture )
+ {
+ // ffmpeg makes it hard to attach a pts to a frame. if the MPEG ES
+ // packet had a pts we handed it to av_parser_parse (if the packet had
+ // no pts we set it to -1 but before the parse we can't distinguish between
+ // the start of a video frame with no pts & an intermediate packet of
+ // some frame which never has a pts). we hope that when parse returns
+ // the frame to us the pts we originally handed it will be in parser->pts.
+ // we put this pts into pv->pts so that when a avcodec_decode_video
+ // finally gets around to allocating an AVFrame to hold the decoded
+ // frame we can stuff that pts into the frame. if all of these relays
+ // worked at this point frame.pts should hold the frame's pts from the
+ // original data stream or -1 if it didn't have one. in the latter case
+ // we generate the next pts in sequence for it.
+ double pts = frame.pts;
+ if ( pts < 0 )
+ {
+ pts = pv->pts_next;
+ }
+ if ( pv->duration == 0 )
+ {
+ pv->duration = 90000. * pv->context->time_base.num /
+ pv->context->time_base.den;
+ }
+ double frame_dur = pv->duration;
+ frame_dur += frame.repeat_pict * frame_dur * 0.5;
+ pv->pts_next = pts + frame_dur;
+
+ hb_buffer_t *buf = copy_frame( pv->context, &frame );
+ buf->start = pts;
+
+ if ( pv->new_chap && buf->start >= pv->chap_time )
+ {
+ buf->new_chap = pv->new_chap;
+ pv->new_chap = 0;
+ pv->chap_time = 0;
+ if ( pv->job )
+ {
+ log_chapter( pv, buf->new_chap, buf->start );
+ }
+ }
+ else if ( pv->job && pv->nframes == 0 )
+ {
+ log_chapter( pv, pv->job->chapter_start, buf->start );
+ }
+ hb_list_add( pv->list, buf );
+ ++pv->nframes;
+ }
+ return got_picture;
+}
+
+static void decodeVideo( hb_work_private_t *pv, uint8_t *data, int size,
+ int64_t pts, int64_t dts )
+{
+ /*
+ * The following loop is a do..while because we need to handle both
+ * data & the flush at the end (signaled by size=0). At the end there's
+ * generally a frame in the parser & one or more frames in the decoder
+ * (depending on the bframes setting).
+ */
+ int pos = 0;
+ do {
+ uint8_t *pout;
+ int pout_len;
+ int len = av_parser_parse( pv->parser, pv->context, &pout, &pout_len,
+ data + pos, size - pos, pts, dts );
+ pos += len;
+
+ if ( pout_len > 0 )
+ {
+ pv->pts = pv->parser->pts;
+ decodeFrame( pv, pout, pout_len );
+ }
+ } while ( pos < size );
+
+ /* the stuff above flushed the parser, now flush the decoder */
+ while ( size == 0 && decodeFrame( pv, NULL, 0 ) )
+ {
+ }
+}
+
+static hb_buffer_t *link_buf_list( hb_work_private_t *pv )
+{
+ hb_buffer_t *head = hb_list_item( pv->list, 0 );
+
+ if ( head )
+ {
+ hb_list_rem( pv->list, head );
+
+ hb_buffer_t *last = head, *buf;
+
+ while ( ( buf = hb_list_item( pv->list, 0 ) ) != NULL )
+ {
+ hb_list_rem( pv->list, buf );
+ last->next = buf;
+ last = buf;
+ }
+ }
+ return head;
+}
+
+
+static int decavcodecvInit( hb_work_object_t * w, hb_job_t * job )
+{
+
+ hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
+ w->private_data = pv;
+ pv->job = job;
+ pv->list = hb_list_init();
+
+ int codec_id = w->codec_param;
+ pv->parser = av_parser_init( codec_id );
+ pv->context = avcodec_alloc_context2( CODEC_TYPE_VIDEO );
+
+ /* we have to wrap ffmpeg's get_buffer to be able to set the pts (?!) */
+ pv->context->opaque = pv;
+ pv->context->get_buffer = get_frame_buf;
+
+ AVCodec *codec = avcodec_find_decoder( codec_id );
+
+ // we can't call the avstream funcs but the read_header func in the
+ // AVInputFormat may set up some state in the AVContext. In particular
+ // vc1t_read_header allocates 'extradata' to deal with header issues
+ // related to Microsoft's bizarre engineering notions. We alloc a chunk
+ // of space to make vc1 work then associate the codec with the context.
+ pv->context->extradata_size = 32;
+ pv->context->extradata = av_malloc(pv->context->extradata_size);
+ avcodec_open( pv->context, codec );
+
+ return 0;
+}
+
+static int decavcodecvWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
+ hb_buffer_t ** buf_out )
+{
+ hb_work_private_t *pv = w->private_data;
+ hb_buffer_t *in = *buf_in;
+ int64_t pts = -1;
+ int64_t dts = pts;
+
+ *buf_in = NULL;
+
+ /* if we got an empty buffer signaling end-of-stream send it downstream */
+ if ( in->size == 0 )
+ {
+ decodeVideo( pv, in->data, in->size, pts, dts );
+ hb_list_add( pv->list, in );
+ *buf_out = link_buf_list( pv );
+ hb_log( "%s done: %d frames", pv->context->codec->name, pv->nframes );
+ return HB_WORK_DONE;
+ }
+
+ if( in->start >= 0 )
+ {
+ pts = in->start;
+ dts = in->renderOffset;
+ }
+ if ( in->new_chap )
+ {
+ pv->new_chap = in->new_chap;
+ pv->chap_time = pts >= 0? pts : pv->pts_next;
+ }
+ decodeVideo( pv, in->data, in->size, pts, dts );
+ hb_buffer_close( &in );
+ *buf_out = link_buf_list( pv );
+ return HB_WORK_OK;
+}
+
+static int decavcodecvInfo( hb_work_object_t *w, hb_work_info_t *info )
+{
+ hb_work_private_t *pv = w->private_data;
+
+ memset( info, 0, sizeof(*info) );
+
+ if ( pv && pv->context )
+ {
+ AVCodecContext *context = pv->context;
+ info->bitrate = context->bit_rate;
+ info->width = context->width;
+ info->height = context->height;
+
+ /* ffmpeg gives the frame rate in frames per second while HB wants
+ * it in units of the 27MHz MPEG clock. */
+ info->rate = 27000000;
+ info->rate_base = (int64_t)context->time_base.num * 27000000LL /
+ context->time_base.den;
+
+ /* ffmpeg returns the Pixel Aspect Ratio (PAR). Handbrake wants the
+ * Display Aspect Ratio so we convert by scaling by the Storage
+ * Aspect Ratio (w/h). We do the calc in floating point to get the
+ * rounding right. We round in the second decimal digit because we
+ * scale the (integer) aspect by 9 to preserve the 1st digit. */
+ info->aspect = ( (double)context->sample_aspect_ratio.num *
+ (double)context->width /
+ (double)context->sample_aspect_ratio.den /
+ (double)context->height + 0.05 ) * HB_ASPECT_BASE;
+
+ if( context->sample_aspect_ratio.num == 0 )
+ {
+ info->aspect = (double)context->width / (double)context->height * HB_ASPECT_BASE;
+ }
+ info->profile = context->profile;
+ info->level = context->level;
+ info->name = context->codec->name;
+ return 1;
+ }
+ return 0;
+}
+
+static int decavcodecvBSInfo( hb_work_object_t *w, const hb_buffer_t *buf,
+ hb_work_info_t *info )
+{
+ return 0;
+}
+
+hb_work_object_t hb_decavcodecv =
+{
+ WORK_DECAVCODECV,
+ "Video decoder (libavcodec)",
+ decavcodecvInit,
+ decavcodecvWork,
+ decavcodecClose,
+ decavcodecvInfo,
+ decavcodecvBSInfo
+};
+
+
+// This is a special decoder for ffmpeg streams. The ffmpeg stream reader
+// includes a parser and passes information from the parser to the decoder
+// via a codec context kept in the AVStream of the reader's AVFormatContext.
+// We *have* to use that codec context to decode the stream or we'll get
+// garbage. ffmpeg_title_scan put a cookie that can be used to get to that
+// codec context in our codec_param.
+
+// this routine gets the appropriate context pointer from the ffmpeg
+// stream reader. it can't be called until we get the first buffer because
+// we can't guarantee that reader will be called before the our init
+// routine and if our init is called first we'll get a pointer to the
+// old scan stream (which has already been closed).
+static void init_ffmpeg_context( hb_work_object_t *w )
+{
+ hb_work_private_t *pv = w->private_data;
+ pv->context = hb_ffmpeg_context( w->codec_param );
+
+ // during scan the decoder gets closed & reopened which will
+ // close the codec so reopen it if it's not there
+ if ( ! pv->context->codec )
+ {
+ AVCodec *codec = avcodec_find_decoder( pv->context->codec_id );
+ avcodec_open( pv->context, codec );
+ }
+ // set up our best guess at the frame duration.
+ // the frame rate in the codec seems to be bogus but it's ok in the stream.
+ AVStream *st = hb_ffmpeg_avstream( w->codec_param );
+ AVRational tb = st->time_base;
+ if ( st->r_frame_rate.den && st->r_frame_rate.num )
+ {
+ tb.num = st->r_frame_rate.den;
+ tb.den = st->r_frame_rate.num;
+ }
+ pv->duration = 90000. * tb.num / tb.den;
+
+ // we have to wrap ffmpeg's get_buffer to be able to set the pts (?!)
+ pv->context->opaque = pv;
+ pv->context->get_buffer = get_frame_buf;
+}
+
+static void prepare_ffmpeg_buffer( hb_buffer_t * in )
+{
+ // ffmpeg requires an extra 8 bytes of zero at the end of the buffer and
+ // will seg fault in odd, data dependent ways if it's not there. (my guess
+ // is this is a case of a local performance optimization creating a global
+ // performance degradation since all the time wasted by extraneous data
+ // copies & memory zeroing has to be huge compared to the minor reduction
+ // in inner-loop instructions this affords - modern cpus bottleneck on
+ // memory bandwidth not instruction bandwidth).
+ if ( in->size + FF_INPUT_BUFFER_PADDING_SIZE > in->alloc )
+ {
+ // have to realloc to add the padding
+ hb_buffer_realloc( in, in->size + FF_INPUT_BUFFER_PADDING_SIZE );
+ }
+ memset( in->data + in->size, 0, FF_INPUT_BUFFER_PADDING_SIZE );
+}
+
+static int decavcodecviInit( hb_work_object_t * w, hb_job_t * job )
+{
+
+ hb_work_private_t *pv = calloc( 1, sizeof( hb_work_private_t ) );
+ w->private_data = pv;
+ pv->job = job;
+ pv->list = hb_list_init();
+
+ return 0;
+}
+
+static int decavcodecviWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
+ hb_buffer_t ** buf_out )
+{
+ hb_work_private_t *pv = w->private_data;
+ if ( ! pv->context )
+ {
+ init_ffmpeg_context( w );
+
+ switch ( pv->context->codec_id )
+ {
+ // These are the only formats whose timestamps we'll believe.
+ // All others are treated as CFR (i.e., we take the first timestamp
+ // then generate all the others from the frame rate). The reason for
+ // this is that the M$ encoders are so frigging buggy with garbage
+ // like packed b-frames (vfw divx mpeg4) that believing their timestamps
+ // results in discarding more than half the video frames because they'll
+ // be out of sequence (and attempting to reseqence them doesn't work
+ // because it's the timestamps that are wrong, not the decoded frame
+ // order). All hail Redmond, ancestral home of the rich & stupid.
+ case CODEC_ID_MPEG2VIDEO:
+ case CODEC_ID_RAWVIDEO:
+ case CODEC_ID_H264:
+ case CODEC_ID_VC1:
+ break;
+
+ default:
+ pv->ignore_pts = 1;
+ break;
+ }
+ }
+ hb_buffer_t *in = *buf_in;
+ int64_t pts = -1;
+
+ *buf_in = NULL;
+
+ /* if we got an empty buffer signaling end-of-stream send it downstream */
+ if ( in->size == 0 )
+ {
+ /* flush any frames left in the decoder */
+ while ( decodeFrame( pv, NULL, 0 ) )
+ {
+ }
+ hb_list_add( pv->list, in );
+ *buf_out = link_buf_list( pv );
+ hb_log( "%s done: %d frames", pv->context->codec->name, pv->nframes );
+ return HB_WORK_DONE;
+ }
+
+ if( in->start >= 0 )
+ {
+ // use the first timestamp as our 'next expected' pts
+ if ( pv->pts_next <= 0 )
+ {
+ pv->pts_next = in->start;
+ }
+
+ if ( ! pv->ignore_pts )
+ {
+ pts = in->start;
+ if ( pv->pts > 0 )
+ {
+ hb_log( "overwriting pts %lld with %lld (diff %d)",
+ pv->pts, pts, pts - pv->pts );
+ }
+ if ( pv->pts_next - pts >= 10.)
+ {
+ hb_log( "time reversal next %.0f pts %lld (diff %g)",
+ pv->pts_next, pts, pv->pts_next - pts );
+ }
+ pv->pts = pts;
+ }
+ }
+
+ if ( in->new_chap )
+ {
+ pv->new_chap = in->new_chap;
+ pv->chap_time = pts >= 0? pts : pv->pts_next;
+ }
+ prepare_ffmpeg_buffer( in );
+ decodeFrame( pv, in->data, in->size );
+ hb_buffer_close( &in );
+ *buf_out = link_buf_list( pv );
+ return HB_WORK_OK;
+}
+
+static int decavcodecviInfo( hb_work_object_t *w, hb_work_info_t *info )
+{
+ if ( decavcodecvInfo( w, info ) )
+ {
+ // the frame rate in the codec seems to be bogus but it's ok in the stream.
+ AVStream *st = hb_ffmpeg_avstream( w->codec_param );
+ AVRational tb;
+ if ( st->r_frame_rate.den && st->r_frame_rate.num )
+ {
+ tb.num = st->r_frame_rate.den;
+ tb.den = st->r_frame_rate.num;
+ }
+ else
+ {
+ tb = st->time_base;
+ }
+
+ // ffmpeg gives the frame rate in frames per second while HB wants
+ // it in units of the 27MHz MPEG clock. */
+ info->rate = 27000000;
+ info->rate_base = (int64_t)tb.num * 27000000LL / tb.den;
+ return 1;
+ }
+ return 0;
+}
+
+static void decodeAudio( hb_work_private_t *pv, uint8_t *data, int size )
+{
+ AVCodecContext *context = pv->context;
+ int pos = 0;
+
+ while ( pos < size )
+ {
+ int16_t buffer[AVCODEC_MAX_AUDIO_FRAME_SIZE];
+ int out_size = sizeof(buffer);
+ int len = avcodec_decode_audio2( context, buffer, &out_size,
+ data + pos, size - pos );
+ if ( len <= 0 )
+ {
+ return;
+ }
+ pos += len;
+ if( out_size > 0 )
+ {
+ hb_buffer_t *buf = hb_buffer_init( 2 * out_size );
+
+ double pts = pv->pts_next;
+ buf->start = pts;
+ out_size >>= 1;
+ pts += out_size * pv->duration;
+ buf->stop = pts;
+ pv->pts_next = pts;
+
+ float *fl32 = (float *)buf->data;
+ int i;
+ for( i = 0; i < out_size; ++i )
+ {
+ fl32[i] = buffer[i];
+ }
+ hb_list_add( pv->list, buf );
+ }
+ }
+}
+
+static int decavcodecaiWork( hb_work_object_t *w, hb_buffer_t **buf_in,
+ hb_buffer_t **buf_out )
+{
+ hb_work_private_t *pv = w->private_data;
+ if ( ! pv->context )
+ {
+ init_ffmpeg_context( w );
+ pv->duration = 90000. /
+ (double)( pv->context->sample_rate * pv->context->channels );
+ }
+ hb_buffer_t *in = *buf_in;
+
+ if ( in->start >= 0 &&
+ ( pv->pts_next < 0 || ( in->start - pv->pts_next ) > 90*100 ) )
+ {
+ pv->pts_next = in->start;
+ }
+ prepare_ffmpeg_buffer( in );
+ decodeAudio( pv, in->data, in->size );
+ *buf_out = link_buf_list( pv );
return HB_WORK_OK;
}
+hb_work_object_t hb_decavcodecvi =
+{
+ WORK_DECAVCODECVI,
+ "Video decoder (ffmpeg streams)",
+ decavcodecviInit,
+ decavcodecviWork,
+ decavcodecClose,
+ decavcodecviInfo,
+ decavcodecvBSInfo
+};
+
+hb_work_object_t hb_decavcodecai =
+{
+ WORK_DECAVCODECAI,
+ "Audio decoder (ffmpeg streams)",
+ decavcodecviInit,
+ decavcodecaiWork,
+ decavcodecClose,
+ decavcodecInfo,
+ decavcodecBSInfo
+};
};
-int decdcaInit( hb_work_object_t *, hb_job_t * );
-int decdcaWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
-void decdcaClose( hb_work_object_t * );
+static int decdcaInit( hb_work_object_t *, hb_job_t * );
+static int decdcaWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
+static void decdcaClose( hb_work_object_t * );
+static int decdcaBSInfo( hb_work_object_t *, const hb_buffer_t *,
+ hb_work_info_t * );
hb_work_object_t hb_decdca =
{
"DCA decoder",
decdcaInit,
decdcaWork,
- decdcaClose
+ decdcaClose,
+ 0,
+ decdcaBSInfo
};
/***********************************************************************
***********************************************************************
* Allocate the work object, initialize libdca
**********************************************************************/
-int decdcaInit( hb_work_object_t * w, hb_job_t * job )
+static int decdcaInit( hb_work_object_t * w, hb_job_t * job )
{
hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
hb_audio_t * audio = w->audio;
***********************************************************************
* Free memory
**********************************************************************/
-void decdcaClose( hb_work_object_t * w )
+static void decdcaClose( hb_work_object_t * w )
{
hb_work_private_t * pv = w->private_data;
dca_free( pv->state );
* Add the given buffer to the data we already have, and decode as much
* as we can
**********************************************************************/
-int decdcaWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
+static int decdcaWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out )
{
hb_work_private_t * pv = w->private_data;
return buf;
}
+
+static int decdcaBSInfo( hb_work_object_t *w, const hb_buffer_t *b,
+ hb_work_info_t *info )
+{
+ int i, flags, rate, bitrate, frame_length;
+ dca_state_t * state = dca_init( 0 );
+
+ memset( info, 0, sizeof(*info) );
+
+ /* since DCA frames don't line up with MPEG ES frames scan the
+ * entire frame for an DCA sync pattern. */
+ for ( i = 0; i < b->size - 7; ++i )
+ {
+ if( dca_syncinfo( state, &b->data[i], &flags, &rate, &bitrate,
+ &frame_length ) )
+ {
+ break;
+ }
+ }
+ if ( i >= b->size - 7 )
+ {
+ /* didn't find DCA sync */
+ return 0;
+ }
+
+ info->name = "DCA";
+ info->rate = rate;
+ info->rate_base = 1;
+ info->bitrate = bitrate;
+ info->flags = flags;
+
+ if ( ( flags & DCA_CHANNEL_MASK) == DCA_DOLBY )
+ {
+ info->flags |= AUDIO_F_DOLBY;
+ }
+
+ switch( flags & DCA_CHANNEL_MASK )
+ {
+ /* mono sources */
+ case DCA_MONO:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_MONO;
+ break;
+ /* stereo input */
+ case DCA_CHANNEL:
+ case DCA_STEREO:
+ case DCA_STEREO_SUMDIFF:
+ case DCA_STEREO_TOTAL:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
+ break;
+ /* 3F/2R input */
+ case DCA_3F2R:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_3F2R;
+ break;
+ /* 3F/1R input */
+ case DCA_3F1R:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_3F1R;
+ break;
+ /* other inputs */
+ case DCA_3F:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_3F;
+ break;
+ case DCA_2F1R:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_2F1R;
+ break;
+ case DCA_2F2R:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_2F2R;
+ break;
+ case DCA_4F2R:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_4F2R;
+ break;
+ /* unknown */
+ default:
+ info->channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
+ }
+
+ if (flags & DCA_LFE)
+ {
+ info->channel_layout |= HB_INPUT_CH_LAYOUT_HAS_LFE;
+ }
+
+ return 1;
+}
};
static hb_buffer_t * Decode( hb_work_object_t * w );
-int declpcmInit( hb_work_object_t *, hb_job_t * );
-int declpcmWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
-void declpcmClose( hb_work_object_t * );
+static int declpcmInit( hb_work_object_t *, hb_job_t * );
+static int declpcmWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
+static void declpcmClose( hb_work_object_t * );
+static int declpcmBSInfo( hb_work_object_t *, const hb_buffer_t *,
+ hb_work_info_t * );
hb_work_object_t hb_declpcm =
{
"LPCM decoder",
declpcmInit,
declpcmWork,
- declpcmClose
+ declpcmClose,
+ 0,
+ declpcmBSInfo
};
static const int hdr2samplerate[] = { 48000, 96000, 44100, 32000 };
static const int hdr2samplesize[] = { 16, 20, 24, 16 };
+static const int hdr2layout[] = {
+ HB_INPUT_CH_LAYOUT_MONO, HB_INPUT_CH_LAYOUT_STEREO,
+ HB_INPUT_CH_LAYOUT_2F1R, HB_INPUT_CH_LAYOUT_2F2R,
+ HB_INPUT_CH_LAYOUT_3F2R, HB_INPUT_CH_LAYOUT_4F2R,
+ HB_INPUT_CH_LAYOUT_STEREO, HB_INPUT_CH_LAYOUT_STEREO,
+};
static void lpcmInfo( hb_work_object_t *w, hb_buffer_t *in )
{
pv->next_pts = in->start;
}
-int declpcmInit( hb_work_object_t * w, hb_job_t * job )
+static int declpcmInit( hb_work_object_t * w, hb_job_t * job )
{
hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
w->private_data = pv;
* to DVD PES boundaries, this routine has to reconstruct then extract the audio
* frames. Because of the arbitrary alignment, it can output zero, one or two buf's.
*/
-int declpcmWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
+static int declpcmWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out )
{
hb_work_private_t * pv = w->private_data;
return out;
}
-void declpcmClose( hb_work_object_t * w )
+static void declpcmClose( hb_work_object_t * w )
{
if ( w->private_data )
{
w->private_data = 0;
}
}
+
+static int declpcmBSInfo( hb_work_object_t *w, const hb_buffer_t *b,
+ hb_work_info_t *info )
+{
+ int nchannels = ( b->data[4] & 7 ) + 1;
+ int sample_size = hdr2samplesize[b->data[4] >> 6];
+
+ int rate = hdr2samplerate[ ( b->data[4] >> 4 ) & 0x3 ];
+ int bitrate = rate * sample_size * nchannels;
+
+ memset( info, 0, sizeof(*info) );
+
+ info->name = "LPCM";
+ info->rate = rate;
+ info->rate_base = 1;
+ info->bitrate = bitrate;
+ info->flags = ( b->data[3] << 16 ) | ( b->data[4] << 8 ) | b->data[5];
+ info->channel_layout = hdr2layout[nchannels - 1];
+
+ return 1;
+}
#define BTB_PROG 64
#define TB_PROG 128
#define TBT_PROG 256
-int cadence[12];
-int flag = 0;
+static int cadence[12];
+static int flag = 0;
/**********************************************************************
* hb_libmpeg2_t
- **********************************************************************
- * A convenient libmpeg wrapper, used both here and in scan.c
*********************************************************************/
-struct hb_libmpeg2_s
+typedef struct hb_libmpeg2_s
{
mpeg2dec_t * libmpeg2;
const mpeg2_info_t * info;
int look_for_break; /* need gop start to add chap break */
uint32_t nframes; /* number of frames we've decoded */
int64_t last_pts;
-};
+} hb_libmpeg2_t;
/**********************************************************************
* hb_libmpeg2_init
**********************************************************************
*
*********************************************************************/
-hb_libmpeg2_t * hb_libmpeg2_init()
+static hb_libmpeg2_t * hb_libmpeg2_init()
{
hb_libmpeg2_t * m = calloc( sizeof( hb_libmpeg2_t ), 1 );
**********************************************************************
*
*********************************************************************/
-int hb_libmpeg2_decode( hb_libmpeg2_t * m, hb_buffer_t * buf_es,
+static int hb_libmpeg2_decode( hb_libmpeg2_t * m, hb_buffer_t * buf_es,
hb_list_t * list_raw )
{
mpeg2_state_t state;
**********************************************************************
*
*********************************************************************/
-void hb_libmpeg2_info( hb_libmpeg2_t * m, int * width, int * height,
+static void hb_libmpeg2_info( hb_libmpeg2_t * m, int * width, int * height,
int * rate, int *aspect_ratio )
{
*width = m->width;
*aspect_ratio = m->aspect_ratio;
}
-int hb_libmpeg2_clear_aspect_ratio( hb_libmpeg2_t * m )
-{
- int ar = m->aspect_ratio;
- m->aspect_ratio = 0;
- return ar;
-}
-
/**********************************************************************
* hb_libmpeg2_close
**********************************************************************
*
*********************************************************************/
-void hb_libmpeg2_close( hb_libmpeg2_t ** _m )
+static void hb_libmpeg2_close( hb_libmpeg2_t ** _m )
{
hb_libmpeg2_t * m = *_m;
**********************************************************************
*
*********************************************************************/
-int decmpeg2Init( hb_work_object_t * w, hb_job_t * job )
+static int decmpeg2Init( hb_work_object_t * w, hb_job_t * job )
{
hb_work_private_t * pv;
**********************************************************************
*
*********************************************************************/
-int decmpeg2Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
+static int decmpeg2Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out )
{
hb_work_private_t * pv = w->private_data;
**********************************************************************
*
*********************************************************************/
-void decmpeg2Close( hb_work_object_t * w )
+static void decmpeg2Close( hb_work_object_t * w )
{
hb_work_private_t * pv = w->private_data;
- hb_log( "mpeg2 done: %d frames", pv->libmpeg2->nframes );
+
+ // don't log during scan
+ if ( pv->libmpeg2->job )
+ {
+ hb_log( "mpeg2 done: %d frames", pv->libmpeg2->nframes );
+ }
hb_list_close( &pv->list );
hb_libmpeg2_close( &pv->libmpeg2 );
free( pv );
}
+static int decmpeg2Info( hb_work_object_t *w, hb_work_info_t *info )
+{
+ hb_work_private_t *pv = w->private_data;
+
+ if ( pv && pv->libmpeg2 )
+ {
+ int aspect;
+ hb_libmpeg2_t *m = pv->libmpeg2;
+
+ hb_libmpeg2_info( m, &info->width, &info->height, &info->rate_base,
+ &aspect );
+
+ info->aspect = (double)aspect;
+ info->rate = 27000000;
+
+ info->bitrate = m->info->sequence->byte_rate * 8;
+ info->profile = m->info->sequence->profile_level_id >> 4;
+ info->level = m->info->sequence->profile_level_id & 0xf;
+ info->name = "mpeg2";
+ return 1;
+ }
+ return 0;
+}
+
hb_work_object_t hb_decmpeg2 =
{
WORK_DECMPEG2,
"MPEG-2 decoder (libmpeg2)",
decmpeg2Init,
decmpeg2Work,
- decmpeg2Close
+ decmpeg2Close,
+ decmpeg2Info
};
The yadif algorithm was created by Michael Niedermayer. */
#include "hb.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
#include "mpeg2dec/mpeg2.h"
#define SUPPRESS_AV_LOG
int height,
char * settings );
-int hb_decomb_work( hb_buffer_t * buf_in,
+int hb_decomb_work( const hb_buffer_t * buf_in,
hb_buffer_t ** buf_out,
int pix_fmt,
int width,
free( pv );
}
-int hb_decomb_work( hb_buffer_t * buf_in,
- hb_buffer_t ** buf_out,
- int pix_fmt,
- int width,
- int height,
- hb_filter_private_t * pv )
+int hb_decomb_work( const hb_buffer_t * cbuf_in,
+ hb_buffer_t ** buf_out,
+ int pix_fmt,
+ int width,
+ int height,
+ hb_filter_private_t * pv )
{
+ hb_buffer_t * buf_in = (hb_buffer_t *)cbuf_in;
+
if( !pv ||
pix_fmt != pv->pix_fmt ||
width != pv->width[0] ||
*/
#include "hb.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
#include "mpeg2dec/mpeg2.h"
#define SUPPRESS_AV_LOG
#include "hb.h"
-/* Basic MPEG demuxer, only works with DVDs (2048 bytes packets) */
+/* Basic MPEG demuxer */
int hb_demux_ps( hb_buffer_t * buf_ps, hb_list_t * list_es, hb_psdemux_t* state )
{
int pes_header_d_length;
int pes_header_end;
int has_pts;
- int64_t pts = -1;
+ int64_t pts = -1, dts = -1;
pos += 3; /* packet_start_code_prefix */
id = d[pos];
continue;
}
- has_pts = ( ( d[pos+1] >> 6 ) & 0x2 ) ? 1 : 0;
+ has_pts = d[pos+1] >> 6;
pos += 2; /* Required headers */
pes_header_d_length = d[pos];
if( has_pts )
{
- pts = ( ( ( (uint64_t) d[pos] >> 1 ) & 0x7 ) << 30 ) +
+ pts = ( (uint64_t)(d[pos] & 0xe ) << 29 ) +
( d[pos+1] << 22 ) +
( ( d[pos+2] >> 1 ) << 15 ) +
( d[pos+3] << 7 ) +
( d[pos+4] >> 1 );
+ if ( has_pts & 1 )
+ {
+ dts = ( (uint64_t)(d[pos+5] & 0xe ) << 29 ) +
+ ( d[pos+6] << 22 ) +
+ ( ( d[pos+7] >> 1 ) << 15 ) +
+ ( d[pos+8] << 7 ) +
+ ( d[pos+9] >> 1 );
+ }
+ else
+ {
+ dts = pts;
+ }
}
pos = pes_header_end;
buf_es->id = id;
buf_es->start = pts;
+ buf_es->renderOffset = dts;
buf_es->stop = -1;
if (id == 0xE0) {
// Consume a chapter break, and apply it to the ES.
return 1;
}
+
+// "null" demuxer (makes a copy of input buf & returns it in list)
+// used when the reader for some format includes its own demuxer.
+// for example, ffmpeg.
+int hb_demux_null( hb_buffer_t * buf_ps, hb_list_t * list_es, hb_psdemux_t* state )
+{
+ hb_buffer_t *buf = hb_buffer_init( buf_ps->size );
+
+ // copy everything from the old to the new except the data ptr & alloc
+ uint8_t *data = buf->data;
+ int alloc = buf->alloc;
+ *buf = *buf_ps;
+ buf->data = data;
+ buf->alloc = alloc;
+
+ // now copy the data
+ memcpy( buf->data, buf_ps->data, buf_ps->size );
+ hb_list_add( list_es, buf );
+ return 1;
+}
*/
#include "hb.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
#include "mpeg2dec/mpeg2.h"
#define HQDN3D_SPATIAL_LUMA_DEFAULT 4.0f
#include "hb.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
#include "mpeg2dec/mpeg2.h"
/*
#include "hb.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
struct hb_work_private_s
{
struct hb_fifo_s
{
hb_lock_t * lock;
- int capacity;
- int size;
- int buffer_size;
+ uint32_t capacity;
+ uint32_t size;
+ uint32_t buffer_size;
hb_buffer_t * first;
hb_buffer_t * last;
};
-#define MAX_BUFFER_POOLS 15
-#define BUFFER_POOL_MAX_ELEMENTS 2048
+/* we round the requested buffer size up to the next power of 2 so there can
+ * be at most 32 possible pools when the size is a 32 bit int. To avoid a lot
+ * of slow & error-prone run-time checking we allow for all 32. */
+#define MAX_BUFFER_POOLS 32
+/* the buffer pool only exists to avoid the two malloc and two free calls that
+ * it would otherwise take to allocate & free a buffer. but we don't want to
+ * tie up a lot of memory in the pool because this allocator isn't as general
+ * as malloc so memory tied up here puts more pressure on the malloc pool.
+ * A pool of 16 elements will avoid 94% of the malloc/free calls without wasting
+ * too much memory. */
+#define BUFFER_POOL_MAX_ELEMENTS 32
struct hb_buffer_pools_s
{
- int entries;
- int allocated;
- hb_fifo_t *pool[MAX_BUFFER_POOLS];
+ int64_t allocated;
hb_lock_t *lock;
-};
+ hb_fifo_t *pool[MAX_BUFFER_POOLS];
+} buffers;
-struct hb_buffer_pools_s buffers;
void hb_buffer_pool_init( void )
{
- hb_fifo_t *buffer_pool;
- int size = 512;
- int max_size = 32768;;
-
- buffers.entries = 0;
buffers.lock = hb_lock_init();
buffers.allocated = 0;
- while(size <= max_size) {
- buffer_pool = buffers.pool[buffers.entries++] = hb_fifo_init(BUFFER_POOL_MAX_ELEMENTS);
- buffer_pool->buffer_size = size;
- size *= 2;
+ /* we allocate pools for sizes 2^10 through 2^25. requests larger than
+ * 2^25 will get passed through to malloc. */
+ int i;
+ for ( i = 10; i < 26; ++i )
+ {
+ buffers.pool[i] = hb_fifo_init(BUFFER_POOL_MAX_ELEMENTS);
+ buffers.pool[i]->buffer_size = 1 << i;
+ }
+ /* requests smaller than 2^10 are satisfied from the 2^10 pool. */
+ for ( i = 1; i < 10; ++i )
+ {
+ buffers.pool[i] = buffers.pool[10];
}
}
{
int i;
int count;
- int freed = 0;
+ int64_t freed = 0;
hb_buffer_t *b;
hb_lock(buffers.lock);
- for( i = 0; i < buffers.entries; i++)
+ for( i = 10; i < 26; ++i)
{
count = 0;
while( ( b = hb_fifo_get(buffers.pool[i]) ) )
if( b->data )
{
free( b->data );
- b->data = NULL;
}
free( b );
count++;
}
- hb_log("Freed %d buffers of size %d", count, buffers.pool[i]->buffer_size);
+ if ( count )
+ {
+ hb_log("Freed %d buffers of size %d", count,
+ buffers.pool[i]->buffer_size);
+ }
}
- hb_log("Allocated %d bytes of buffers on this pass and Freed %d bytes, %d bytes leaked",
- buffers.allocated, freed, buffers.allocated - freed);
+ hb_log("Allocated %lld bytes of buffers on this pass and Freed %lld bytes, "
+ "%lld bytes leaked", buffers.allocated, freed, buffers.allocated - freed);
buffers.allocated = 0;
hb_unlock(buffers.lock);
}
-
-hb_buffer_t * hb_buffer_init( int size )
+static hb_fifo_t *size_to_pool( int size )
{
- hb_buffer_t * b;
int i;
- hb_fifo_t *buffer_pool = NULL;
- uint8_t *data;
- int b_alloc;
- int resize = 0;
-
- if( size > 0 )
+ for ( i = 0; i < 30; ++i )
{
- /*
- * The buffer pools are allocated in increasing size
- */
- for( i = 0; i < buffers.entries; i++ )
+ if ( size <= (1 << i) )
{
- if( buffers.pool[i]->buffer_size >= size )
- {
- /*
- * This pool is big enough, but are there any buffers in it?
- */
- if( hb_fifo_size( buffers.pool[i] ) )
- {
- /*
- * We've found a matching buffer pool, with buffers.
- */
- buffer_pool = buffers.pool[i];
- resize = buffers.pool[i]->buffer_size;
- } else {
- /*
- * Buffer pool is empty,
- */
- if( resize ) {
- /*
- * This is the second time through, so break
- * out of here to avoid using too large a
- * buffer for a small job.
- */
- break;
- }
- resize = buffers.pool[i]->buffer_size;
- }
- }
+ return buffers.pool[i];
}
}
- /*
- * Don't reuse the 0 size buffers, not much gain.
- */
- if( size != 0 && buffer_pool )
+ return NULL;
+}
+
+hb_buffer_t * hb_buffer_init( int size )
+{
+ hb_buffer_t * b;
+ hb_fifo_t *buffer_pool = size_to_pool( size );
+
+ if( buffer_pool )
{
b = hb_fifo_get( buffer_pool );
/*
* Zero the contents of the buffer, would be nice if we
* didn't have to do this.
- *
- hb_log("Reused buffer size %d for size %d from pool %d depth %d",
- b->alloc, size, smallest_pool->buffer_size,
- hb_fifo_size(smallest_pool));
- */
- data = b->data;
- b_alloc = b->alloc;
+ */
+ uint8_t *data = b->data;
memset( b, 0, sizeof(hb_buffer_t) );
- b->alloc = b_alloc;
+ b->alloc = buffer_pool->buffer_size;
b->size = size;
b->data = data;
return( b );
}
b->size = size;
+ b->alloc = buffer_pool? buffer_pool->buffer_size : size;
- if( resize )
+ if (size)
{
- size = resize;
- }
- b->alloc = size;
-
- /*
- hb_log("Allocating new buffer of size %d for size %d",
- b->alloc,
- b->size);
- */
-
- if (!size)
- return b;
#if defined( SYS_DARWIN ) || defined( SYS_FREEBSD )
- b->data = malloc( b->alloc );
+ b->data = malloc( b->alloc );
#elif defined( SYS_CYGWIN )
- /* FIXME */
- b->data = malloc( b->alloc + 17 );
+ /* FIXME */
+ b->data = malloc( b->alloc + 17 );
#else
- b->data = memalign( 16, b->alloc );
+ b->data = memalign( 16, b->alloc );
#endif
-
- if( !b->data )
- {
- hb_log( "out of memory" );
- free( b );
- return NULL;
+ if( !b->data )
+ {
+ hb_log( "out of memory" );
+ free( b );
+ return NULL;
+ }
+ hb_lock(buffers.lock);
+ buffers.allocated += b->alloc;
+ hb_unlock(buffers.lock);
}
-
- buffers.allocated += b->alloc;
-
return b;
}
void hb_buffer_realloc( hb_buffer_t * b, int size )
{
- /* No more alignment, but we don't care */
- if( size < 2048 ) {
- size = 2048;
+ if ( size > b->alloc )
+ {
+ uint32_t orig = b->alloc;
+ size = size_to_pool( size )->buffer_size;
+ b->data = realloc( b->data, size );
+ b->alloc = size;
+
+ hb_lock(buffers.lock);
+ buffers.allocated += size - orig;
+ hb_unlock(buffers.lock);
}
- b->data = realloc( b->data, size );
- buffers.allocated -= b->alloc;
- b->alloc = size;
- buffers.allocated += b->alloc;
}
void hb_buffer_close( hb_buffer_t ** _b )
{
hb_buffer_t * b = *_b;
- hb_fifo_t *buffer_pool = NULL;
- int i;
+ hb_fifo_t *buffer_pool = size_to_pool( b->alloc );
- /*
- * Put the buffer into our free list in the matching buffer pool, if there is one.
- */
- if( b->alloc != 0 )
+ if( buffer_pool && b->data && !hb_fifo_is_full( buffer_pool ) )
{
- for( i = 0; i < buffers.entries; i++ )
- {
- if( b->alloc == buffers.pool[i]->buffer_size )
- {
- buffer_pool = buffers.pool[i];
- break;
- }
- }
+ hb_fifo_push( buffer_pool, b );
+ return;
}
-
- if( buffer_pool )
+ /* either the pool is full or this size doesn't use a pool - free the buf */
+ if( b->data )
{
- if( !hb_fifo_is_full( buffer_pool ) )
- {
- if(b->data)
- {
- /*
- hb_log("Putting a buffer of size %d on pool %d, depth %d",
- b->alloc,
- buffer_pool->buffer_size,
- hb_fifo_size(buffer_pool));
- */
- hb_fifo_push( buffer_pool, b );
- } else {
- free(b);
- }
- } else {
- /*
- * Got a load of these size ones already, free this buffer.
- *
- hb_log("Buffer pool for size %d full, freeing buffer", b->alloc);
- */
- if( b->data )
- {
- free( b->data );
- }
- buffers.allocated -= b->alloc;
- free( b );
- }
- } else {
- /*
- * Need a new buffer pool for this size.
- */
+ free( b->data );
hb_lock(buffers.lock);
- if ( b->alloc != 0 && buffers.entries < MAX_BUFFER_POOLS)
- {
- buffer_pool = buffers.pool[buffers.entries++] = hb_fifo_init(BUFFER_POOL_MAX_ELEMENTS);
- buffer_pool->buffer_size = b->alloc;
- hb_fifo_push( buffer_pool, b );
- /*
- hb_log("*** Allocated a new buffer pool for size %d [%d]", b->alloc,
- buffers.entries );
- */
- } else {
- if( b->alloc != 0 )
- {
- for( i = buffers.entries-1; i >= 0; i-- )
- {
- if( hb_fifo_size(buffers.pool[i]) == 0 )
- {
- /*
- * Reuse this pool as it is empty.
- */
- buffers.pool[i]->buffer_size = b->alloc;
- hb_fifo_push( buffers.pool[i], b );
- b = NULL;
- break;
- }
- }
- }
-
- if( b )
- {
- if( b->data )
- {
- free( b->data );
- b->data = NULL;
- buffers.allocated -= b->alloc;
- }
- free( b );
- }
- }
+ buffers.allocated -= b->alloc;
hb_unlock(buffers.lock);
}
-
+ free( b );
*_b = NULL;
-
}
void hb_buffer_copy_settings( hb_buffer_t * dst, const hb_buffer_t * src )
#include "hb.h"
-#include "ffmpeg/avcodec.h"
-#include "ffmpeg/swscale.h"
+#include "libavcodec/avcodec.h"
+#include "libavformat/avformat.h"
+#include "libswscale/swscale.h"
struct hb_handle_s
{
h->pause_lock = hb_lock_init();
/* libavcodec */
- avcodec_init();
- avcodec_register_all();
- av_register_codec_parser( &mpegaudio_parser);
+ av_register_all();
/* Start library thread */
hb_log( "hb_init: starting libhb thread" );
hb_register( &hb_deca52 );
hb_register( &hb_decdca );
hb_register( &hb_decavcodec );
+ hb_register( &hb_decavcodecv );
+ hb_register( &hb_decavcodecvi );
+ hb_register( &hb_decavcodecai );
hb_register( &hb_declpcm );
hb_register( &hb_encfaac );
hb_register( &hb_enclame );
extern "C" {
#endif
+#include "hbversion.h"
#include "common.h"
/* hb_init()
hb_register( &hb_deca52 ); \
hb_register( &hb_decdca ); \
hb_register( &hb_decavcodec ); \
+hb_register( &hb_decavcodecv ); \
+hb_register( &hb_decavcodecvi ); \
+hb_register( &hb_decavcodecai ); \
hb_register( &hb_declpcm ); \
hb_register( &hb_encfaac ); \
hb_register( &hb_enclame ); \
hb_register( &hb_deca52 ); \
hb_register( &hb_decdca ); \
hb_register( &hb_decavcodec ); \
+hb_register( &hb_decavcodecv ); \
+hb_register( &hb_decavcodecvi ); \
+hb_register( &hb_decavcodecai ); \
hb_register( &hb_declpcm ); \
hb_register( &hb_encfaac ); \
volatile int * die, int * error, hb_job_t ** job );
hb_thread_t * hb_reader_init( hb_job_t * );
hb_thread_t * hb_muxer_init( hb_job_t * );
-
-/***********************************************************************
- * libmpeg2 wrapper
- ***********************************************************************
- * It is exported here because it is used at several places
- **********************************************************************/
-typedef struct hb_libmpeg2_s hb_libmpeg2_t;
-
-hb_libmpeg2_t * hb_libmpeg2_init();
-int hb_libmpeg2_decode( hb_libmpeg2_t *,
- hb_buffer_t * es_buf,
- hb_list_t * raw_list );
-void hb_libmpeg2_info( hb_libmpeg2_t * m, int * width,
- int * height, int * rate, int * aspect_ratio );
-void hb_libmpeg2_close( hb_libmpeg2_t ** );
-int hb_libmpeg2_clear_aspect_ratio( hb_libmpeg2_t * );
+hb_work_object_t * hb_get_work( int );
+hb_work_object_t * hb_codec_decoder( int );
+hb_work_object_t * hb_codec_encoder( int );
/***********************************************************************
* mpegdemux.c
} hb_psdemux_t;
int hb_demux_ps( hb_buffer_t * ps_buf, hb_list_t * es_list, hb_psdemux_t * );
+int hb_demux_null( hb_buffer_t * ps_buf, hb_list_t * es_list, hb_psdemux_t * );
/***********************************************************************
* dvd.c
int hb_dvd_is_break( hb_dvd_t * d );
void hb_dvd_close( hb_dvd_t ** );
-hb_stream_t * hb_stream_open( char * path, int opentype );
+hb_stream_t * hb_stream_open( char * path, hb_title_t *title );
void hb_stream_close( hb_stream_t ** );
hb_title_t * hb_stream_title_scan( hb_stream_t *);
int hb_stream_read( hb_stream_t *, hb_buffer_t *);
int hb_stream_seek( hb_stream_t *, float );
+void * hb_ffmpeg_context( int codec_param );
+void * hb_ffmpeg_avstream( int codec_param );
+
/***********************************************************************
* Work objects
**********************************************************************/
WORK_DECA52,
WORK_DECDCA,
WORK_DECAVCODEC,
+ WORK_DECAVCODECV,
+ WORK_DECAVCODECVI,
+ WORK_DECAVCODECAI,
WORK_DECLPCM,
WORK_ENCFAAC,
WORK_ENCLAME,
It may be used under the terms of the GNU General Public License. */
#include "hb.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
#define AVIF_HASINDEX 0x10
#define AVIIF_KEYFRAME 0x10
HB_NORMAL_PRIORITY );
}
+static void push_buf( hb_reader_t *r, hb_fifo_t *fifo, hb_buffer_t *buf )
+{
+ while( !*r->die && !r->job->done && hb_fifo_is_full( fifo ) )
+ {
+ /*
+ * Loop until the incoming fifo is reaqdy to receive
+ * this buffer.
+ */
+ hb_snooze( 50 );
+ }
+ hb_fifo_push( fifo, buf );
+}
+
/***********************************************************************
* ReaderFunc
***********************************************************************
hb_reader_t * r = _r;
hb_fifo_t ** fifos;
hb_buffer_t * buf;
- hb_buffer_t * buf_old;
hb_list_t * list;
int n;
int chapter = -1;
if( !( r->dvd = hb_dvd_init( r->title->dvd ) ) )
{
- if ( !( r->stream = hb_stream_open( r->title->dvd, 1 ) ) )
+ if ( !( r->stream = hb_stream_open( r->title->dvd, r->title ) ) )
{
return;
}
hb_set_state( r->job->h, &state );
}
- hb_demux_ps( r->ps, list, &r->demux );
+ if ( r->title->demuxer == HB_NULL_DEMUXER )
+ {
+ hb_demux_null( r->ps, list, &r->demux );
+ }
+ else
+ {
+ hb_demux_ps( r->ps, list, &r->demux );
+ }
while( ( buf = hb_list_item( list, 0 ) ) )
{
{
/* The first video packet defines 'time zero' so discard
data until we get a video packet with a PTS */
- if ( buf->id == 0xE0 && buf->start != -1 )
+ if ( buf->id == r->title->video_id && buf->start != -1 )
{
r->saw_video = 1;
- r->demux.scr_offset = buf->start;
+ r->demux.scr_offset = buf->renderOffset;
hb_log( "reader: first SCR %llu scr_offset %llu",
r->demux.last_scr, r->demux.scr_offset );
}
everything after this sees a continuous clock with 0
being the time of the first video packet. */
buf->start -= r->demux.scr_offset;
+ buf->renderOffset -= r->demux.scr_offset;
}
buf->sequence = r->sequence++;
- for( n = 0; fifos[n] != NULL; n++)
+ /* if there are mutiple output fifos, send a copy of the
+ * buffer down all but the first (we have to not ship the
+ * original buffer or we'll race with the thread that's
+ * consuming the buffer & inject garbage into the data stream). */
+ for( n = 1; fifos[n] != NULL; n++)
{
- if( n != 0 )
- {
- /*
- * Replace the buffer with a new copy of itself for when
- * it is being sent down multiple fifos.
- */
- buf_old = buf;
- buf = hb_buffer_init(buf_old->size);
- memcpy( buf->data, buf_old->data, buf->size );
- hb_buffer_copy_settings( buf, buf_old );
- }
-
- while( !*r->die && !r->job->done &&
- hb_fifo_is_full( fifos[n] ) )
- {
- /*
- * Loop until the incoming fifo is reaqdy to receive
- * this buffer.
- */
- hb_snooze( 50 );
- }
-
- hb_fifo_push( fifos[n], buf );
+ hb_buffer_t *buf_copy = hb_buffer_init( buf->size );
+ hb_buffer_copy_settings( buf_copy, buf );
+ memcpy( buf_copy->data, buf->data, buf->size );
+ push_buf( r, fifos[n], buf_copy );
}
+ push_buf( r, fifos[0], buf );
}
else
{
memset(fifos, 0, sizeof(fifos));
- if( id == 0xE0 )
+ if( id == title->video_id )
{
if( job->indepth_scan )
{
#include "hb.h"
-#include "ffmpeg/avcodec.h"
-#include "ffmpeg/swscale.h"
+#include "libavcodec/avcodec.h"
+#include "libswscale/swscale.h"
struct hb_work_private_s
{
static int DecodePreviews( hb_scan_t * data, hb_title_t * title )
{
int i, npreviews = 0;
- hb_buffer_t * buf_ps, * buf_es, * buf_raw;
- hb_list_t * list_es, * list_raw;
- hb_libmpeg2_t * mpeg2;
+ hb_buffer_t * buf_ps, * buf_es;
+ hb_list_t * list_es;
int progressive_count = 0;
int interlaced_preview_count = 0;
- int last_ar = 0, ar16_count = 0, ar4_count = 0;
+ double last_ar = 0;
+ int ar16_count = 0, ar4_count = 0;
buf_ps = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
list_es = hb_list_init();
- list_raw = hb_list_init();
hb_log( "scan: decoding previews for title %d", title->index );
{
if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / 11.0 ) )
{
- goto error;
+ continue;
}
}
else if (data->stream)
* file and we need it to decode any previews. */
if (!hb_stream_seek(data->stream, (float) i / 11.0 ) )
{
- goto error;
+ continue;
}
}
hb_log( "scan: preview %d", i + 1 );
- mpeg2 = hb_libmpeg2_init();
+ int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2;
+ hb_work_object_t *vid_decoder = hb_get_work( vcodec );
+ vid_decoder->codec_param = title->video_codec_param;
+ vid_decoder->init( vid_decoder, NULL );
+ hb_buffer_t * vid_buf = NULL;
for( j = 0; j < 10240 ; j++ )
{
goto skip_preview;
}
}
- hb_demux_ps( buf_ps, list_es, 0 );
+ if ( title->demuxer == HB_NULL_DEMUXER )
+ {
+ hb_demux_null( buf_ps, list_es, 0 );
+ }
+ else
+ {
+ hb_demux_ps( buf_ps, list_es, 0 );
+ }
while( ( buf_es = hb_list_item( list_es, 0 ) ) )
{
hb_list_rem( list_es, buf_es );
- if( buf_es->id == 0xE0 && !hb_list_count( list_raw ) )
+ if( buf_es->id == title->video_id && vid_buf == NULL )
{
- hb_libmpeg2_decode( mpeg2, buf_es, list_raw );
- int ar = hb_libmpeg2_clear_aspect_ratio( mpeg2 );
- if ( ar != 0 )
- {
- if ( ar != last_ar && last_ar != 0 )
- {
- hb_log( "aspect ratio changed from %d to %d",
- last_ar, ar );
- }
- switch ( ar )
- {
- case HB_ASPECT_BASE * 4 / 3:
- ++ar4_count;
- break;
- case HB_ASPECT_BASE * 16 / 9:
- ++ar16_count;
- break;
- default:
- hb_log( "unknown aspect ratio %d", ar );
- /* if the aspect is closer to 4:3 use that
- * otherwise use 16:9 */
- if ( ar < HB_ASPECT_BASE * 14 / 9 )
- {
- ++ar4_count;
- }
- else
- {
- ++ar16_count;
- }
- break;
- }
- }
- last_ar = ar;
+ vid_decoder->work( vid_decoder, &buf_es, &vid_buf );
}
else if( ! AllAudioOK( title ) )
{
LookForAudio( title, buf_es );
}
- hb_buffer_close( &buf_es );
-
- if( hb_list_count( list_raw ) && AllAudioOK( title ) )
- {
- /* We got a picture */
- break;
- }
+ if ( buf_es )
+ hb_buffer_close( &buf_es );
}
- if( hb_list_count( list_raw ) && AllAudioOK( title ) )
- {
+ if( vid_buf && AllAudioOK( title ) )
break;
- }
}
- if( !hb_list_count( list_raw ) )
+ if( ! vid_buf )
{
hb_log( "scan: could not get a decoded picture" );
continue;
}
/* Get size and rate infos */
- title->rate = 27000000;
- int ar;
- hb_libmpeg2_info( mpeg2, &title->width, &title->height,
- &title->rate_base, &ar );
- /* if we found mostly 4:3 previews use that as the aspect ratio otherwise
- use 16:9 */
- title->aspect = ar4_count > ar16_count ?
- HB_ASPECT_BASE * 4 / 3 : HB_ASPECT_BASE * 16 / 9;
+ hb_work_info_t vid_info;
+ vid_decoder->info( vid_decoder, &vid_info );
+ vid_decoder->close( vid_decoder );
+ free( vid_decoder );
+
+ title->width = vid_info.width;
+ title->height = vid_info.height;
+ title->rate = vid_info.rate;
+ title->rate_base = vid_info.rate_base;
+ if ( vid_info.aspect != 0 )
+ {
+ if ( vid_info.aspect != last_ar && last_ar != 0 )
+ {
+ hb_log( "aspect ratio changed from %g to %g",
+ last_ar, vid_info.aspect );
+ }
+ switch ( (int)vid_info.aspect )
+ {
+ case HB_ASPECT_BASE * 4 / 3:
+ ++ar4_count;
+ break;
+ case HB_ASPECT_BASE * 16 / 9:
+ ++ar16_count;
+ break;
+ default:
+ hb_log( "unknown aspect ratio %g", vid_info.aspect );
+ /* if the aspect is closer to 4:3 use that
+ * otherwise use 16:9 */
+ vid_info.aspect < HB_ASPECT_BASE * 14 / 9 ? ++ar4_count :
+ ++ar16_count;
+ break;
+ }
+ last_ar = vid_info.aspect;
+ }
if( title->rate_base == 1126125 )
{
title->crop[2] = title->crop[3] = title->width / 2;
}
- hb_libmpeg2_close( &mpeg2 );
-
while( ( buf_es = hb_list_item( list_es, 0 ) ) )
{
hb_list_rem( list_es, buf_es );
hb_buffer_close( &buf_es );
}
- buf_raw = hb_list_item( list_raw, 0 );
-
/* Check preview for interlacing artifacts */
- if( hb_detect_comb( buf_raw, title->width, title->height, 10, 30, 9, 10, 30, 9 ) )
+ if( hb_detect_comb( vid_buf, title->width, title->height, 10, 30, 9, 10, 30, 9 ) )
{
hb_log("Interlacing detected in preview frame %i", i);
interlaced_preview_count++;
file_preview = fopen( filename, "w" );
if( file_preview )
{
- fwrite( buf_raw->data, title->width * title->height * 3 / 2,
+ fwrite( vid_buf->data, title->width * title->height * 3 / 2,
1, file_preview );
fclose( file_preview );
}
hb_log( "scan: fopen failed (%s)", filename );
}
-#define Y buf_raw->data
+#define Y vid_buf->data
#define DARK 64
/* Detect black borders */
for( j = 0; j < title->width; j++ )
{
- for( k = 0; k < title->crop[0]; k++ )
+ for( k = 2; k < title->crop[0]; k++ )
if( Y[ k * title->width + j ] > DARK )
{
title->crop[0] = k;
++npreviews;
skip_preview:
- while( ( buf_raw = hb_list_item( list_raw, 0 ) ) )
- {
- hb_list_rem( list_raw, buf_raw );
- hb_buffer_close( &buf_raw );
- }
+ if ( vid_buf )
+ hb_buffer_close( &vid_buf );
}
+ /* if we found mostly 4:3 previews use that as the aspect ratio otherwise
+ use 16:9 */
+ title->aspect = ar4_count > ar16_count ?
+ HB_ASPECT_BASE * 4 / 3 : HB_ASPECT_BASE * 16 / 9;
+
title->crop[0] = EVEN( title->crop[0] );
title->crop[1] = EVEN( title->crop[1] );
title->crop[2] = EVEN( title->crop[2] );
title->detected_interlacing = 0;
}
- goto cleanup;
-
-error:
- npreviews = 0;
-
-cleanup:
hb_buffer_close( &buf_ps );
while( ( buf_es = hb_list_item( list_es, 0 ) ) )
{
hb_buffer_close( &buf_es );
}
hb_list_close( &list_es );
- while( ( buf_raw = hb_list_item( list_raw, 0 ) ) )
- {
- hb_list_rem( list_raw, buf_raw );
- hb_buffer_close( &buf_raw );
- }
- hb_list_close( &list_raw );
if (data->dvd)
hb_dvd_stop( data->dvd );
return npreviews;
}
-static void update_audio_description( const char *codec, hb_audio_t *audio,
- int is_dolby )
-{
- hb_log( "scan: %s, rate=%dHz, bitrate=%d", codec, audio->config.in.samplerate,
- audio->config.in.bitrate );
-
- /* XXX */
- if ( is_dolby )
- {
- strcat( audio->config.lang.description, " (Dolby Surround)" );
- return;
- }
-
- char *desc = audio->config.lang.description +
- strlen( audio->config.lang.description );
- sprintf( desc, " (%d.%d ch)",
- HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(audio->config.in.channel_layout) +
- HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(audio->config.in.channel_layout),
- HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(audio->config.in.channel_layout));
-}
-
-static int hb_setup_a52_audio( hb_audio_t *audio, hb_buffer_t *b )
-{
- int i, rate, bitrate, flags;
-
- /* since AC3 frames don't line up with MPEG ES frames scan the
- * entire frame for an AC3 sync pattern. */
- for ( i = 0; i < b->size - 7; ++i )
- {
- if( a52_syncinfo( &b->data[i], &flags, &rate, &bitrate ) != 0 )
- {
- break;
- }
- }
- if ( i >= b->size - 7 )
- {
- /* didn't find AC3 sync */
- return 0;
- }
-
- audio->config.in.samplerate = rate;
- audio->config.in.bitrate = bitrate;
-
- switch( flags & A52_CHANNEL_MASK )
- {
- /* mono sources */
- case A52_MONO:
- case A52_CHANNEL1:
- case A52_CHANNEL2:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_MONO;
- break;
- /* stereo input */
- case A52_CHANNEL:
- case A52_STEREO:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- break;
- /* dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input */
- case A52_DOLBY:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_DOLBY;
- break;
- /* 3F/2R input */
- case A52_3F2R:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F2R;
- break;
- /* 3F/1R input */
- case A52_3F1R:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F1R;
- break;
- /* other inputs */
- case A52_3F:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F;
- break;
- case A52_2F1R:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F1R;
- break;
- case A52_2F2R:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F2R;
- break;
- /* unknown */
- default:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- }
-
- if (flags & A52_LFE)
- {
- audio->config.in.channel_layout |= HB_INPUT_CH_LAYOUT_HAS_LFE;
- }
-
- /* store the AC3 flags for future reference
- * This enables us to find out if we had a stereo or Dolby source later on
- * Store the ac3 flags in the public ac3flags property too, so we can access
- * it from the GUI
- */
- audio->config.flags.ac3 = audio->priv.config.a52.ac3flags = flags;
- update_audio_description( "AC3", audio, (flags & A52_CHANNEL_MASK) == A52_DOLBY );
- return 1;
-}
-
-static int hb_setup_dca_audio( hb_audio_t *audio, hb_buffer_t *b )
-{
- int i, flags, rate, bitrate, frame_length;
- dca_state_t * state = dca_init( 0 );
-
- /* since DCA frames don't line up with MPEG ES frames scan the
- * entire frame for an DCA sync pattern. */
- for ( i = 0; i < b->size - 7; ++i )
- {
- if( dca_syncinfo( state, &b->data[i], &flags, &rate, &bitrate,
- &frame_length ) )
- {
- break;
- }
- }
- if ( i >= b->size - 7 )
- {
- /* didn't find DCA sync */
- return 0;
- }
-
- audio->config.in.samplerate = rate;
- audio->config.in.bitrate = bitrate;
- switch( flags & DCA_CHANNEL_MASK )
- {
- /* mono sources */
- case DCA_MONO:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_MONO;
- break;
- /* stereo input */
- case DCA_CHANNEL:
- case DCA_STEREO:
- case DCA_STEREO_SUMDIFF:
- case DCA_STEREO_TOTAL:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- break;
- /* 3F/2R input */
- case DCA_3F2R:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F2R;
- break;
- /* 3F/1R input */
- case DCA_3F1R:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F1R;
- break;
- /* other inputs */
- case DCA_3F:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_3F;
- break;
- case DCA_2F1R:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F1R;
- break;
- case DCA_2F2R:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_2F2R;
- break;
- case DCA_4F2R:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_4F2R;
- break;
- /* unknown */
- default:
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- }
-
- if (flags & DCA_LFE)
- {
- audio->config.in.channel_layout |= HB_INPUT_CH_LAYOUT_HAS_LFE;
- }
-
- /* store the DCA flags for future reference
- * This enables us to find out if we had a stereo or Dolby source later on
- * store the dca flags in the public dcaflags property too, so we can access
- * it from the GUI
- */
- audio->config.flags.dca = audio->priv.config.dca.dcaflags = flags;
- update_audio_description( "DCA", audio, (flags & DCA_CHANNEL_MASK) == DCA_DOLBY );
- return 1;
-}
-
-static int hb_setup_pcm_audio( hb_audio_t *audio, hb_buffer_t *b )
-{
- // LPCM doesn't have a sync pattern like AC3 or DCA but every
- // LPCM elementary stream packet starts with a 7 byte header
- // giving the characteristics of the stream.
- // See libhb/declpcm.c for a description of the LPCM header.
-
- static const int hdr2samplerate[] = { 48000, 96000, 44100, 32000 };
- static const int hdr2samplesize[] = { 16, 20, 24, 16 };
- static const int hdr2layout[] = {
- HB_INPUT_CH_LAYOUT_MONO, HB_INPUT_CH_LAYOUT_STEREO,
- HB_INPUT_CH_LAYOUT_2F1R, HB_INPUT_CH_LAYOUT_2F2R,
- HB_INPUT_CH_LAYOUT_3F2R, HB_INPUT_CH_LAYOUT_4F2R,
- HB_INPUT_CH_LAYOUT_STEREO, HB_INPUT_CH_LAYOUT_STEREO,
- };
-
- int nchannels = ( b->data[4] & 7 ) + 1;
- int sample_size = hdr2samplesize[b->data[4] >> 6];
-
- int rate = hdr2samplerate[ ( b->data[4] >> 4 ) & 0x3 ];
- int bitrate = rate * sample_size * nchannels;
-
- audio->config.in.samplerate = rate;
- audio->config.in.bitrate = bitrate;
- audio->config.in.channel_layout = hdr2layout[nchannels - 1];
- update_audio_description( "LPCM", audio, 0 );
- return 1;
-}
-
-static int hb_setup_mpg_audio( hb_audio_t *audio, hb_buffer_t *b )
-{
- /* XXX
- * This is a placeholder to get the audio sample rate set.
- * It should be replaced by something that extracts the correct info from
- * the mpeg audio bitstream.
- */
- audio->config.in.samplerate = 48000;
- audio->config.in.bitrate = 384000;
- audio->config.in.channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
- update_audio_description( "MPGA", audio, 0 );
- return 1;
-}
-
/*
* This routine is called for every frame from a non-video elementary stream.
* These are a mix of audio & subtitle streams, some of which we want & some
return;
}
- switch ( audio->config.in.codec )
- {
- case HB_ACODEC_AC3:
- hb_setup_a52_audio( audio, b );
- break;
+ hb_work_object_t *w = hb_codec_decoder( audio->config.in.codec );
- case HB_ACODEC_DCA:
- hb_setup_dca_audio( audio, b );
- break;
-
- case HB_ACODEC_LPCM:
- hb_setup_pcm_audio( audio, b );
- break;
+ if ( w == NULL || w->bsinfo == NULL )
+ {
+ hb_log( "Internal error in scan: unhandled audio type %d for id 0x%x",
+ audio->config.in.codec, audio->id );
+ goto drop_audio;
+ }
- case HB_ACODEC_MPGA:
- hb_setup_mpg_audio( audio, b );
- break;
+ hb_work_info_t info;
+ w->audio = audio;
+ w->codec_param = audio->config.in.codec_param;
+ int ret = w->bsinfo( w, b, &info );
+ if ( ret < 0 )
+ {
+ hb_log( "no info on audio type %d/0x%x for id 0x%x",
+ audio->config.in.codec, audio->config.in.codec_param,
+ audio->id );
+ goto drop_audio;
+ }
+ if ( !info.bitrate )
+ {
+ /* didn't find any info */
+ return;
+ }
+ audio->config.in.samplerate = info.rate;
+ audio->config.in.bitrate = info.bitrate;
+ audio->config.in.channel_layout = info.channel_layout;
+ audio->config.flags.ac3 = info.flags;
- default:
- hb_log( "Internal error in scan: unhandled audio type %d for 0x%x",
- audio->config.in.codec, audio->id );
- break;
+ // update the audio description string based on the info we found
+ if ( audio->config.flags.ac3 & AUDIO_F_DOLBY )
+ {
+ strcat( audio->config.lang.description, " (Dolby Surround)" );
}
+ else
+ {
+ int layout = audio->config.in.channel_layout;
+ char *desc = audio->config.lang.description +
+ strlen( audio->config.lang.description );
+ sprintf( desc, " (%d.%d ch)",
+ HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(layout) +
+ HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(layout),
+ HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(layout) );
+ }
+
+ hb_log( "scan: audio 0x%x: %s, rate=%dHz, bitrate=%d %s", audio->id,
+ info.name, audio->config.in.samplerate, audio->config.in.bitrate,
+ audio->config.lang.description );
+
+ free( w );
+ return;
+
+ // We get here if there's no hope of finding info on an audio bitstream,
+ // either because we don't have a decoder (or a decoder with a bitstream
+ // info proc) or because the decoder's info proc said that the stream
+ // wasn't something it could handle. Delete the item from the title's
+ // audio list so we won't keep reading packets while trying to get its
+ // bitstream info.
+ drop_audio:
+ if ( w )
+ free( w );
+
+ hb_list_rem( title->list_audio, audio );
}
/*
#include "hb.h"
#include "lang.h"
#include "a52dec/a52.h"
+#include "libavcodec/avcodec.h"
+#include "libavformat/avformat.h"
#include <string.h>
+#include <ctype.h>
#define min(a, b) a < b ? a : b
+/*
+ * This table defines how ISO MPEG stream type codes map to HandBrake
+ * codecs. It is indexed by the 8 bit stream type and contains the codec
+ * worker object id and a parameter for that worker proc (ignored except
+ * for the ffmpeg-based codecs in which case it is the ffmpeg codec id).
+ *
+ * Entries with a worker proc id of 0 or a kind of 'U' indicate that HB
+ * doesn't handle the stream type.
+ */
+typedef struct {
+ enum { U, A, V } kind; /* unknown / audio / video */
+ int codec; /* HB worker object id of codec */
+ int codec_param; /* param for codec (usually ffmpeg codec id) */
+ const char* name; /* description of type */
+} stream2codec_t;
+
+#define st(id, kind, codec, codec_param, name) \
+ [id] = { kind, codec, codec_param, name }
+
+static const stream2codec_t st2codec[256] = {
+ st(0x01, V, WORK_DECMPEG2, 0, "MPEG1"),
+ st(0x02, V, WORK_DECMPEG2, 0, "MPEG2"),
+ st(0x03, A, HB_ACODEC_MPGA, CODEC_ID_MP2, "MPEG1"),
+ st(0x04, A, HB_ACODEC_MPGA, CODEC_ID_MP2, "MPEG2"),
+ st(0x05, U, 0, 0, "ISO 13818-1 private section"),
+ st(0x06, U, 0, 0, "ISO 13818-1 PES private data"),
+ st(0x07, U, 0, 0, "ISO 13522 MHEG"),
+ st(0x08, U, 0, 0, "ISO 13818-1 DSM-CC"),
+ st(0x09, U, 0, 0, "ISO 13818-1 auxiliary"),
+ st(0x0a, U, 0, 0, "ISO 13818-6 encap"),
+ st(0x0b, U, 0, 0, "ISO 13818-6 DSM-CC U-N msgs"),
+ st(0x0c, U, 0, 0, "ISO 13818-6 Stream descriptors"),
+ st(0x0d, U, 0, 0, "ISO 13818-6 Sections"),
+ st(0x0e, U, 0, 0, "ISO 13818-1 auxiliary"),
+ st(0x0f, A, HB_ACODEC_MPGA, CODEC_ID_AAC, "ISO 13818-7 AAC Audio"),
+ st(0x10, V, WORK_DECAVCODECV, CODEC_ID_MPEG4, "MPEG4"),
+ st(0x11, A, HB_ACODEC_MPGA, CODEC_ID_AAC, "MPEG4 LATM AAC"),
+ st(0x12, U, 0, 0, "MPEG4 generic"),
+
+ st(0x14, U, 0, 0, "ISO 13818-6 DSM-CC download"),
+
+ st(0x1b, V, WORK_DECAVCODECV, CODEC_ID_H264, "H.264"),
+
+ st(0x80, U, 0, 0, "DigiCipher II Video"),
+ st(0x81, A, HB_ACODEC_AC3, 0, "AC-3"),
+ st(0x82, A, HB_ACODEC_MPGA, CODEC_ID_DTS, "HDMV DTS"),
+ st(0x83, A, HB_ACODEC_LPCM, 0, "LPCM"),
+ st(0x84, A, 0, 0, "SDDS"),
+ st(0x85, U, 0, 0, "ATSC Program ID"),
+ st(0x86, U, 0, 0, "SCTE 35 splice info"),
+ st(0x87, A, 0, 0, "E-AC-3"),
+
+ st(0x8a, A, HB_ACODEC_DCA, 0, "DTS"),
+
+ st(0x91, A, HB_ACODEC_AC3, 0, "AC-3"),
+ st(0x92, U, 0, 0, "Subtitle"),
+
+ st(0x94, A, 0, 0, "SDDS"),
+ st(0xa0, V, 0, 0, "MSCODEC"),
+
+ st(0xea, V, WORK_DECAVCODECV, CODEC_ID_VC1, "VC1"),
+};
+#undef st
+
typedef enum {
hb_stream_type_unknown = 0,
transport,
program,
- dvd_program
+ dvd_program,
+ ffmpeg
} hb_stream_type_t;
#define kMaxNumberVideoPIDS 1
char *path;
FILE *file_handle;
hb_stream_type_t hb_stream_type;
- int opentype;
+ hb_title_t *title;
+
+ AVFormatContext *ffmpeg_ic;
struct {
int lang_code;
static void hb_ps_stream_find_audio_ids(hb_stream_t *stream, hb_title_t *title);
static off_t align_to_next_packet(hb_stream_t *stream);
+static int ffmpeg_open( hb_stream_t *stream, hb_title_t *title );
+static void ffmpeg_close( hb_stream_t *d );
+static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream );
+static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf );
+static int ffmpeg_seek( hb_stream_t *stream, float frac );
+
/*
* streams have a bunch of state that's learned during the scan. We don't
* want to throw away the state when scan does a close then relearn
***********************************************************************
*
**********************************************************************/
-hb_stream_t * hb_stream_open( char *path, int opentype )
+hb_stream_t * hb_stream_open( char *path, hb_title_t *title )
{
-
FILE *f = fopen( path, "r" );
if ( f == NULL )
{
* (even if we have saved state, the stream may have changed).
*/
hb_stream_t *ss = hb_stream_lookup( path );
- if ( opentype == 1 )
+ if ( title && ss && ss->hb_stream_type != ffmpeg )
{
- /* opening to read - we must have saved state */
- if ( ss == NULL )
- {
- hb_log( "hb_stream_open: error: re-opening %s but no scan state", path );
- fclose( f );
- free( d );
- return NULL;
- }
/*
* copy the saved state since we might be encoding the same stream
* multiple times.
*/
memcpy( d, ss, sizeof(*d) );
d->file_handle = f;
- d->opentype = opentype;
+ d->title = title;
d->path = strdup( path );
if ( d->hb_stream_type == transport )
hb_stream_state_delete( ss );
}
d->file_handle = f;
- d->opentype = opentype;
+ d->title = title;
d->path = strdup( path );
- if (d->path != NULL && hb_stream_get_type( d ) != 0 )
+ if (d->path != NULL )
{
- return d;
+ if ( hb_stream_get_type( d ) != 0 )
+ {
+ return d;
+ }
+ fclose( d->file_handle );
+ d->file_handle = NULL;
+ if ( ffmpeg_open( d, title ) )
+ {
+ return d;
+ }
}
fclose( d->file_handle );
if (d->path)
void hb_stream_close( hb_stream_t ** _d )
{
hb_stream_t *stream = * _d;
+
+ if ( stream->hb_stream_type == ffmpeg )
+ {
+ ffmpeg_close( stream );
+ hb_stream_delete( stream );
+ *_d = NULL;
+ return;
+ }
+
if ( stream->frames )
{
hb_log( "stream: %d good frames, %d errors (%.0f%%)", stream->frames,
stream->errors, (double)stream->errors * 100. /
(double)stream->frames );
}
+
/*
* if the stream was opened for a scan, cache the result, otherwise delete
* the state.
*/
- if ( stream->opentype == 0 )
+ if ( stream->title == NULL )
{
hb_stream_delete_dynamic( stream );
if ( stream_state_list == NULL )
**********************************************************************/
hb_title_t * hb_stream_title_scan(hb_stream_t *stream)
{
+ if ( stream->hb_stream_type == ffmpeg )
+ return ffmpeg_title_scan( stream );
+
// 'Barebones Title'
hb_title_t *aTitle = hb_title_init( stream->path, 0 );
aTitle->index = 1;
stream->ts_audio_pids[stream->ts_number_audio_pids++] =
stream->pmt_info.PCR_PID;
}
+
+ // set up the video codec to use for this title
+ aTitle->video_codec = st2codec[stream->ts_stream_type[0]].codec;
+ aTitle->video_codec_param = st2codec[stream->ts_stream_type[0]].codec_param;
}
else
{
**********************************************************************/
int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b )
{
+ if ( src_stream->hb_stream_type == ffmpeg )
+ {
+ return ffmpeg_read( src_stream, b );
+ }
if ( src_stream->hb_stream_type == dvd_program )
{
size_t amt_read = fread(b->data, HB_DVD_READ_BUFFER_SIZE, 1,
**********************************************************************/
int hb_stream_seek( hb_stream_t * src_stream, float f )
{
+ if ( src_stream->hb_stream_type == ffmpeg )
+ {
+ return ffmpeg_seek( src_stream, f );
+ }
off_t stream_size, cur_pos, new_pos;
double pos_ratio = f;
cur_pos = ftello( src_stream->file_handle );
return 1;
}
+static const char* make_upper( const char* s )
+{
+ static char name[8];
+ char *cp = name;
+ char *ep = cp + sizeof(name)-1;
+
+ while ( *s && cp < ep )
+ {
+ *cp++ = islower(*s)? toupper(*s) : *s;
+ ++s;
+ }
+ *cp = 0;
+ return name;
+}
+
static void set_audio_description( hb_audio_t *audio, iso639_lang_t *lang )
{
/* XXX
* code or a lang pointer into the audio config & let the common description
* formatting routine in scan.c do all the stuff below.
*/
+ const char *codec_name;
+ AVCodecContext *cc;
+
+ if ( audio->config.in.codec == HB_ACODEC_FFMPEG &&
+ ( cc = hb_ffmpeg_context( audio->config.in.codec_param ) ) &&
+ avcodec_find_decoder( cc->codec_id ) )
+ {
+ codec_name = make_upper( avcodec_find_decoder( cc->codec_id )->name );
+ if ( !strcmp( codec_name, "LIBFAAD" ) )
+ {
+ codec_name = "AAC";
+ }
+ }
+ else if ( audio->config.in.codec == HB_ACODEC_MPGA &&
+ avcodec_find_decoder( audio->config.in.codec_param ) )
+ {
+ codec_name = avcodec_find_decoder( audio->config.in.codec_param )->name;
+ }
+ else
+ {
+ codec_name = audio->config.in.codec == HB_ACODEC_AC3 ? "AC3" :
+ audio->config.in.codec == HB_ACODEC_DCA ? "DTS" :
+ audio->config.in.codec == HB_ACODEC_MPGA ? "MPEG" :
+ audio->config.in.codec == HB_ACODEC_LPCM ? "LPCM" :
+ audio->config.in.codec == HB_ACODEC_FFMPEG ? "FFMPEG" :
+ "Unknown";
+ }
snprintf( audio->config.lang.description,
sizeof( audio->config.lang.description ), "%s (%s)",
strlen(lang->native_name) ? lang->native_name : lang->eng_name,
- audio->config.in.codec == HB_ACODEC_AC3 ? "AC3" :
- audio->config.in.codec == HB_ACODEC_DCA ? "DTS" :
- audio->config.in.codec == HB_ACODEC_MPGA ? "MPEG" : "LPCM" );
+ codec_name );
snprintf( audio->config.lang.simple, sizeof( audio->config.lang.simple ), "%s",
strlen(lang->native_name) ? lang->native_name : lang->eng_name );
snprintf( audio->config.lang.iso639_2, sizeof( audio->config.lang.iso639_2 ),
buf = hb_ts_stream_getPEStype(stream, stream->ts_audio_pids[aud_pid_index]);
/* check that we found a PES header */
+ uint8_t stype = 0;
if (buf && buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x01)
{
- if (buf[3] == 0xbd)
+ // 0xbd is the normal container for AC3/DCA/PCM/etc. 0xfd indicates an
+ // extended stream id (ISO 13818-1(2007)). If we cared about the
+ // real id we'd have to look inside the PES extension to find it.
+ // But since we remap stream id's when we generate PS packets from
+ // the TS packets we can just ignore the actual id.
+ if ( buf[3] == 0xbd || buf[3] == 0xfd )
{
audio->id = 0x80bd | (aud_pid_index << 8);
- audio->config.in.codec = HB_ACODEC_AC3;
- hb_log("transport stream pid 0x%x (type 0x%x) is AC-3 audio id 0x%x",
- stream->ts_audio_pids[aud_pid_index],
- stream->ts_stream_type[1 + aud_pid_index],
- audio->id);
- stream->ts_stream_type[1 + aud_pid_index] = 0x81;
- stream->ts_streamid[1 + aud_pid_index] = 0xbd;
- }
- else if (buf[3] == 0xfd)
- {
- /* XXX Extended stream id (ISO 13818-1(2000) Amd 2) - we have to look
- * inside the PES extension to find out the real stream id then
- * figure out what the heck it means. For now we just use the stream
- * type if one was specified. */
- const char *atype = 0;
- switch (stream->ts_stream_type[1 + aud_pid_index])
+ stype = stream->ts_stream_type[1 + aud_pid_index];
+ if ( st2codec[stype].kind == U )
{
- case 0x81: // AC-3
- atype = "AC-3";
- audio->config.in.codec = HB_ACODEC_AC3;
- break;
- case 0x82: // HDMV DTS
- case 0x8a: // DTS
- atype = "DTS";
- audio->config.in.codec = HB_ACODEC_DCA;
- break;
- case 0x83: // LPCM
- atype = "PCM";
- audio->config.in.codec = HB_ACODEC_LPCM;
- break;
+ // XXX assume unknown stream types are AC-3 (if they're not
+ // audio we'll find that out during the scan but if they're
+ // some other type of audio we'll end up ignoring them).
+ stype = 0x81;
+ stream->ts_stream_type[1 + aud_pid_index] = 0x81;
}
- audio->id = 0x80bd | (aud_pid_index << 8);
stream->ts_streamid[1 + aud_pid_index] = 0xbd;
- hb_log("transport stream pid 0x%x (type 0x%x) is %s audio id 0x%x",
- stream->ts_audio_pids[aud_pid_index],
- stream->ts_stream_type[1 + aud_pid_index], atype, audio->id);
}
else if ((buf[3] & 0xe0) == 0xc0)
{
- audio->id = buf[3] | aud_pid_index;
- audio->config.in.codec = HB_ACODEC_MPGA;
- hb_log("transport stream pid 0x%x (type 0x%x) is MPEG audio id 0x%x",
- stream->ts_audio_pids[aud_pid_index],
- stream->ts_stream_type[1 + aud_pid_index],
- audio->id);
- stream->ts_stream_type[1 + aud_pid_index] = 0x03;
- stream->ts_streamid[1 + aud_pid_index] = buf[3];
+ audio->id = 0xc0 | aud_pid_index;
+ stype = stream->ts_stream_type[1 + aud_pid_index];
+ if ( st2codec[stype].kind == U )
+ {
+ // XXX assume unknown stream types are MPEG audio
+ stype = 0x03;
+ stream->ts_stream_type[1 + aud_pid_index] = 0x03;
+ }
}
}
- fseeko(stream->file_handle, cur_pos, SEEK_SET);
- if ( audio->config.in.codec )
+ // if we found an audio stream type & HB has a codec that can decode it
+ // finish configuring the audio so we'll add it to the title's list.
+ if ( st2codec[stype].kind == A && st2codec[stype].codec )
{
+ stream->ts_streamid[1 + aud_pid_index] = audio->id;
+ audio->config.in.codec = st2codec[stype].codec;
+ audio->config.in.codec_param = st2codec[stype].codec_param;
set_audio_description( audio,
lang_for_code( stream->a52_info[aud_pid_index].lang_code ) );
+ hb_log("transport stream pid 0x%x (type 0x%x) is %s audio id 0x%x",
+ stream->ts_audio_pids[aud_pid_index],
+ stype, st2codec[stype].name, audio->id);
}
else
{
stream->ts_audio_pids[aud_pid_index],
stream->ts_stream_type[1 + aud_pid_index]);
}
+ fseeko(stream->file_handle, cur_pos, SEEK_SET);
return audio;
}
}
}
-static const char * stream_type_name (uint8_t stream_type)
+static const char *stream_type_name (uint8_t stream_type)
{
- switch( stream_type )
- {
- case 0x01: return("ISO 11172 (MPEG1) Video");
- case 0x02: return("ISO 13818-2 (MPEG2) Video");
- case 0x03: return("ISO 11172 (MPEG1) Audio");
- case 0x04: return("ISO 13818-3 (MPEG2) Audio");
- case 0x05: return("ISO 13818-1 private section");
- case 0x06: return("ISO 13818-1 PES private data");
- case 0x07: return("ISO 13522 MHEG");
- case 0x08: return("ISO 13818-1 DSM-CC");
- case 0x09: return("ISO 13818-1 auxiliary");
- case 0x0a: return("ISO 13818-6 multi-protocol encap");
- case 0x0b: return("ISO 13818-6 DSM-CC U-N msgs");
- case 0x0c: return("ISO 13818-6 Stream descriptors");
- case 0x0d: return("ISO 13818-6 Sections");
- case 0x0e: return("ISO 13818-1 auxiliary");
- case 0x0f: return("ISO 13818-7 AAC Audio");
- case 0x10: return("MPEG4 Video");
- case 0x11: return("MPEG4 Audio");
- case 0x12: return("MPEG4 generic");
-
- case 0x14: return("ISO 13818-6 DSM-CC download");
-
- case 0x1b: return("H.264 Video");
-
- case 0x80: return("DigiCipher II Video");
- case 0x81: return("A52/AC-3 Audio");
- case 0x82: return("HDMV DTS Audio");
- case 0x83: return("LPCM Audio");
- case 0x84: return("SDDS Audio");
- case 0x85: return("ATSC Program ID");
- case 0x86: return("SCTE 35 splice info");
- case 0x87: return("ATSC E-AC-3");
-
- case 0x8a: return("DTS Audio");
-
- case 0x91: return("A52b/AC-3 Audio");
- case 0x92: return("Subtitle");
-
- case 0x94: return("SDDS Audio");
- case 0xa0: return("MSCODEC Video");
-
- case 0xea: return("VC-1 Video");
-
- default: return("Unknown");
- }
+ return st2codec[stream_type].name? st2codec[stream_type].name : "Unknown";
}
int decode_program_map(hb_stream_t* stream)
}
- if (stream->ts_number_video_pids == 0 &&
- ( stream_type == 0x02 || stream_type == 0x10 || stream_type == 0x1B ) )
+ if (stream->ts_number_video_pids == 0 && st2codec[stream_type].kind == V )
{
stream->ts_video_pids[0] = elementary_PID;
stream->ts_stream_type[0] = stream_type;
int len;
// we always ship a PACK header plus all the data in our demux buf.
- // AC3 audio also always needs it substream header.
+ // AC3 audio also always needs its substream header.
len = 14 + stream->ts_pos[curstream];
if ( stream->ts_stream_type[curstream] == 0x81)
{
stream->ts_pos[curstream] = 0;
}
-static int isIframe( const uint8_t *buf, int adapt_len )
+static int isIframe( hb_stream_t *stream, const uint8_t *buf, int adapt_len )
{
- // Look for the Group of Pictures packet
+ // For mpeg2: look for a gop start or i-frame picture start
+ // for h.264: look for idr nal type or a slice header for an i-frame
+ // for vc1: ???
int i;
uint32_t strid = 0;
- for (i = 4 + adapt_len; i < 188; i++)
+
+ if ( stream->ts_stream_type[0] <= 2 )
{
- strid = (strid << 8) | buf[i];
- switch ( strid )
+ // This section of the code handles MPEG-1 and MPEG-2 video streams
+ for (i = 13 + adapt_len; i < 188; i++)
{
- case 0x000001B8: // group_start_code (GOP header)
- case 0x000001B3: // sequence_header code
- return 1;
+ strid = (strid << 8) | buf[i];
+ if ( ( strid >> 8 ) == 1 )
+ {
+ // we found a start code
+ uint8_t id = strid;
+ switch ( id )
+ {
+ case 0xB8: // group_start_code (GOP header)
+ case 0xB3: // sequence_header code
+ return 1;
+
+ case 0x00: // picture_start_code
+ // picture_header, let's see if it's an I-frame
+ if (i<185)
+ {
+ // check if picture_coding_type == 1
+ if ((buf[i+2] & (0x7 << 3)) == (1 << 3))
+ {
+ // found an I-frame picture
+ return 1;
+ }
+ }
+ break;
+ }
+ }
+ }
+ // didn't find an I-frame
+ return 0;
+ }
+ if ( stream->ts_stream_type[0] == 0x1b )
+ {
+ // we have an h.264 stream
+ for (i = 13 + adapt_len; i < 188; i++)
+ {
+ strid = (strid << 8) | buf[i];
+ if ( ( strid >> 8 ) == 1 )
+ {
+ // we found a start code - remove the ref_idc from the nal type
+ uint8_t nal_type = strid & 0x1f;
+ if ( nal_type == 0x05 )
+ // h.264 IDR picture start
+ return 1;
- case 0x00000100: // picture_start_code
- // picture_header, let's see if it's an I-frame
- if (i<185)
+ if ( nal_type == 0x01 )
{
- // check if picture_coding_type == 1
- if ((buf[i+2] & (0x7 << 3)) == (1 << 3))
+ // h.264 slice: has to be start MB 0 & type I (2, 4, 7 or 9)
+ uint8_t id = buf[i+1];
+ if ( ( id >> 4 ) == 0x0b || ( id >> 2 ) == 0x25 ||
+ id == 0x88 || id == 0x8a )
{
- // found an I-frame picture
return 1;
}
}
- break;
+ }
}
+ // didn't find an I-frame
+ return 0;
}
- // didn't find an I frame
- return 0;
+
+ // we don't understand the stream type so just say "yes" otherwise
+ // we'll discard all the video.
+ return 1;
}
/***********************************************************************
{
// video skips to an iframe after a bad packet to minimize
// screen corruption
- if ( curstream == 0 && !isIframe( buf, adapt_len ) )
+ if ( curstream == 0 && !isIframe( stream, buf, adapt_len ) )
{
continue;
}
{
if ( !stream->ts_foundfirst[0] )
{
- if ( stream->ts_stream_type[0] == 2 &&
- !isIframe( buf, adapt_len ) )
+ if ( !isIframe( stream, buf, adapt_len ) )
{
// didn't find an I frame
continue;
}
}
-/***********************************************************************
- * hb_ts_stream_reset
- ***********************************************************************
- *
- **********************************************************************/
static void hb_ts_stream_reset(hb_stream_t *stream)
{
int i;
align_to_next_packet(stream);
}
+// ------------------------------------------------------------------
+// Support for reading media files via the ffmpeg libraries.
+
+static void ffmpeg_add_codec( hb_stream_t *stream, int stream_index )
+{
+ // add a codec to the context here so it will be there when we
+ // read the first packet.
+ AVCodecContext *context = stream->ffmpeg_ic->streams[stream_index]->codec;
+ context->workaround_bugs = FF_BUG_AUTODETECT;
+ context->error_resilience = 1;
+ context->error_concealment = FF_EC_GUESS_MVS|FF_EC_DEBLOCK;
+ AVCodec *codec = avcodec_find_decoder( context->codec_id );
+ avcodec_open( context, codec );
+}
+
+// The ffmpeg stream reader / parser shares a lot of state with the
+// decoder via a codec context kept in the AVStream of the reader's
+// AVFormatContext. Since decoding is done in a different thread we
+// have to somehow pass this codec context to the decoder and we have
+// to do it before the first packet is read (so we can't put the info
+// in the buf we'll send downstream). Decoders don't have any way to
+// get to the stream directly (they're not passed the title or job
+// pointers during a scan) so this is a back door for the decoder to
+// get the codec context. We just stick the stream pointer in the next
+// slot an array of pointers maintained as a circular list then return
+// the index into the list combined with the ffmpeg stream index as the
+// codec_param that will be passed to the decoder init routine. We make
+// the list 'big' (enough for 1024 simultaneously open ffmpeg streams)
+// so that we don't have to do a complicated allocator or worry about
+// deleting entries on close.
+//
+// Entries can only be added to this list during a scan and are never
+// deleted so the list access doesn't require locking.
+static hb_stream_t **ffmpeg_streams; // circular list of stream pointers
+static int ffmpeg_stream_cur; // where we put the last stream pointer
+#define ffmpeg_sl_bits (10) // log2 stream list size (in entries)
+#define ffmpeg_sl_size (1 << ffmpeg_sl_bits)
+
+// add a stream to the list & return the appropriate codec_param to access it
+static int ffmpeg_codec_param( hb_stream_t *stream, int stream_index )
+{
+ if ( !ffmpeg_streams )
+ {
+ ffmpeg_streams = calloc( ffmpeg_sl_size, sizeof(stream) );
+ }
+
+ // the title scan adds all the ffmpeg media streams at once so we
+ // only add a new entry to our stream list if the stream is different
+ // than last time.
+ int slot = ffmpeg_stream_cur;
+ if ( ffmpeg_streams[slot] != stream )
+ {
+ // new stream - put it in the next slot of the stream list
+ slot = ++ffmpeg_stream_cur & (ffmpeg_sl_size - 1);
+ ffmpeg_streams[slot] = stream;
+ }
+
+ ffmpeg_add_codec( stream, stream_index );
+
+ return ( stream_index << ffmpeg_sl_bits ) | slot;
+}
+
+// we're about to open 'title' to convert it - remap the stream associated
+// with the video & audio codec params of the title to refer to 'stream'
+// (the original scan stream was closed and no longer exists).
+static void ffmpeg_remap_stream( hb_stream_t *stream, hb_title_t *title )
+{
+ // all the video & audio came from the same stream so remapping
+ // the video's stream slot takes care of everything.
+ int slot = title->video_codec_param & (ffmpeg_sl_size - 1);
+ ffmpeg_streams[slot] = stream;
+
+ // add codecs for all the streams used by the title
+ ffmpeg_add_codec( stream, title->video_codec_param >> ffmpeg_sl_bits );
+
+ int i;
+ hb_audio_t *audio;
+ for ( i = 0; ( audio = hb_list_item( title->list_audio, i ) ); ++i )
+ {
+ if ( audio->config.in.codec == HB_ACODEC_FFMPEG )
+ {
+ ffmpeg_add_codec( stream,
+ audio->config.in.codec_param >> ffmpeg_sl_bits );
+ }
+ }
+}
+
+void *hb_ffmpeg_context( int codec_param )
+{
+ int slot = codec_param & (ffmpeg_sl_size - 1);
+ int stream_index = codec_param >> ffmpeg_sl_bits;
+ return ffmpeg_streams[slot]->ffmpeg_ic->streams[stream_index]->codec;
+}
+
+void *hb_ffmpeg_avstream( int codec_param )
+{
+ int slot = codec_param & (ffmpeg_sl_size - 1);
+ int stream_index = codec_param >> ffmpeg_sl_bits;
+ return ffmpeg_streams[slot]->ffmpeg_ic->streams[stream_index];
+}
+
+static AVFormatContext *ffmpeg_deferred_close;
+
+static int ffmpeg_open( hb_stream_t *stream, hb_title_t *title )
+{
+ if ( ffmpeg_deferred_close )
+ {
+ av_close_input_file( ffmpeg_deferred_close );
+ ffmpeg_deferred_close = NULL;
+ }
+ AVFormatContext *ic;
+
+ av_log_set_level( AV_LOG_ERROR );
+ if ( av_open_input_file( &ic, stream->path, NULL, 0, NULL ) < 0 )
+ {
+ return 0;
+ }
+ if ( av_find_stream_info( ic ) < 0 )
+ goto fail;
+
+ stream->ffmpeg_ic = ic;
+ stream->hb_stream_type = ffmpeg;
+
+ if ( title )
+ {
+ // we're opening for read. scan passed out codec params that
+ // indexed its stream so we need to remap them so they point
+ // to this stream.
+ ffmpeg_remap_stream( stream, title );
+ ffmpeg_seek( stream, 0. );
+ av_log_set_level( AV_LOG_ERROR );
+ }
+ else
+ {
+ // we're opening for scan. let ffmpeg put some info into the
+ // log about what we've got.
+ av_log_set_level( AV_LOG_INFO );
+ dump_format( ic, 0, stream->path, 0 );
+ av_log_set_level( AV_LOG_ERROR );
+
+ // accept this file if it has at least one video stream we can decode
+ int i;
+ for (i = 0; i < ic->nb_streams; ++i )
+ {
+ if ( ic->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO )
+ {
+ break;
+ }
+ }
+ if ( i >= ic->nb_streams )
+ goto fail;
+ }
+ return 1;
+
+ fail:
+ av_close_input_file( ic );
+ return 0;
+}
+
+static void ffmpeg_close( hb_stream_t *d )
+{
+ // XXX since we're sharing the CodecContext with the downstream
+ // decoder proc we can't close the stream. We need to reference count
+ // this so we can close it when both are done with their instance but
+ // for now just defer the close until the next stream open or close.
+ if ( ffmpeg_deferred_close )
+ {
+ av_close_input_file( ffmpeg_deferred_close );
+ }
+ ffmpeg_deferred_close = d->ffmpeg_ic;
+}
+
+static void add_ffmpeg_audio( hb_title_t *title, hb_stream_t *stream, int id )
+{
+ AVStream *st = stream->ffmpeg_ic->streams[id];
+ AVCodecContext *codec = st->codec;
+
+ // scan will ignore any audio without a bitrate. Since we've already
+ // typed the audio in order to determine its codec we set up the audio
+ // paramters here.
+ if ( codec->bit_rate || codec->sample_rate )
+ {
+ static const int chan2layout[] = {
+ HB_INPUT_CH_LAYOUT_MONO, // We should allow no audio really.
+ HB_INPUT_CH_LAYOUT_MONO,
+ HB_INPUT_CH_LAYOUT_STEREO,
+ HB_INPUT_CH_LAYOUT_2F1R,
+ HB_INPUT_CH_LAYOUT_2F2R,
+ HB_INPUT_CH_LAYOUT_3F2R,
+ HB_INPUT_CH_LAYOUT_4F2R,
+ HB_INPUT_CH_LAYOUT_STEREO,
+ HB_INPUT_CH_LAYOUT_STEREO,
+ };
+
+ hb_audio_t *audio = calloc( 1, sizeof(*audio) );;
+
+ audio->id = id;
+ if ( codec->codec_id == CODEC_ID_AC3 )
+ {
+ audio->config.in.codec = HB_ACODEC_AC3;
+ }
+ else
+ {
+ audio->config.in.codec = HB_ACODEC_FFMPEG;
+ audio->config.in.codec_param = ffmpeg_codec_param( stream, id );
+
+ audio->config.in.bitrate = codec->bit_rate? codec->bit_rate : 1;
+ audio->config.in.samplerate = codec->sample_rate;
+ audio->config.in.channel_layout = chan2layout[codec->channels & 7];
+ }
+
+ set_audio_description( audio, lang_for_code2( st->language ) );
+
+ hb_list_add( title->list_audio, audio );
+ }
+}
+
+static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream )
+{
+ AVFormatContext *ic = stream->ffmpeg_ic;
+
+ // 'Barebones Title'
+ hb_title_t *title = hb_title_init( stream->path, 0 );
+ title->index = 1;
+
+ // Copy part of the stream path to the title name
+ char *sep = strrchr(stream->path, '/');
+ if (sep)
+ strcpy(title->name, sep+1);
+ char *dot_term = strrchr(title->name, '.');
+ if (dot_term)
+ *dot_term = '\0';
+
+ uint64_t dur = ic->duration * 90000 / AV_TIME_BASE;
+ title->duration = dur;
+ dur /= 90000;
+ title->hours = dur / 3600;
+ title->minutes = ( dur % 3600 ) / 60;
+ title->seconds = dur % 60;
+
+ // One Chapter
+ hb_chapter_t * chapter;
+ chapter = calloc( sizeof( hb_chapter_t ), 1 );
+ chapter->index = 1;
+ chapter->duration = title->duration;
+ chapter->hours = title->hours;
+ chapter->minutes = title->minutes;
+ chapter->seconds = title->seconds;
+ hb_list_add( title->list_chapter, chapter );
+
+ // set the title to decode the first video stream in the file
+ title->demuxer = HB_NULL_DEMUXER;
+ title->video_codec = 0;
+ int i;
+ for (i = 0; i < ic->nb_streams; ++i )
+ {
+ if ( ic->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO &&
+ avcodec_find_decoder( ic->streams[i]->codec->codec_id ) &&
+ title->video_codec == 0 )
+ {
+ title->video_id = i;
+
+ // We have to use the 'internal' avcodec decoder because
+ // it needs to share the codec context from this video
+ // stream. The parser internal to av_read_frame
+ // passes a bunch of state info to the decoder via the context.
+ title->video_codec = WORK_DECAVCODECVI;
+ title->video_codec_param = ffmpeg_codec_param( stream, i );
+ }
+ else if ( ic->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO &&
+ avcodec_find_decoder( ic->streams[i]->codec->codec_id ) )
+ {
+ add_ffmpeg_audio( title, stream, i );
+ }
+ }
+
+ return title;
+}
+
+static int64_t av_to_hb_pts( int64_t pts, double conv_factor )
+{
+ if ( pts == AV_NOPTS_VALUE )
+ return -1;
+ return (int64_t)( (double)pts * conv_factor );
+}
+
+static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf )
+{
+ AVPacket pkt;
+
+ if ( av_read_frame( stream->ffmpeg_ic, &pkt ) < 0 )
+ {
+ return 0;
+ }
+ if ( pkt.size > buf->alloc )
+ {
+ // need to expand buffer
+ hb_buffer_realloc( buf, pkt.size );
+ }
+ memcpy( buf->data, pkt.data, pkt.size );
+ buf->id = pkt.stream_index;
+ buf->size = pkt.size;
+ int64_t pts = pkt.pts != AV_NOPTS_VALUE? pkt.pts :
+ pkt.dts != AV_NOPTS_VALUE? pkt.dts : -1;
+ buf->start = av_to_hb_pts( pts,
+ av_q2d(stream->ffmpeg_ic->streams[pkt.stream_index]->time_base)*90000. );
+ buf->renderOffset = av_to_hb_pts( pkt.pts,
+ av_q2d(stream->ffmpeg_ic->streams[pkt.stream_index]->time_base)*90000. );
+ av_free_packet( &pkt );
+ return 1;
+}
+
+static int ffmpeg_seek( hb_stream_t *stream, float frac )
+{
+ AVFormatContext *ic = stream->ffmpeg_ic;
+ int64_t pos = (double)ic->duration * (double)frac;
+ av_seek_frame( ic, -1, pos, pos? 0 : AVSEEK_FLAG_BACKWARD );
+ return 1;
+}
#include <stdio.h>
#include "samplerate.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
#ifdef INT64_MIN
#undef INT64_MIN /* Because it isn't defined correctly in Zeta */
{
if ( (int64_t)( buf->start - sync->next_pts ) < 0 )
{
- /*
- * audio time went backwards by more than a frame time (this can
- * happen when we reset the PTS because of lost data).
- * Discard data that's in the past.
- */
- if ( sync->first_drop == 0 )
+ // audio time went backwards.
+ // If our output clock is more than a half frame ahead of the
+ // input clock drop this frame to move closer to sync.
+ // Otherwise drop frames until the input clock matches the output clock.
+ if ( sync->first_drop || sync->next_start - buf->start > 90*15 )
{
- sync->first_drop = buf->start;
+ // Discard data that's in the past.
+ if ( sync->first_drop == 0 )
+ {
+ sync->first_drop = sync->next_pts;
+ }
+ ++sync->drop_count;
+ buf = hb_fifo_get( audio->priv.fifo_raw );
+ hb_buffer_close( &buf );
+ continue;
}
- ++sync->drop_count;
- buf = hb_fifo_get( audio->priv.fifo_raw );
- hb_buffer_close( &buf );
- continue;
+ sync->next_pts = buf->start;
}
if ( sync->first_drop )
{
+ // we were dropping old data but input buf time is now current
hb_log( "sync: audio %d time went backwards %d ms, dropped %d frames "
"(next %lld, current %lld)", i,
(int)( sync->next_pts - sync->first_drop ) / 90,
sync->drop_count, sync->first_drop, sync->next_pts );
sync->first_drop = 0;
sync->drop_count = 0;
+ sync->next_pts = buf->start;
}
if ( buf->start - sync->next_pts >= (90 * 70) )
{
free( work );
}
-static hb_work_object_t * getWork( int id )
+hb_work_object_t * hb_get_work( int id )
{
hb_work_object_t * w;
for( w = hb_objects; w; w = w->next )
{
if( w->id == id )
{
- return w;
+ hb_work_object_t *wc = malloc( sizeof(*w) );
+ *wc = *w;
+ return wc;
}
}
return NULL;
}
+hb_work_object_t * hb_codec_decoder( int codec )
+{
+ switch( codec )
+ {
+ case HB_ACODEC_AC3: return hb_get_work( WORK_DECA52 );
+ case HB_ACODEC_DCA: return hb_get_work( WORK_DECDCA );
+ case HB_ACODEC_MPGA: return hb_get_work( WORK_DECAVCODEC );
+ case HB_ACODEC_LPCM: return hb_get_work( WORK_DECLPCM );
+ case HB_ACODEC_FFMPEG: return hb_get_work( WORK_DECAVCODECAI );
+ }
+ return NULL;
+}
+
+hb_work_object_t * hb_codec_encoder( int codec )
+{
+ switch( codec )
+ {
+ case HB_ACODEC_FAAC: return hb_get_work( WORK_ENCFAAC );
+ case HB_ACODEC_LAME: return hb_get_work( WORK_ENCLAME );
+ case HB_ACODEC_VORBIS: return hb_get_work( WORK_ENCVORBIS );
+ }
+ return NULL;
+}
+
/**
* Job initialization rountine.
* Initializes fifos.
hb_title_t * title;
int i, j;
hb_work_object_t * w;
-
- /* FIXME: This feels really hackish, anything better? */
- hb_work_object_t * audio_w = NULL;
- hb_work_object_t * sub_w = NULL;
hb_work_object_t * final_w = NULL;
hb_audio_t * audio;
job->fifo_mpeg4 = hb_fifo_init( FIFO_CPU_MULT * cpu_count );
/* Synchronization */
- hb_list_add( job->list_work, ( w = getWork( WORK_SYNC ) ) );
+ hb_list_add( job->list_work, ( w = hb_get_work( WORK_SYNC ) ) );
w->fifo_in = NULL;
w->fifo_out = NULL;
/* Video decoder */
- hb_list_add( job->list_work, ( w = getWork( WORK_DECMPEG2 ) ) );
+ int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2;
+ hb_list_add( job->list_work, ( w = hb_get_work( vcodec ) ) );
+ w->codec_param = title->video_codec_param;
w->fifo_in = job->fifo_mpeg2;
w->fifo_out = job->fifo_raw;
/* Video renderer */
- hb_list_add( job->list_work, ( w = getWork( WORK_RENDER ) ) );
+ hb_list_add( job->list_work, ( w = hb_get_work( WORK_RENDER ) ) );
w->fifo_in = job->fifo_sync;
w->fifo_out = job->fifo_render;
if ( job->indepth_scan )
{
case HB_VCODEC_FFMPEG:
hb_log( " + encoder FFmpeg" );
- w = getWork( WORK_ENCAVCODEC );
+ w = hb_get_work( WORK_ENCAVCODEC );
break;
case HB_VCODEC_XVID:
hb_log( " + encoder XviD" );
- w = getWork( WORK_ENCXVID );
+ w = hb_get_work( WORK_ENCXVID );
break;
case HB_VCODEC_X264:
hb_log( " + encoder x264" );
if( job->x264opts != NULL && *job->x264opts != '\0' )
hb_log( " + x264 options: %s", job->x264opts);
- w = getWork( WORK_ENCX264 );
+ w = hb_get_work( WORK_ENCX264 );
break;
case HB_VCODEC_THEORA:
hb_log( " + encoder Theora" );
- w = getWork( WORK_ENCTHEORA );
+ w = hb_get_work( WORK_ENCTHEORA );
break;
}
w->fifo_in = job->fifo_render;
* Don't add threads for subtitles when we are scanning, unless
* looking for forced subtitles.
*/
- if( sub_w != NULL )
- {
- /*
- * Need to copy the prior subtitle structure so that we
- * don't overwrite the fifos.
- */
- sub_w = calloc( sizeof( hb_work_object_t ), 1 );
- sub_w = memcpy( sub_w, w, sizeof( hb_work_object_t ));
- } else {
- w = sub_w = getWork( WORK_DECSUB );
- }
- hb_list_add( job->list_work, sub_w );
- sub_w->fifo_in = subtitle->fifo_in;
- sub_w->fifo_out = subtitle->fifo_raw;
+ w = hb_get_work( WORK_DECSUB );
+ w->fifo_in = subtitle->fifo_in;
+ w->fifo_out = subtitle->fifo_raw;
+ hb_list_add( job->list_work, w );
}
}
}
/* sense-check the requested mixdown */
- if( audio->config.out.mixdown == 0 && audio->config.out.codec != HB_ACODEC_AC3 )
+ if( audio->config.out.mixdown == 0 &&
+ audio->config.out.codec != HB_ACODEC_AC3 )
+ {
+ /*
+ * Mixdown wasn't specified and this is not pass-through,
+ * set a default mixdown of stereo.
+ */
+ audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
+ }
+
+ // Here we try to sanitize the audio input to output mapping.
+ // Constraints are:
+ // 1. only the AC3 & DCA decoder libraries currently support mixdown
+ // 2. the lame encoder library only supports stereo.
+ // So if the encoder is lame we need the output to be stereo (or multichannel
+ // matrixed into stereo like dpl). If the decoder is not AC3 or DCA the
+ // encoder has to handle the input format since we can't do a mixdown.
+#define CAN_MIXDOWN(a) ( a->config.in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA) )
+#define STEREO_ONLY(a) ( a->config.out.codec & HB_ACODEC_LAME )
+
+ switch (audio->config.in.channel_layout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK)
+ {
+ // stereo input or something not handled below
+ default:
+ case HB_INPUT_CH_LAYOUT_STEREO:
+ // mono gets mixed up to stereo & more than stereo gets mixed down
+ if ( STEREO_ONLY( audio ) ||
+ audio->config.out.mixdown > HB_AMIXDOWN_STEREO)
{
- /*
- * Mixdown wasn't specified and this is not pass-through, set a default mixdown
- * of stereo.
- */
audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
}
+ break;
- /* audioCodecsSupportMono and audioCodecsSupport6Ch are the same for now,
- but this may change in the future, so they are separated for flexibility */
- int audioCodecsSupportMono = ( (audio->config.in.codec == HB_ACODEC_AC3 || audio->config.in.codec == HB_ACODEC_DCA) &&
- (audio->config.out.codec == HB_ACODEC_FAAC || audio->config.out.codec == HB_ACODEC_VORBIS) );
- int audioCodecsSupport6Ch = ( (audio->config.in.codec == HB_ACODEC_AC3 || audio->config.in.codec == HB_ACODEC_DCA) &&
- (audio->config.out.codec == HB_ACODEC_FAAC || audio->config.out.codec == HB_ACODEC_VORBIS));
-
- /* find out what the format of our source audio is */
- switch (audio->config.in.channel_layout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK) {
-
- /* mono sources */
+ // mono input
case HB_INPUT_CH_LAYOUT_MONO:
- /* regardless of what stereo mixdown we've requested, a mono source always get mixed down
- to mono if we can, and mixed up to stereo if we can't */
- if (audio->config.out.mixdown == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 1) {
- audio->config.out.mixdown = HB_AMIXDOWN_MONO;
- } else {
+ if ( STEREO_ONLY( audio ) )
+ {
+ if ( !CAN_MIXDOWN( audio ) )
+ {
+ // XXX we're hosed - we can't mix up & lame can't handle
+ // the input format. The user shouldn't be able to make
+ // this choice. It's too late to do anything about it now
+ // so complain in the log & let things abort in lame.
+ hb_log( "ERROR - can't use lame mp3 audio output with "
+ "mono audio stream %x - output will be messed up",
+ audio->id );
+ }
audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
}
- break;
-
- /* stereo input */
- case HB_INPUT_CH_LAYOUT_STEREO:
- /* if we've requested a mono mixdown, and it is supported, then do the mix */
- /* use stereo if not supported */
- if (audio->config.out.mixdown == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 0) {
- audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
- /* otherwise, preserve stereo regardless of if we requested something higher */
- } else if (audio->config.out.mixdown > HB_AMIXDOWN_STEREO) {
- audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
+ else
+ {
+ // everything else passes through
+ audio->config.out.mixdown = HB_AMIXDOWN_MONO;
}
break;
- /* dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input */
- /* the A52 flags don't allow for a way to distinguish between DPL1 and DPL2 on a DVD,
- so we always assume a DPL1 source for A52_DOLBY */
+ // dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input
+ // the A52 flags don't allow for a way to distinguish between DPL1 and
+ // DPL2 on a DVD so we always assume a DPL1 source for A52_DOLBY.
case HB_INPUT_CH_LAYOUT_DOLBY:
- /* if we've requested a mono mixdown, and it is supported, then do the mix */
- /* preserve dolby if not supported */
- if (audio->config.out.mixdown == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 0) {
- audio->config.out.mixdown = HB_AMIXDOWN_DOLBY;
- /* otherwise, preserve dolby even if we requested something higher */
- /* a stereo mixdown will still be honoured here */
- } else if (audio->config.out.mixdown > HB_AMIXDOWN_DOLBY) {
+ if ( STEREO_ONLY( audio ) || !CAN_MIXDOWN( audio ) ||
+ audio->config.out.mixdown > HB_AMIXDOWN_DOLBY )
+ {
audio->config.out.mixdown = HB_AMIXDOWN_DOLBY;
}
break;
- /* 3F/2R input */
+ // 4 channel discrete
+ case HB_INPUT_CH_LAYOUT_2F2R:
+ case HB_INPUT_CH_LAYOUT_3F1R:
+ if ( CAN_MIXDOWN( audio ) )
+ {
+ if ( STEREO_ONLY( audio ) ||
+ audio->config.out.mixdown > HB_AMIXDOWN_DOLBY )
+ {
+ audio->config.out.mixdown = HB_AMIXDOWN_DOLBY;
+ }
+ }
+ else
+ {
+ // XXX we can't mixdown & don't have any way to specify
+ // 4 channel discrete output so we're hosed.
+ hb_log( "ERROR - can't handle 4 channel discrete audio stream "
+ "%x - output will be messed up", audio->id );
+ }
+ break;
+
+ // 5 or 6 channel discrete
case HB_INPUT_CH_LAYOUT_3F2R:
- /* if we've requested a mono mixdown, and it is supported, then do the mix */
- /* use dpl2 if not supported */
- if (audio->config.out.mixdown == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 0) {
- audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII;
- } else {
- /* check if we have 3F2R input and also have an LFE - i.e. we have a 5.1 source) */
- if (audio->config.in.channel_layout & HB_INPUT_CH_LAYOUT_HAS_LFE) {
- /* we have a 5.1 source */
- /* if we requested 6ch, but our audio format doesn't support it, then mix to DPLII instead */
- if (audio->config.out.mixdown == HB_AMIXDOWN_6CH && audioCodecsSupport6Ch == 0) {
- audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII;
+ if ( CAN_MIXDOWN( audio ) )
+ {
+ if ( STEREO_ONLY( audio ) )
+ {
+ if ( audio->config.out.mixdown < HB_AMIXDOWN_STEREO )
+ {
+ audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
}
- } else {
- /* we have a 5.0 source, so we can't do 6ch conversion
- default to DPL II instead */
- if (audio->config.out.mixdown > HB_AMIXDOWN_DOLBYPLII) {
+ else if ( audio->config.out.mixdown > HB_AMIXDOWN_DOLBYPLII )
+ {
audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII;
}
}
- }
- /* all other mixdowns will have been preserved here */
- break;
-
- /* 3F/1R input */
- case HB_INPUT_CH_LAYOUT_3F1R:
- /* if we've requested a mono mixdown, and it is supported, then do the mix */
- /* use dpl1 if not supported */
- if (audio->config.out.mixdown == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 0) {
- audio->config.out.mixdown = HB_AMIXDOWN_DOLBY;
- } else {
- /* we have a 4.0 or 4.1 source, so we can't do DPLII or 6ch conversion
- default to DPL I instead */
- if (audio->config.out.mixdown > HB_AMIXDOWN_DOLBY) {
- audio->config.out.mixdown = HB_AMIXDOWN_DOLBY;
+ else if ( ! ( audio->config.in.channel_layout &
+ HB_INPUT_CH_LAYOUT_HAS_LFE ) )
+ {
+ // we don't do 5 channel discrete so mixdown to DPLII
+ audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII;
}
}
- /* all other mixdowns will have been preserved here */
- break;
-
- default:
- /* if we've requested a mono mixdown, and it is supported, then do the mix */
- if (audio->config.out.mixdown == HB_AMIXDOWN_MONO && audioCodecsSupportMono == 1) {
- audio->config.out.mixdown = HB_AMIXDOWN_MONO;
- /* mix everything else down to stereo */
- } else {
- audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
+ else if ( ! ( audio->config.in.channel_layout &
+ HB_INPUT_CH_LAYOUT_HAS_LFE ) )
+ {
+ // XXX we can't mixdown & don't have any way to specify
+ // 5 channel discrete output so we're hosed.
+ hb_log( "ERROR - can't handle 5 channel discrete audio stream "
+ "%x - output will be messed up", audio->id );
}
-
+ else
+ {
+ // we can't mixdown so force 6 channel discrete
+ audio->config.out.mixdown = HB_AMIXDOWN_6CH;
+ }
+ break;
}
/* log the output mixdown */
/*
* Audio Decoder Thread
*/
- switch( audio->config.in.codec )
+ if ( ( w = hb_codec_decoder( audio->config.in.codec ) ) == NULL )
{
- case HB_ACODEC_AC3:
- w = getWork( WORK_DECA52 );
- break;
- case HB_ACODEC_DCA:
- w = getWork( WORK_DECDCA );
- break;
- case HB_ACODEC_MPGA:
- w = getWork( WORK_DECAVCODEC );
- break;
- case HB_ACODEC_LPCM:
- w = getWork( WORK_DECLPCM );
- break;
- default:
- /* Invalid input codec */
- hb_error("Invalid input codec: %d", audio->config.in.codec);
- *job->die = 1;
- goto cleanup;
+ hb_error("Invalid input codec: %d", audio->config.in.codec);
+ *job->die = 1;
+ goto cleanup;
}
- w->fifo_in = audio->priv.fifo_in;
- w->fifo_out = audio->priv.fifo_raw;
- w->config = &audio->priv.config;
- w->audio = audio;
+ w->fifo_in = audio->priv.fifo_in;
+ w->fifo_out = audio->priv.fifo_raw;
+ w->config = &audio->priv.config;
+ w->audio = audio;
+ w->codec_param = audio->config.in.codec_param;
- /* FIXME: This feels really hackish, anything better? */
- audio_w = calloc( sizeof( hb_work_object_t ), 1 );
- audio_w = memcpy( audio_w, w, sizeof( hb_work_object_t ));
-
- hb_list_add( job->list_work, audio_w );
+ hb_list_add( job->list_work, w );
/*
* Audio Encoder Thread
*/
- switch( audio->config.out.codec )
- {
- case HB_ACODEC_FAAC:
- w = getWork( WORK_ENCFAAC );
- break;
- case HB_ACODEC_LAME:
- w = getWork( WORK_ENCLAME );
- break;
- case HB_ACODEC_VORBIS:
- w = getWork( WORK_ENCVORBIS );
- break;
- case HB_ACODEC_AC3:
- break;
- case HB_ACODEC_DCA: /* These are all invalid output codecs. */
- default:
- hb_error("Invalid audio codec: %#x", audio->config.out.codec);
- w = NULL;
- *job->die = 1;
- goto cleanup;
- }
-
if( audio->config.out.codec != HB_ACODEC_AC3 )
{
/*
* Add the encoder thread if not doing AC-3 pass through
*/
- w->fifo_in = audio->priv.fifo_sync;
- w->fifo_out = audio->priv.fifo_out;
- w->config = &audio->priv.config;
- w->audio = audio;
-
- /* FIXME: This feels really hackish, anything better? */
- audio_w = calloc( sizeof( hb_work_object_t ), 1 );
- audio_w = memcpy( audio_w, w, sizeof( hb_work_object_t ));
+ if ( ( w = hb_codec_encoder( audio->config.out.codec ) ) == NULL )
+ {
+ hb_error("Invalid audio codec: %#x", audio->config.out.codec);
+ w = NULL;
+ *job->die = 1;
+ goto cleanup;
+ }
+ w->fifo_in = audio->priv.fifo_sync;
+ w->fifo_out = audio->priv.fifo_out;
+ w->config = &audio->priv.config;
+ w->audio = audio;
- hb_list_add( job->list_work, audio_w );
+ hb_list_add( job->list_work, w );
}
-
-
}
/* Init read & write threads */
}
hb_list_rem( job->list_work, w );
w->close( w );
+ free( w );
job->done = 1;
cleanup:
while( ( w = hb_list_item( job->list_work, 0 ) ) )
{
hb_list_rem( job->list_work, w );
- if( w != NULL && w->thread != NULL )
+ if( w->thread != NULL )
{
hb_thread_close( &w->thread );
w->close( w );
}
-
- /* FIXME: This feels really hackish, anything better? */
- if ( w->id == WORK_DECA52 ||
- w->id == WORK_DECDCA ||
- w->id == WORK_DECLPCM ||
- w->id == WORK_ENCFAAC ||
- w->id == WORK_ENCLAME ||
- w->id == WORK_ENCVORBIS )
- {
- free( w );
- w = NULL;
- }
+ free( w );
}
hb_list_close( &job->list_work );
}
/**
- * Performs the work objects specific work function.
+ * Performs the work object's specific work function.
* Loops calling work function for associated work object. Sleeps when fifo is full.
* Monitors work done indicator.
* Exits loop when work indiactor is set.
as they are the only libraries able to do the mixdown to mono / conversion to 6-ch */
/* audioCodecsSupportMono and audioCodecsSupport6Ch are the same for now,
but this may change in the future, so they are separated for flexibility */
- int audioCodecsSupportMono = ((audio->in.codec == HB_ACODEC_AC3 ||
- audio->in.codec == HB_ACODEC_DCA) && acodec == HB_ACODEC_FAAC);
- int audioCodecsSupport6Ch = ((audio->in.codec == HB_ACODEC_AC3 ||
- audio->in.codec == HB_ACODEC_DCA) && (acodec == HB_ACODEC_FAAC ||
- acodec == HB_ACODEC_VORBIS));
+ int audioCodecsSupportMono =
+ (audio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) &&
+ (acodec != HB_ACODEC_LAME);
+ int audioCodecsSupport6Ch =
+ (audio->in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA)) &&
+ (acodec != HB_ACODEC_LAME);
/* check for AC-3 passthru */
if (audio->in.codec == HB_ACODEC_AC3 && acodec == HB_ACODEC_AC3)
OSDN Git Service
