* mp4.c : MP4 file input module for vlc
*****************************************************************************
* Copyright (C) 2001-2004, 2010 the VideoLAN team
- * $Id$
+ *
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
* This program is free software; you can redistribute it and/or modify
#include <vlc_common.h>
#include <vlc_plugin.h>
-
#include <vlc_demux.h>
-#include <vlc_md5.h>
-#include <vlc_charset.h>
-#include <vlc_iso_lang.h>
-#include <vlc_meta.h>
+#include <vlc_charset.h> /* EnsureUTF8 */
+#include <vlc_meta.h> /* vlc_meta_t, vlc_meta_ */
#include <vlc_input.h>
#include "libmp4.h"
-#include "drms.h"
-#include "id3genres.h"
+#include "id3genres.h" /* for ATOM_gnre */
/*****************************************************************************
* Module descriptor
set_subcategory( SUBCAT_INPUT_DEMUX )
set_description( N_("MP4 stream demuxer") )
set_shortname( N_("MP4") )
- set_capability( "demux", 242 )
+ set_capability( "demux", 240 )
set_callbacks( Open, Close )
vlc_module_end ()
/* display size only ! */
int i_width;
int i_height;
+ float f_rotation;
/* more internal data */
uint64_t i_timescale; /* time scale for this track only */
MP4_Box_t *p_stsd; /* will contain all data to initialize decoder */
MP4_Box_t *p_sample;/* point on actual sdsd */
- bool b_drms;
- void *p_drms;
MP4_Box_t *p_skcr;
} mp4_track_t;
switch( VLC_FOURCC( p_peek[4], p_peek[5], p_peek[6], p_peek[7] ) )
{
- case FOURCC_ftyp:
- case FOURCC_moov:
- case FOURCC_foov:
- case FOURCC_moof:
- case FOURCC_mdat:
- case FOURCC_udta:
- case FOURCC_free:
- case FOURCC_skip:
- case FOURCC_wide:
+ case ATOM_ftyp:
+ case ATOM_moov:
+ case ATOM_foov:
+ case ATOM_moof:
+ case ATOM_mdat:
+ case ATOM_udta:
+ case ATOM_free:
+ case ATOM_skip:
+ case ATOM_wide:
case VLC_FOURCC( 'p', 'n', 'o', 't' ):
break;
default:
{
switch( p_ftyp->data.p_ftyp->i_major_brand )
{
- case( FOURCC_isom ):
+ case( ATOM_isom ):
msg_Dbg( p_demux,
"ISO Media file (isom) version %d.",
p_ftyp->data.p_ftyp->i_minor_version );
break;
+ case( ATOM_3gp4 ):
+ case( VLC_FOURCC( '3', 'g', 'p', '5' ) ):
+ case( VLC_FOURCC( '3', 'g', 'p', '6' ) ):
+ case( VLC_FOURCC( '3', 'g', 'p', '7' ) ):
+ msg_Dbg( p_demux, "3GPP Media file Release: %c",
+#ifdef WORDS_BIGENDIAN
+ p_ftyp->data.p_ftyp->i_major_brand
+#else
+ p_ftyp->data.p_ftyp->i_major_brand >> 24
+#endif
+ );
+ break;
+ case( VLC_FOURCC( 'q', 't', ' ', ' ') ):
+ msg_Dbg( p_demux, "Apple QuickTime file" );
+ break;
+ case( VLC_FOURCC( 'i', 's', 'm', 'l') ):
+ msg_Dbg( p_demux, "PIFF (= isml = fMP4) file" );
+ break;
default:
msg_Dbg( p_demux,
"unrecognized major file specification (%4.4s).",
if( !p_foov )
{
- msg_Err( p_demux, "MP4 plugin discarded (no moov box)" );
- goto error;
+ /* search also for moof box used by smoothstreaming */
+ p_foov = MP4_BoxGet( p_sys->p_root, "/moof" );
+ if( !p_foov )
+ {
+ msg_Err( p_demux, "MP4 plugin discarded (no moov,foov,moof box)" );
+ goto error;
+ }
}
/* we have a free box as a moov, rename it */
- p_foov->i_type = FOURCC_moov;
+ p_foov->i_type = ATOM_moov;
}
if( ( p_rmra = MP4_BoxGet( p_sys->p_root, "/moov/rmra" ) ) )
free( psz_path );
}
msg_Dbg( p_demux, "adding ref = `%s'", psz_ref );
- input_item_t *p_input = input_item_New( p_demux, psz_ref, NULL );
- input_item_CopyOptions( p_current, p_input );
- input_item_node_AppendItem( p_subitems, p_input );
- vlc_gc_decref( p_input );
+ input_item_t *p_item = input_item_New( psz_ref, NULL );
+ input_item_CopyOptions( p_current, p_item );
+ input_item_node_AppendItem( p_subitems, p_item );
+ vlc_gc_decref( p_item );
}
else
{
p_sys->track = calloc( p_sys->i_tracks, sizeof( mp4_track_t ) );
if( p_sys->track == NULL )
goto error;
- memset( p_sys->track, 0, p_sys->i_tracks * sizeof( mp4_track_t ) );
/* Search the first chap reference (like quicktime) and
* check that at least 1 stream is enabled */
break;
}
- if( tk->b_drms && tk->p_drms )
- {
- if( tk->p_skcr )
- {
- uint32_t p_key[4];
- drms_get_p_key( tk->p_drms, p_key );
-
- for( size_t i_pos = tk->p_skcr->data.p_skcr->i_init; i_pos < p_block->i_buffer; )
- {
- int n = __MIN( tk->p_skcr->data.p_skcr->i_encr, p_block->i_buffer - i_pos );
- drms_decrypt( tk->p_drms, (uint32_t*)&p_block->p_buffer[i_pos], n, p_key );
- i_pos += n;
- i_pos += __MIN( tk->p_skcr->data.p_skcr->i_decr, p_block->i_buffer - i_pos );
- }
- }
- else
- {
- drms_decrypt( tk->p_drms, (uint32_t*)p_block->p_buffer,
- p_block->i_buffer, NULL );
- }
- }
else if( tk->fmt.i_cat == SPU_ES )
{
- if( tk->fmt.i_codec == VLC_FOURCC( 's', 'u', 'b', 't' ) &&
+ if( tk->fmt.i_codec == VLC_CODEC_SUBT &&
p_block->i_buffer >= 2 )
{
- uint16_t i_size = GetWBE( p_block->p_buffer );
+ size_t i_size = GetWBE( p_block->p_buffer );
if( i_size + 2 <= p_block->i_buffer )
{
else
p_block->i_pts = VLC_TS_INVALID;
- if( !tk->b_drms || ( tk->b_drms && tk->p_drms ) )
- es_out_Send( p_demux->out, tk->p_es, p_block );
+ es_out_Send( p_demux->out, tk->p_es, p_block );
}
/* Next sample */
/* XXX Becarefull p_udta can have box that are not 0xa9xx */
switch( p_0xa9xxx->i_type )
{
- case FOURCC_0xa9nam: /* Full name */
+ case ATOM_0xa9nam: /* Full name */
SET( vlc_meta_SetTitle );
break;
- case FOURCC_0xa9aut:
+ case ATOM_0xa9aut:
SET( vlc_meta_SetArtist );
break;
- case FOURCC_0xa9ART:
+ case ATOM_0xa9ART:
SET( vlc_meta_SetArtist );
break;
- case FOURCC_0xa9cpy:
+ case ATOM_0xa9cpy:
SET( vlc_meta_SetCopyright );
break;
- case FOURCC_0xa9day: /* Creation Date */
+ case ATOM_0xa9day: /* Creation Date */
SET( vlc_meta_SetDate );
break;
- case FOURCC_0xa9des: /* Description */
+ case ATOM_0xa9des: /* Description */
SET( vlc_meta_SetDescription );
break;
- case FOURCC_0xa9gen: /* Genre */
+ case ATOM_0xa9gen: /* Genre */
SET( vlc_meta_SetGenre );
break;
- case FOURCC_gnre:
+ case ATOM_gnre:
if( p_0xa9xxx->data.p_gnre->i_genre <= NUM_GENRES )
vlc_meta_SetGenre( p_meta, ppsz_genres[p_0xa9xxx->data.p_gnre->i_genre - 1] );
break;
- case FOURCC_0xa9alb: /* Album */
+ case ATOM_0xa9alb: /* Album */
SET( vlc_meta_SetAlbum );
break;
- case FOURCC_0xa9trk: /* Track */
+ case ATOM_0xa9trk: /* Track */
SET( vlc_meta_SetTrackNum );
break;
- case FOURCC_trkn:
+ case ATOM_trkn:
{
char psz_trck[11];
snprintf( psz_trck, sizeof( psz_trck ), "%i",
vlc_meta_SetTrackNum( p_meta, psz_trck );
break;
}
- case FOURCC_0xa9cmt: /* Commment */
+ case ATOM_0xa9cmt: /* Commment */
SET( vlc_meta_SetDescription );
break;
- case FOURCC_0xa9url: /* URL */
+ case ATOM_0xa9url: /* URL */
SET( vlc_meta_SetURL );
break;
- case FOURCC_0xa9too: /* Encoder Tool */
- case FOURCC_0xa9enc: /* Encoded By */
+ case ATOM_0xa9too: /* Encoder Tool */
+ case ATOM_0xa9enc: /* Encoded By */
SET( vlc_meta_SetEncodedBy );
break;
#undef SET
static const struct { uint32_t xa9_type; char metadata[25]; } xa9typetoextrameta[] =
{
- { FOURCC_0xa9wrt, N_("Writer") },
- { FOURCC_0xa9com, N_("Composr") },
- { FOURCC_0xa9prd, N_("Producer") },
- { FOURCC_0xa9inf, N_("Information") },
- { FOURCC_0xa9dir, N_("Director") },
- { FOURCC_0xa9dis, N_("Disclaimer") },
- { FOURCC_0xa9req, N_("Requirements") },
- { FOURCC_0xa9fmt, N_("Original Format") },
- { FOURCC_0xa9dsa, N_("Display Source As") },
- { FOURCC_0xa9hst, N_("Host Computer") },
- { FOURCC_0xa9prf, N_("Performers") },
- { FOURCC_0xa9ope, N_("Original Performer") },
- { FOURCC_0xa9src, N_("Providers Source Content") },
- { FOURCC_0xa9wrn, N_("Warning") },
- { FOURCC_0xa9swr, N_("Software") },
- { FOURCC_0xa9lyr, N_("Lyrics") },
- { FOURCC_0xa9mak, N_("Make") },
- { FOURCC_0xa9mod, N_("Model") },
- { FOURCC_0xa9PRD, N_("Product") },
- { FOURCC_0xa9grp, N_("Grouping") },
+ { ATOM_0xa9wrt, N_("Writer") },
+ { ATOM_0xa9com, N_("Composer") },
+ { ATOM_0xa9prd, N_("Producer") },
+ { ATOM_0xa9inf, N_("Information") },
+ { ATOM_0xa9dir, N_("Director") },
+ { ATOM_0xa9dis, N_("Disclaimer") },
+ { ATOM_0xa9req, N_("Requirements") },
+ { ATOM_0xa9fmt, N_("Original Format") },
+ { ATOM_0xa9dsa, N_("Display Source As") },
+ { ATOM_0xa9hst, N_("Host Computer") },
+ { ATOM_0xa9prf, N_("Performers") },
+ { ATOM_0xa9ope, N_("Original Performer") },
+ { ATOM_0xa9src, N_("Providers Source Content") },
+ { ATOM_0xa9wrn, N_("Warning") },
+ { ATOM_0xa9swr, N_("Software") },
+ { ATOM_0xa9lyr, N_("Lyrics") },
+ { ATOM_0xa9mak, N_("Make") },
+ { ATOM_0xa9mod, N_("Model") },
+ { ATOM_0xa9PRD, N_("Product") },
+ { ATOM_0xa9grp, N_("Grouping") },
{ 0, "" },
};
for( unsigned i = 0; xa9typetoextrameta[i].xa9_type; i++ )
case DEMUX_SET_GROUP:
case DEMUX_HAS_UNSUPPORTED_META:
case DEMUX_GET_ATTACHMENTS:
+ case DEMUX_GET_PTS_DELAY:
+ case DEMUX_CAN_RECORD:
return VLC_EGENERIC;
default:
{
mp4_track_t *tk = &p_sys->track[j];
if( tk->b_ok && tk->i_track_ID == p_chap->i_track_ID[i] &&
- tk->fmt.i_cat == SPU_ES && tk->fmt.i_codec == VLC_FOURCC( 's', 'u', 'b', 't' ) )
+ tk->fmt.i_cat == SPU_ES && tk->fmt.i_codec == VLC_CODEC_SUBT )
break;
}
if( j < p_sys->i_tracks )
}
}
}
+
+ /* Add duration if titles are enabled */
+ if( p_sys->p_title )
+ {
+ p_sys->p_title->i_length = (uint64_t)1000000 *
+ (uint64_t)p_sys->i_duration / (uint64_t)p_sys->i_timescale;
+ }
}
/* now create basic chunk data, the rest will be filled by MP4_CreateSamplesIndex */
MP4_Box_t *p_esds;
MP4_Box_t *p_frma;
MP4_Box_t *p_enda;
+ MP4_Box_t *p_pasp;
if( pp_es )
*pp_es = NULL;
if( !p_enda )
p_enda = MP4_BoxGet( p_sample, "enda" );
- if( p_track->fmt.i_cat == AUDIO_ES && ( p_track->i_sample_size == 1 || p_track->i_sample_size == 2 ) )
- {
- MP4_Box_data_sample_soun_t *p_soun;
-
- p_soun = p_sample->data.p_sample_soun;
-
- if( p_soun->i_qt_version == 0 )
- {
- switch( p_sample->i_type )
- {
- case VLC_FOURCC( 'i', 'm', 'a', '4' ):
- p_soun->i_qt_version = 1;
- p_soun->i_sample_per_packet = 64;
- p_soun->i_bytes_per_packet = 34;
- p_soun->i_bytes_per_frame = 34 * p_soun->i_channelcount;
- p_soun->i_bytes_per_sample = 2;
- break;
- case VLC_FOURCC( 'M', 'A', 'C', '3' ):
- p_soun->i_qt_version = 1;
- p_soun->i_sample_per_packet = 6;
- p_soun->i_bytes_per_packet = 2;
- p_soun->i_bytes_per_frame = 2 * p_soun->i_channelcount;
- p_soun->i_bytes_per_sample = 2;
- break;
- case VLC_FOURCC( 'M', 'A', 'C', '6' ):
- p_soun->i_qt_version = 1;
- p_soun->i_sample_per_packet = 12;
- p_soun->i_bytes_per_packet = 2;
- p_soun->i_bytes_per_frame = 2 * p_soun->i_channelcount;
- p_soun->i_bytes_per_sample = 2;
- break;
- case VLC_FOURCC( 'a', 'l', 'a', 'w' ):
- case VLC_FOURCC( 'u', 'l', 'a', 'w' ):
- p_soun->i_samplesize = 8;
- p_track->i_sample_size = p_soun->i_channelcount;
- break;
- case VLC_FOURCC( 'N', 'O', 'N', 'E' ):
- case VLC_FOURCC( 'r', 'a', 'w', ' ' ):
- case VLC_FOURCC( 't', 'w', 'o', 's' ):
- case VLC_FOURCC( 's', 'o', 'w', 't' ):
- /* What would be the fun if you could trust the .mov */
- p_track->i_sample_size = ((p_soun->i_samplesize+7)/8) * p_soun->i_channelcount;
- break;
- default:
- break;
- }
-
- }
- else if( p_soun->i_qt_version == 1 && p_soun->i_sample_per_packet <= 0 )
- {
- p_soun->i_qt_version = 0;
- }
- }
- else if( p_track->fmt.i_cat == AUDIO_ES && p_sample->data.p_sample_soun->i_qt_version == 1 )
- {
- MP4_Box_data_sample_soun_t *p_soun = p_sample->data.p_sample_soun;
-
- switch( p_sample->i_type )
- {
- case( VLC_FOURCC( '.', 'm', 'p', '3' ) ):
- case( VLC_FOURCC( 'm', 's', 0x00, 0x55 ) ):
- {
- if( p_track->i_sample_size > 1 )
- p_soun->i_qt_version = 0;
- break;
- }
- case( VLC_FOURCC( 'a', 'c', '-', '3' ) ):
- case( VLC_FOURCC( 'e', 'c', '-', '3' ) ):
- case( VLC_FOURCC( 'm', 's', 0x20, 0x00 ) ):
- p_soun->i_qt_version = 0;
- break;
- default:
- break;
- }
- }
+ p_pasp = MP4_BoxGet( p_sample, "pasp" );
/* */
switch( p_track->fmt.i_cat )
p_track->fmt.video.i_sar_num = p_track->i_width * p_track->fmt.video.i_height;
p_track->fmt.video.i_sar_den = p_track->i_height * p_track->fmt.video.i_width;
}
+ if( p_pasp && p_pasp->data.p_pasp->i_horizontal_spacing > 0 &&
+ p_pasp->data.p_pasp->i_vertical_spacing > 0 )
+ {
+ p_track->fmt.video.i_sar_num = p_pasp->data.p_pasp->i_horizontal_spacing;
+ p_track->fmt.video.i_sar_den = p_pasp->data.p_pasp->i_vertical_spacing;
+ }
/* Support for cropping (eg. in H263 files) */
p_track->fmt.video.i_visible_width = p_track->fmt.video.i_width;
p_track, i_sample_description_index, i_chunk );
p_demux->p_sys->f_fps = (float)p_track->fmt.video.i_frame_rate /
(float)p_track->fmt.video.i_frame_rate_base;
+
+ /* Rotation */
+ switch( (int)p_track->f_rotation ) {
+ case 90:
+ p_track->fmt.video.orientation = ORIENT_ROTATED_90;
+ break;
+ case 180:
+ p_track->fmt.video.orientation = ORIENT_ROTATED_180;
+ break;
+ case 270:
+ p_track->fmt.video.orientation = ORIENT_ROTATED_270;
+ break;
+ }
+
break;
case AUDIO_ES:
p_track->fmt.audio.i_bitspersample =
p_sample->data.p_sample_soun->i_samplesize;
+ if( ( p_track->i_sample_size == 1 || p_track->i_sample_size == 2 ) )
+ {
+ MP4_Box_data_sample_soun_t *p_soun;
+ p_soun = p_sample->data.p_sample_soun;
+
+ if( p_soun->i_qt_version == 0 )
+ {
+ switch( p_sample->i_type )
+ {
+ case VLC_FOURCC( 'i', 'm', 'a', '4' ):
+ p_soun->i_qt_version = 1;
+ p_soun->i_sample_per_packet = 64;
+ p_soun->i_bytes_per_packet = 34;
+ p_soun->i_bytes_per_frame = 34 * p_soun->i_channelcount;
+ p_soun->i_bytes_per_sample = 2;
+ break;
+ case VLC_FOURCC( 'M', 'A', 'C', '3' ):
+ p_soun->i_qt_version = 1;
+ p_soun->i_sample_per_packet = 6;
+ p_soun->i_bytes_per_packet = 2;
+ p_soun->i_bytes_per_frame = 2 * p_soun->i_channelcount;
+ p_soun->i_bytes_per_sample = 2;
+ break;
+ case VLC_FOURCC( 'M', 'A', 'C', '6' ):
+ p_soun->i_qt_version = 1;
+ p_soun->i_sample_per_packet = 12;
+ p_soun->i_bytes_per_packet = 2;
+ p_soun->i_bytes_per_frame = 2 * p_soun->i_channelcount;
+ p_soun->i_bytes_per_sample = 2;
+ break;
+ case VLC_FOURCC( 'a', 'l', 'a', 'w' ):
+ case VLC_FOURCC( 'u', 'l', 'a', 'w' ):
+ p_soun->i_samplesize = 8;
+ p_track->i_sample_size = p_soun->i_channelcount;
+ break;
+ case VLC_FOURCC( 'N', 'O', 'N', 'E' ):
+ case VLC_FOURCC( 'r', 'a', 'w', ' ' ):
+ case VLC_FOURCC( 't', 'w', 'o', 's' ):
+ case VLC_FOURCC( 's', 'o', 'w', 't' ):
+ /* What would be the fun if you could trust the .mov */
+ p_track->i_sample_size = ((p_soun->i_samplesize+7)/8) * p_soun->i_channelcount;
+ break;
+ default:
+ break;
+ }
+
+ }
+ else if( p_soun->i_qt_version == 1 && p_soun->i_sample_per_packet <= 0 )
+ {
+ p_soun->i_qt_version = 0;
+ }
+ }
+ else if( p_sample->data.p_sample_soun->i_qt_version == 1 )
+ {
+ MP4_Box_data_sample_soun_t *p_soun = p_sample->data.p_sample_soun;
+
+ switch( p_sample->i_type )
+ {
+ case( VLC_FOURCC( '.', 'm', 'p', '3' ) ):
+ case( VLC_FOURCC( 'm', 's', 0x00, 0x55 ) ):
+ {
+ if( p_track->i_sample_size > 1 )
+ p_soun->i_qt_version = 0;
+ break;
+ }
+ case( VLC_FOURCC( 'a', 'c', '-', '3' ) ):
+ case( VLC_FOURCC( 'e', 'c', '-', '3' ) ):
+ case( VLC_FOURCC( 'm', 's', 0x20, 0x00 ) ):
+ p_soun->i_qt_version = 0;
+ break;
+ default:
+ break;
+ }
+ }
+
if( p_track->i_sample_size != 0 &&
- p_sample->data.p_sample_soun->i_qt_version == 1 && p_sample->data.p_sample_soun->i_sample_per_packet <= 0 )
+ p_sample->data.p_sample_soun->i_qt_version == 1 &&
+ p_sample->data.p_sample_soun->i_sample_per_packet <= 0 )
{
msg_Err( p_demux, "Invalid sample per packet value for qt_version 1" );
return VLC_EGENERIC;
case( VLC_FOURCC( '.', 'm', 'p', '3' ) ):
case( VLC_FOURCC( 'm', 's', 0x00, 0x55 ) ):
{
- p_track->fmt.i_codec = VLC_FOURCC( 'm', 'p', 'g', 'a' );
+ p_track->fmt.i_codec = VLC_CODEC_MPGA;
break;
}
case( VLC_FOURCC( 'a', 'c', '-', '3' ) ):
{
MP4_Box_t *p_dac3_box = MP4_BoxGet( p_sample, "dac3", 0 );
- p_track->fmt.i_codec = VLC_FOURCC( 'a', '5', '2', ' ' );
+ p_track->fmt.i_codec = VLC_CODEC_A52;
if( p_dac3_box )
{
static const int pi_bitrate[] = {
}
case( VLC_FOURCC( 'e', 'c', '-', '3' ) ):
{
- p_track->fmt.i_codec = VLC_FOURCC( 'e', 'a', 'c', '3' );
+ p_track->fmt.i_codec = VLC_CODEC_EAC3;
break;
}
}
case( VLC_FOURCC( 's', '2', '6', '3' ) ):
- p_track->fmt.i_codec = VLC_FOURCC( 'h', '2', '6', '3' );
+ p_track->fmt.i_codec = VLC_CODEC_H263;
break;
case( VLC_FOURCC( 't', 'e', 'x', 't' ) ):
case( VLC_FOURCC( 't', 'x', '3', 'g' ) ):
- p_track->fmt.i_codec = VLC_FOURCC( 's', 'u', 'b', 't' );
+ p_track->fmt.i_codec = VLC_CODEC_SUBT;
/* FIXME: Not true, could be UTF-16 with a Byte Order Mark (0xfeff) */
/* FIXME UTF-8 doesn't work here ? */
if( p_track->b_mac_encoding )
break;
case VLC_FOURCC('y','v','1','2'):
- p_track->fmt.i_codec = VLC_FOURCC('Y','V','1','2');
+ p_track->fmt.i_codec = VLC_CODEC_YV12;
break;
case VLC_FOURCC('y','u','v','2'):
p_track->fmt.i_codec = VLC_FOURCC('Y','U','Y','2');
p_track->fmt.i_codec = p_enda && p_enda->data.p_enda->i_little_endian == 1 ?
VLC_CODEC_F64L : VLC_CODEC_F64B;
break;
+ case VLC_FOURCC( 'l', 'p', 'c', 'm' ):
+ {
+ MP4_Box_data_sample_soun_t *p_soun = p_sample->data.p_sample_soun;
+ if( p_soun->i_qt_version == 2 &&
+ p_soun->i_qt_description > 20 + 28 )
+ {
+ /* Flags:
+ * 0x01: IsFloat
+ * 0x02: IsBigEndian
+ * 0x04: IsSigned
+ */
+ static const struct {
+ unsigned i_flags;
+ unsigned i_mask;
+ unsigned i_bits;
+ vlc_fourcc_t i_codec;
+ } p_formats[] = {
+ { 0x01, 0x03, 32, VLC_CODEC_F32L },
+ { 0x01, 0x03, 64, VLC_CODEC_F64L },
+ { 0x01|0x02, 0x03, 32, VLC_CODEC_F32B },
+ { 0x01|0x02, 0x03, 64, VLC_CODEC_F64B },
+
+ { 0x00, 0x05, 8, VLC_CODEC_U8 },
+ { 0x00| 0x04, 0x05, 8, VLC_CODEC_S8 },
+
+ { 0x00, 0x07, 16, VLC_CODEC_U16L },
+ { 0x00|0x02, 0x07, 16, VLC_CODEC_U16B },
+ { 0x00 |0x04, 0x07, 16, VLC_CODEC_S16L },
+ { 0x00|0x02|0x04, 0x07, 16, VLC_CODEC_S16B },
+
+ { 0x00, 0x07, 24, VLC_CODEC_U24L },
+ { 0x00|0x02, 0x07, 24, VLC_CODEC_U24B },
+ { 0x00 |0x04, 0x07, 24, VLC_CODEC_S24L },
+ { 0x00|0x02|0x04, 0x07, 24, VLC_CODEC_S24B },
+
+ { 0x00, 0x07, 32, VLC_CODEC_U32L },
+ { 0x00|0x02, 0x07, 32, VLC_CODEC_U32B },
+ { 0x00 |0x04, 0x07, 32, VLC_CODEC_S32L },
+ { 0x00|0x02|0x04, 0x07, 32, VLC_CODEC_S32B },
+
+ {0, 0, 0, 0}
+ };
+ uint32_t i_bits = GetDWBE(&p_soun->p_qt_description[20 + 20]);
+ uint32_t i_flags = GetDWBE(&p_soun->p_qt_description[20 + 24]);
+
+ for( int i = 0; p_formats[i].i_codec; i++ )
+ {
+ if( p_formats[i].i_bits == i_bits &&
+ (i_flags & p_formats[i].i_mask) == p_formats[i].i_flags )
+ {
+ p_track->fmt.i_codec = p_formats[i].i_codec;
+ p_track->fmt.audio.i_bitspersample = i_bits;
+ p_track->fmt.audio.i_blockalign = p_soun->i_channelcount * i_bits / 8;
+ p_track->i_sample_size = p_track->fmt.audio.i_blockalign;
+ p_soun->i_qt_version = 0;
+ break;
+ }
+ }
+ }
+ break;
+ }
default:
p_track->fmt.i_codec = p_sample->i_type;
break;
switch( p_decconfig->i_objectTypeIndication )
{
case( 0x20 ): /* MPEG4 VIDEO */
- p_track->fmt.i_codec = VLC_FOURCC( 'm','p','4','v' );
+ p_track->fmt.i_codec = VLC_CODEC_MP4V;
+ break;
+ case( 0x21 ): /* H.264 */
+ p_track->fmt.i_codec = VLC_CODEC_H264;
break;
case( 0x40):
- p_track->fmt.i_codec = VLC_FOURCC( 'm','p','4','a' );
+ p_track->fmt.i_codec = VLC_CODEC_MP4A;
if( p_decconfig->i_decoder_specific_info_len >= 2 &&
p_decconfig->p_decoder_specific_info[0] == 0xF8 &&
(p_decconfig->p_decoder_specific_info[1]&0xE0) == 0x80 )
case( 0x63):
case( 0x64):
case( 0x65): /* MPEG2 video */
- p_track->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' );
+ p_track->fmt.i_codec = VLC_CODEC_MPGV;
break;
/* Theses are MPEG2-AAC */
case( 0x66): /* main profile */
case( 0x67): /* Low complexity profile */
case( 0x68): /* Scaleable Sampling rate profile */
- p_track->fmt.i_codec = VLC_FOURCC( 'm','p','4','a' );
+ p_track->fmt.i_codec = VLC_CODEC_MP4A;
break;
- /* true MPEG 2 audio */
+ /* True MPEG 2 audio */
case( 0x69):
- p_track->fmt.i_codec = VLC_FOURCC( 'm','p','g','a' );
+ p_track->fmt.i_codec = VLC_CODEC_MPGA;
break;
case( 0x6a): /* MPEG1 video */
p_track->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' );
break;
case( 0x6b): /* MPEG1 audio */
- p_track->fmt.i_codec = VLC_FOURCC( 'm','p','g','a' );
+ p_track->fmt.i_codec = VLC_CODEC_MPGA;
break;
case( 0x6c ): /* jpeg */
p_track->fmt.i_codec = VLC_FOURCC( 'j','p','e','g' );
case( 0x6d ): /* png */
p_track->fmt.i_codec = VLC_FOURCC( 'p','n','g',' ' );
break;
- case( 0x6e ): /* jpeg200 */
+ case( 0x6e ): /* jpeg2000 */
p_track->fmt.i_codec = VLC_FOURCC( 'M','J','2','C' );
break;
case( 0xa3 ): /* vc1 */
- p_track->fmt.i_codec = VLC_FOURCC( 'W','V','C','1' );
+ p_track->fmt.i_codec = VLC_CODEC_VC1;
+ break;
+ case( 0xa4 ):
+ p_track->fmt.i_codec = VLC_CODEC_DIRAC;
+ break;
+ case( 0xa5 ):
+ p_track->fmt.i_codec = VLC_CODEC_A52;
+ break;
+ case( 0xa6 ):
+ p_track->fmt.i_codec = VLC_CODEC_EAC3;
+ break;
+ case( 0xa9 ): /* dts */
+ case( 0xaa ): /* DTS-HD HRA */
+ case( 0xab ): /* DTS-HD Master Audio */
+ p_track->fmt.i_codec = VLC_CODEC_DTS;
+ break;
+ case( 0xDD ):
+ p_track->fmt.i_codec = VLC_CODEC_VORBIS;
break;
/* Private ID */
p_track->fmt.i_extra);
}
break;
- case VLC_FOURCC( 's', 'a', 'm', 'r' ):
+
+ case VLC_CODEC_AMR_NB:
p_track->fmt.audio.i_rate = 8000;
+ case VLC_CODEC_AMR_WB:
+ p_track->fmt.audio.i_rate = 16000;
case VLC_FOURCC( 'Q', 'D', 'M', 'C' ):
- case VLC_FOURCC( 'Q', 'D', 'M', '2' ):
- case VLC_FOURCC( 'a', 'l', 'a', 'c' ):
+ case VLC_CODEC_QDM2:
+ case VLC_CODEC_ALAC:
p_track->fmt.i_extra =
p_sample->data.p_sample_soun->i_qt_description;
if( p_track->fmt.i_extra > 0 )
p_sample->data.p_sample_soun->p_qt_description,
p_track->fmt.i_extra);
}
+ if( p_track->fmt.i_extra >= 56 && p_sample->i_type == VLC_CODEC_ALAC )
+ {
+ p_track->fmt.audio.i_channels = *((uint8_t*)p_track->fmt.p_extra + 41);
+ p_track->fmt.audio.i_rate = GetDWBE((uint8_t*)p_track->fmt.p_extra + 52);
+ }
break;
+ case VLC_FOURCC( 'v', 'c', '-', '1' ):
+ {
+ MP4_Box_t *p_dvc1 = MP4_BoxGet( p_sample, "dvc1" );
+ if( p_dvc1 )
+ {
+ p_track->fmt.i_extra = p_dvc1->data.p_dvc1->i_vc1;
+ if( p_track->fmt.i_extra > 0 )
+ {
+ p_track->fmt.p_extra = malloc( p_dvc1->data.p_dvc1->i_vc1 );
+ memcpy( p_track->fmt.p_extra, p_dvc1->data.p_dvc1->p_vc1,
+ p_track->fmt.i_extra );
+ }
+ }
+ else
+ {
+ msg_Err( p_demux, "missing dvc1" );
+ }
+ break;
+ }
+
/* avc1: send avcC (h264 without annexe B, ie without start code)*/
case VLC_FOURCC( 'a', 'v', 'c', '1' ):
{
break;
}
- case VLC_FOURCC('m','s',0x00,0x02):
- case VLC_FOURCC('m','s',0x00,0x11):
- case VLC_FOURCC('Q','c','l','p'):
+ case VLC_CODEC_ADPCM_MS:
+ case VLC_CODEC_ADPCM_IMA_WAV:
+ case VLC_CODEC_QCELP:
p_track->fmt.audio.i_blockalign = p_sample->data.p_sample_soun->i_bytes_per_frame;
break;
default:
+ msg_Dbg( p_demux, "Unrecognized FourCC %4.4s", (char *)&p_sample->i_type );
break;
}
}
MP4_Box_t *p_vmhd;
MP4_Box_t *p_smhd;
- MP4_Box_t *p_drms;
-
unsigned int i;
char language[4];
p_track->i_track_ID = p_tkhd->data.p_tkhd->i_track_ID;
p_track->i_width = p_tkhd->data.p_tkhd->i_width / 65536;
p_track->i_height = p_tkhd->data.p_tkhd->i_height / 65536;
+ p_track->f_rotation = p_tkhd->data.p_tkhd->f_rotation;
if( p_tref )
{
switch( p_hdlr->data.p_hdlr->i_handler_type )
{
- case( FOURCC_soun ):
+ case( ATOM_soun ):
if( !( p_smhd = MP4_BoxGet( p_box_trak, "mdia/minf/smhd" ) ) )
{
return;
p_track->fmt.i_cat = AUDIO_ES;
break;
- case( FOURCC_vide ):
+ case( ATOM_vide ):
if( !( p_vmhd = MP4_BoxGet( p_box_trak, "mdia/minf/vmhd" ) ) )
{
return;
p_track->fmt.i_cat = VIDEO_ES;
break;
- case( FOURCC_text ):
- case( FOURCC_subp ):
- case( FOURCC_tx3g ):
- case( FOURCC_sbtl ):
+ case( ATOM_text ):
+ case( ATOM_subp ):
+ case( ATOM_tx3g ):
+ case( ATOM_sbtl ):
p_track->fmt.i_cat = SPU_ES;
break;
return;
}
- p_drms = MP4_BoxGet( p_track->p_stsd, "drms" );
- p_track->b_drms = p_drms != NULL;
- p_track->p_drms = p_track->b_drms ?
- p_drms->data.p_sample_soun->p_drms : NULL;
-
- if ( !p_drms )
- {
- p_drms = MP4_BoxGet( p_track->p_stsd, "drmi" );
- p_track->b_drms = p_drms != NULL;
- p_track->p_drms = p_track->b_drms ?
- p_drms->data.p_sample_vide->p_drms : NULL;
- }
-
- if( p_drms )
- p_track->p_skcr = MP4_BoxGet( p_drms, "sinf/skcr" );
-
/* Set language */
if( *language && strcmp( language, "```" ) && strcmp( language, "und" ) )
{
p_udta = MP4_BoxGet( p_box_trak, "udta" );
if( p_udta )
{
- MP4_Box_t *p_0xa9xxx;
- for( p_0xa9xxx = p_udta->p_first; p_0xa9xxx != NULL;
- p_0xa9xxx = p_0xa9xxx->p_next )
+ MP4_Box_t *p_box_iter;
+ for( p_box_iter = p_udta->p_first; p_box_iter != NULL;
+ p_box_iter = p_box_iter->p_next )
{
- switch( p_0xa9xxx->i_type )
+ switch( p_box_iter->i_type )
{
- case FOURCC_0xa9nam:
+ case ATOM_0xa9nam:
+ p_track->fmt.psz_description =
+ strdup( p_box_iter->data.p_0xa9xxx->psz_text );
+ break;
+ case ATOM_name:
p_track->fmt.psz_description =
- strdup( p_0xa9xxx->data.p_0xa9xxx->psz_text );
+ strdup( p_box_iter->data.p_name->psz_text );
break;
}
}
MP4_Box_data_sample_soun_t *p_soun =
p_track->p_sample->data.p_sample_soun;
- if( p_soun->i_qt_version == 0 )
+ if( p_track->fmt.i_cat != AUDIO_ES || p_soun->i_qt_version == 0 )
{
i_pos += ( p_track->i_sample -
p_track->chunk[p_track->i_chunk].i_sample_first ) *