generic-library/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'newdev/master'

Browse Source 
* newdev/master:
  ac3enc: Add codec-specific options for writing AC-3 metadata.
NOT MERGED:  Remove arrozcru URL from documentation
  sndio support for playback and record

Conflicts:
	doc/faq.texi
	doc/general.texi

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2011-03-28 01:50:36 +02:00
commit 25d8099beb
16 changed files with 1183 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Changelog
View File

@ -80,6 +80,7 @@ version <next>:
- Bitmap Brothers JV playback system
- Linux framebuffer input device added
- Apple HTTP Live Streaming protocol handler
- sndio support for playback and record
version 0.6:

6
configure vendored
View File

@ -1098,6 +1098,7 @@ HAVE_LIST="
sdl
sdl_video_size
setmode
sndio_h
socklen_t
soundcard_h
poll_h
@ -1448,6 +1449,8 @@ jack_indev_deps="jack_jack_h"
libdc1394_indev_deps="libdc1394"
oss_indev_deps_any="soundcard_h sys_soundcard_h"
oss_outdev_deps_any="soundcard_h sys_soundcard_h"
sndio_indev_deps="sndio_h"
sndio_outdev_deps="sndio_h"
v4l_indev_deps="linux_videodev_h"
v4l2_indev_deps_any="linux_videodev2_h sys_videoio_h"
vfwcap_indev_deps="capCreateCaptureWindow vfwcap_defines"
@ -2934,6 +2937,7 @@ check_cpp_condition vfw.h "WM_CAP_DRIVER_CONNECT > WM_USER" && enable vfwcap_def
check_header dev/video/bktr/ioctl_bt848.h; } ||
check_header dev/ic/bt8xx.h
check_header sndio.h
check_header sys/soundcard.h
check_header soundcard.h
@ -2941,6 +2945,8 @@ enabled_any alsa_indev alsa_outdev && check_lib2 alsa/asoundlib.h snd_pcm_htimes
enabled jack_indev && check_lib2 jack/jack.h jack_client_open -ljack
enabled_any sndio_indev sndio_outdev && check_lib2 sndio.h sio_open -lsndio
enabled x11grab &&
check_header X11/Xlib.h &&
check_header X11/extensions/XShm.h &&

336
doc/encoders.texi
View File

@ -17,4 +17,340 @@ with the options @code{--enable-encoder=@var{ENCODER}} /
The option @code{-codecs} of the ff* tools will display the list of
enabled encoders.
A description of some of the currently available encoders follows.
@section Audio Encoders
@subsection ac3 and ac3_fixed
AC-3 audio encoders.
These encoders implement part of ATSC A/52:2010 and ETSI TS 102 366, as well as
the undocumented RealAudio 3 (a.k.a. dnet).
The @var{ac3} encoder uses floating-point math, while the @var{ac3_fixed}
encoder only uses fixed-point integer math. This does not mean that one is
always faster, just that one or the other may be better suited to a
particular system. The floating-point encoder will generally produce better
quality audio for a given bitrate. The @var{ac3_fixed} encoder is not the
default codec for any of the output formats, so it must be specified explicitly
using the option @code{-acodec ac3_fixed} in order to use it.
@subheading AC-3 Metadata
The AC-3 metadata options are used to set parameters that describe the audio,
but in most cases do not affect the audio encoding itself. Some of the options
do directly affect or influence the decoding and playback of the resulting
bitstream, while others are just for informational purposes. A few of the
options will add bits to the output stream that could otherwise be used for
audio data, and will thus affect the quality of the output. Those will be
indicated accordingly with a note in the option list below.
These parameters are described in detail in several publicly-available
documents.
@itemize
@item @uref{http://www.atsc.org/cms/standards/a_52-2010.pdf,A/52:2010 - Digital Audio Compression (AC-3) (E-AC-3) Standard}
@item @uref{http://www.atsc.org/cms/standards/a_54a_with_corr_1.pdf,A/54 - Guide to the Use of the ATSC Digital Television Standard}
@item @uref{http://www.dolby.com/uploadedFiles/zz-_Shared_Assets/English_PDFs/Professional/18_Metadata.Guide.pdf,Dolby Metadata Guide}
@item @uref{http://www.dolby.com/uploadedFiles/zz-_Shared_Assets/English_PDFs/Professional/46_DDEncodingGuidelines.pdf,Dolby Digital Professional Encoding Guidelines}
@end itemize
@subsubheading Metadata Control Options
@table @option
@item -per_frame_metadata @var{boolean}
Allow Per-Frame Metadata. Specifies if the encoder should check for changing
metadata for each frame.
@table @option
@item 0
The metadata values set at initialization will be used for every frame in the
stream. (default)
@item 1
Metadata values can be changed before encoding each frame.
@end table
@end table
@subsubheading Downmix Levels
@table @option
@item -center_mixlev @var{level}
Center Mix Level. The amount of gain the decoder should apply to the center
channel when downmixing to stereo. This field will only be written to the
bitstream if a center channel is present. The value is specified as a scale
factor. There are 3 valid values:
@table @option
@item 0.707
Apply -3dB gain
@item 0.595
Apply -4.5dB gain (default)
@item 0.500
Apply -6dB gain
@end table
@item -surround_mixlev @var{level}
Surround Mix Level. The amount of gain the decoder should apply to the surround
channel(s) when downmixing to stereo. This field will only be written to the
bitstream if one or more surround channels are present. The value is specified
as a scale factor. There are 3 valid values:
@table @option
@item 0.707
Apply -3dB gain
@item 0.500
Apply -6dB gain (default)
@item 0.000
Silence Surround Channel(s)
@end table
@end table
@subsubheading Audio Production Information
Audio Production Information is optional information describing the mixing
environment. Either none or both of the fields are written to the bitstream.
@table @option
@item -mixing_level @var{number}
Mixing Level. Specifies peak sound pressure level (SPL) in the production
environment when the mix was mastered. Valid values are 80 to 111, or -1 for
unknown or not indicated. The default value is -1, but that value cannot be
used if the Audio Production Information is written to the bitstream. Therefore,
if the @code{room_type} option is not the default value, the @code{mixing_level}
option must not be -1.
@item -room_type @var{type}
Room Type. Describes the equalization used during the final mixing session at
the studio or on the dubbing stage. A large room is a dubbing stage with the
industry standard X-curve equalization; a small room has flat equalization.
This field will not be written to the bitstream if both the @code{mixing_level}
option and the @code{room_type} option have the default values.
@table @option
@item 0
@itemx notindicated
Not Indicated (default)
@item 1
@itemx large
Large Room
@item 2
@itemx small
Small Room
@end table
@end table
@subsubheading Other Metadata Options
@table @option
@item -copyright @var{boolean}
Copyright Indicator. Specifies whether a copyright exists for this audio.
@table @option
@item 0
@itemx off
No Copyright Exists (default)
@item 1
@itemx on
Copyright Exists
@end table
@item -dialnorm @var{value}
Dialogue Normalization. Indicates how far the average dialogue level of the
program is below digital 100% full scale (0 dBFS). This parameter determines a
level shift during audio reproduction that sets the average volume of the
dialogue to a preset level. The goal is to match volume level between program
sources. A value of -31dB will result in no volume level change, relative to
the source volume, during audio reproduction. Valid values are whole numbers in
the range -31 to -1, with -31 being the default.
@item -dsur_mode @var{mode}
Dolby Surround Mode. Specifies whether the stereo signal uses Dolby Surround
(Pro Logic). This field will only be written to the bitstream if the audio
stream is stereo. Using this option does @b{NOT} mean the encoder will actually
apply Dolby Surround processing.
@table @option
@item 0
@itemx notindicated
Not Indicated (default)
@item 1
@itemx off
Not Dolby Surround Encoded
@item 2
@itemx on
Dolby Surround Encoded
@end table
@item -original @var{boolean}
Original Bit Stream Indicator. Specifies whether this audio is from the
original source and not a copy.
@table @option
@item 0
@itemx off
Not Original Source
@item 1
@itemx on
Original Source (default)
@end table
@end table
@subsubheading Extended Bitstream Information
The extended bitstream options are part of the Alternate Bit Stream Syntax as
specified in Annex D of the A/52:2010 standard. It is grouped into 2 parts.
If any one parameter in a group is specified, all values in that group will be
written to the bitstream. Default values are used for those that are written
but have not been specified. If the mixing levels are written, the decoder
will use these values instead of the ones specified in the @code{center_mixlev}
and @code{surround_mixlev} options if it supports the Alternate Bit Stream
Syntax.
@subsubheading Extended Bitstream Information - Part 1
@table @option
@item -dmix_mode @var{mode}
Preferred Stereo Downmix Mode. Allows the user to select either Lt/Rt
(Dolby Surround) or Lo/Ro (normal stereo) as the preferred stereo downmix mode.
@table @option
@item 0
@itemx notindicated
Not Indicated (default)
@item 1
@itemx ltrt
Lt/Rt Downmix Preferred
@item 2
@itemx loro
Lo/Ro Downmix Preferred
@end table
@item -ltrt_cmixlev @var{level}
Lt/Rt Center Mix Level. The amount of gain the decoder should apply to the
center channel when downmixing to stereo in Lt/Rt mode.
@table @option
@item 1.414
Apply +3dB gain
@item 1.189
Apply +1.5dB gain
@item 1.000
Apply 0dB gain
@item 0.841
Apply -1.5dB gain
@item 0.707
Apply -3.0dB gain
@item 0.595
Apply -4.5dB gain (default)
@item 0.500
Apply -6.0dB gain
@item 0.000
Silence Center Channel
@end table
@item -ltrt_surmixlev @var{level}
Lt/Rt Surround Mix Level. The amount of gain the decoder should apply to the
surround channel(s) when downmixing to stereo in Lt/Rt mode.
@table @option
@item 0.841
Apply -1.5dB gain
@item 0.707
Apply -3.0dB gain
@item 0.595
Apply -4.5dB gain
@item 0.500
Apply -6.0dB gain (default)
@item 0.000
Silence Surround Channel(s)
@end table
@item -loro_cmixlev @var{level}
Lo/Ro Center Mix Level. The amount of gain the decoder should apply to the
center channel when downmixing to stereo in Lo/Ro mode.
@table @option
@item 1.414
Apply +3dB gain
@item 1.189
Apply +1.5dB gain
@item 1.000
Apply 0dB gain
@item 0.841
Apply -1.5dB gain
@item 0.707
Apply -3.0dB gain
@item 0.595
Apply -4.5dB gain (default)
@item 0.500
Apply -6.0dB gain
@item 0.000
Silence Center Channel
@end table
@item -loro_surmixlev @var{level}
Lo/Ro Surround Mix Level. The amount of gain the decoder should apply to the
surround channel(s) when downmixing to stereo in Lo/Ro mode.
@table @option
@item 0.841
Apply -1.5dB gain
@item 0.707
Apply -3.0dB gain
@item 0.595
Apply -4.5dB gain
@item 0.500
Apply -6.0dB gain (default)
@item 0.000
Silence Surround Channel(s)
@end table
@end table
@subsubheading Extended Bitstream Information - Part 2
@table @option
@item -dsurex_mode @var{mode}
Dolby Surround EX Mode. Indicates whether the stream uses Dolby Surround EX
(7.1 matrixed to 5.1). Using this option does @b{NOT} mean the encoder will actually
apply Dolby Surround EX processing.
@table @option
@item 0
@itemx notindicated
Not Indicated (default)
@item 1
@itemx on
Dolby Surround EX On
@item 2
@itemx off
Dolby Surround EX Off
@end table
@item -dheadphone_mode @var{mode}
Dolby Headphone Mode. Indicates whether the stream uses Dolby Headphone
encoding (multi-channel matrixed to 2.0 for use with headphones). Using this
option does @b{NOT} mean the encoder will actually apply Dolby Headphone
processing.
@table @option
@item 0
@itemx notindicated
Not Indicated (default)
@item 1
@itemx on
Dolby Headphone On
@item 2
@itemx off
Dolby Headphone Off
@end table
@item -ad_conv_type @var{type}
A/D Converter Type. Indicates whether the audio has passed through HDCD A/D
conversion.
@table @option
@item 0
@itemx standard
Standard A/D Converter (default)
@item 1
@itemx hdcd
HDCD A/D Converter
@end table
@end table
@c man end ENCODERS

17
doc/indevs.texi
View File

@ -154,6 +154,23 @@ ffmpeg -f oss -i /dev/dsp /tmp/oss.wav
For more information about OSS see:
@url{http://manuals.opensound.com/usersguide/dsp.html}
@section sndio
sndio input device.
To enable this input device during configuration you need libsndio
installed on your system.
The filename to provide to the input device is the device node
representing the sndio input device, and is usually set to
@file{/dev/audio0}.
For example to grab from @file{/dev/audio0} using @file{ffmpeg} use the
command:
@example
ffmpeg -f sndio -i /dev/audio0 /tmp/oss.wav
@end example
@section video4linux and video4linux2
Video4Linux and Video4Linux2 input video devices.

4
doc/outdevs.texi
View File

@ -26,4 +26,8 @@ ALSA (Advanced Linux Sound Architecture) output device.
OSS (Open Sound System) output device.
@section sndio
sndio audio output device.
@c man end OUTPUT DEVICES

11
libavcodec/ac3.h
View File

@ -48,6 +48,17 @@
#define EXP_D25 2
#define EXP_D45 3
/* pre-defined gain values */
#define LEVEL_PLUS_3DB 1.4142135623730950
#define LEVEL_PLUS_1POINT5DB 1.1892071150027209
#define LEVEL_MINUS_1POINT5DB 0.8408964152537145
#define LEVEL_MINUS_3DB 0.7071067811865476
#define LEVEL_MINUS_4POINT5DB 0.5946035575013605
#define LEVEL_MINUS_6DB 0.5000000000000000
#define LEVEL_MINUS_9DB 0.3535533905932738
#define LEVEL_ZERO 0.0000000000000000
#define LEVEL_ONE 1.0000000000000000
/** Delta bit allocation strategy */
typedef enum {
DBA_REUSE = 0,

10
libavcodec/ac3dec.c
View File

@ -67,16 +67,6 @@ static const uint8_t quantization_tab[16] = {
static float dynamic_range_tab[256];
/** Adjustments in dB gain */
#define LEVEL_PLUS_3DB 1.4142135623730950
#define LEVEL_PLUS_1POINT5DB 1.1892071150027209
#define LEVEL_MINUS_1POINT5DB 0.8408964152537145
#define LEVEL_MINUS_3DB 0.7071067811865476
#define LEVEL_MINUS_4POINT5DB 0.5946035575013605
#define LEVEL_MINUS_6DB 0.5000000000000000
#define LEVEL_MINUS_9DB 0.3535533905932738
#define LEVEL_ZERO 0.0000000000000000
#define LEVEL_ONE 1.0000000000000000
static const float gain_levels[9] = {
LEVEL_PLUS_3DB,
LEVEL_PLUS_1POINT5DB,

441
libavcodec/ac3enc.c
View File

@ -32,6 +32,7 @@
#include "libavutil/audioconvert.h"
#include "libavutil/avassert.h"
#include "libavutil/crc.h"
#include "libavutil/opt.h"
#include "avcodec.h"
#include "put_bits.h"
#include "dsputil.h"
@ -65,6 +66,36 @@
#endif
/**
* Encoding Options used by AVOption.
*/
typedef struct AC3EncOptions {
/* AC-3 metadata options*/
int dialogue_level;
int bitstream_mode;
float center_mix_level;
float surround_mix_level;
int dolby_surround_mode;
int audio_production_info;
int mixing_level;
int room_type;
int copyright;
int original;
int extended_bsi_1;
int preferred_stereo_downmix;
float ltrt_center_mix_level;
float ltrt_surround_mix_level;
float loro_center_mix_level;
float loro_surround_mix_level;
int extended_bsi_2;
int dolby_surround_ex_mode;
int dolby_headphone_mode;
int ad_converter_type;
/* other encoding options */
int allow_per_frame_metadata;
} AC3EncOptions;
/**
* Data for a single audio block.
*/
@ -87,6 +118,8 @@ typedef struct AC3Block {
* AC-3 encoder private context.
*/
typedef struct AC3EncodeContext {
AVClass *av_class; ///< AVClass used for AVOption
AC3EncOptions options; ///< encoding options
PutBitContext pb; ///< bitstream writer context
DSPContext dsp;
AC3DSPContext ac3dsp; ///< AC-3 optimized functions
@ -111,9 +144,18 @@ typedef struct AC3EncodeContext {
int channels; ///< total number of channels (nchans)
int lfe_on; ///< indicates if there is an LFE channel (lfeon)
int lfe_channel; ///< channel index of the LFE channel
int has_center; ///< indicates if there is a center channel
int has_surround; ///< indicates if there are one or more surround channels
int channel_mode; ///< channel mode (acmod)
const uint8_t *channel_map; ///< channel map used to reorder channels
int center_mix_level; ///< center mix level code
int surround_mix_level; ///< surround mix level code
int ltrt_center_mix_level; ///< Lt/Rt center mix level code
int ltrt_surround_mix_level; ///< Lt/Rt surround mix level code
int loro_center_mix_level; ///< Lo/Ro center mix level code
int loro_surround_mix_level; ///< Lo/Ro surround mix level code
int cutoff; ///< user-specified cutoff frequency, in Hz
int bandwidth_code[AC3_MAX_CHANNELS]; ///< bandwidth code (0 to 60) (chbwcod)
int nb_coefs[AC3_MAX_CHANNELS];
@ -157,6 +199,78 @@ typedef struct AC3EncodeContext {
} AC3EncodeContext;
#define CMIXLEV_NUM_OPTIONS 3
static const float cmixlev_options[CMIXLEV_NUM_OPTIONS] = {
LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB
};
#define SURMIXLEV_NUM_OPTIONS 3
static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS] = {
LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO
};
#define EXTMIXLEV_NUM_OPTIONS 8
static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS] = {
LEVEL_PLUS_3DB, LEVEL_PLUS_1POINT5DB, LEVEL_ONE, LEVEL_MINUS_4POINT5DB,
LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB, LEVEL_ZERO
};
#define OFFSET(param) offsetof(AC3EncodeContext, options.param)
#define AC3ENC_PARAM (AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
static const AVOption options[] = {
/* Metadata Options */
{"per_frame_metadata", "Allow Changing Metadata Per-Frame", OFFSET(allow_per_frame_metadata), FF_OPT_TYPE_INT, 0, 0, 1, AC3ENC_PARAM},
/* downmix levels */
{"center_mixlev", "Center Mix Level", OFFSET(center_mix_level), FF_OPT_TYPE_FLOAT, LEVEL_MINUS_4POINT5DB, 0.0, 1.0, AC3ENC_PARAM},
{"surround_mixlev", "Surround Mix Level", OFFSET(surround_mix_level), FF_OPT_TYPE_FLOAT, LEVEL_MINUS_6DB, 0.0, 1.0, AC3ENC_PARAM},
/* audio production information */
{"mixing_level", "Mixing Level", OFFSET(mixing_level), FF_OPT_TYPE_INT, -1, -1, 111, AC3ENC_PARAM},
{"room_type", "Room Type", OFFSET(room_type), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "room_type"},
{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"},
{"large", "Large Room", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"},
{"small", "Small Room", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"},
/* other metadata options */
{"copyright", "Copyright Bit", OFFSET(copyright), FF_OPT_TYPE_INT, 0, 0, 1, AC3ENC_PARAM},
{"dialnorm", "Dialogue Level (dB)", OFFSET(dialogue_level), FF_OPT_TYPE_INT, -31, -31, -1, AC3ENC_PARAM},
{"dsur_mode", "Dolby Surround Mode", OFFSET(dolby_surround_mode), FF_OPT_TYPE_INT, 0, 0, 2, AC3ENC_PARAM, "dsur_mode"},
{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"},
{"on", "Dolby Surround Encoded", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"},
{"off", "Not Dolby Surround Encoded", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"},
{"original", "Original Bit Stream", OFFSET(original), FF_OPT_TYPE_INT, 1, 0, 1, AC3ENC_PARAM},
/* extended bitstream information */
{"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "dmix_mode"},
{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"},
{"ltrt", "Lt/Rt Downmix Preferred", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"},
{"loro", "Lo/Ro Downmix Preferred", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"},
{"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM},
{"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM},
{"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM},
{"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM},
{"dsurex_mode", "Dolby Surround EX Mode", OFFSET(dolby_surround_ex_mode), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "dsurex_mode"},
{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"},
{"on", "Dolby Surround EX Encoded", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"},
{"off", "Not Dolby Surround EX Encoded", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"},
{"dheadphone_mode", "Dolby Headphone Mode", OFFSET(dolby_headphone_mode), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "dheadphone_mode"},
{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"},
{"on", "Dolby Headphone Encoded", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"},
{"off", "Not Dolby Headphone Encoded", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"},
{"ad_conv_type", "A/D Converter Type", OFFSET(ad_converter_type), FF_OPT_TYPE_INT, -1, -1, 1, AC3ENC_PARAM, "ad_conv_type"},
{"standard", "Standard (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"},
{"hdcd", "HDCD", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"},
{NULL}
};
#if CONFIG_AC3ENC_FLOAT
static AVClass ac3enc_class = { "AC-3 Encoder", av_default_item_name,
options, LIBAVUTIL_VERSION_INT };
#else
static AVClass ac3enc_class = { "Fixed-Point AC-3 Encoder", av_default_item_name,
options, LIBAVUTIL_VERSION_INT };
#endif
/* prototypes for functions in ac3enc_fixed.c and ac3enc_float.c */
static av_cold void mdct_end(AC3MDCTContext *mdct);
@ -786,9 +900,19 @@ static void bit_alloc_init(AC3EncodeContext *s)
*/
static void count_frame_bits(AC3EncodeContext *s)
{
AC3EncOptions *opt = &s->options;
int blk, ch;
int frame_bits = 0;
if (opt->audio_production_info)
frame_bits += 7;
if (s->bitstream_id == 6) {
if (opt->extended_bsi_1)
frame_bits += 14;
if (opt->extended_bsi_2)
frame_bits += 14;
}
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
/* stereo rematrixing */
if (s->channel_mode == AC3_CHMODE_STEREO &&
@ -1245,6 +1369,8 @@ static void quantize_mantissas(AC3EncodeContext *s)
*/
static void output_frame_header(AC3EncodeContext *s)
{
AC3EncOptions *opt = &s->options;
put_bits(&s->pb, 16, 0x0b77); /* frame header */
put_bits(&s->pb, 16, 0); /* crc1: will be filled later */
put_bits(&s->pb, 2, s->bit_alloc.sr_code);
@ -1253,20 +1379,43 @@ static void output_frame_header(AC3EncodeContext *s)
put_bits(&s->pb, 3, s->bitstream_mode);
put_bits(&s->pb, 3, s->channel_mode);
if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO)
put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */
put_bits(&s->pb, 2, s->center_mix_level);
if (s->channel_mode & 0x04)
put_bits(&s->pb, 2, 1); /* XXX -6 dB */
put_bits(&s->pb, 2, s->surround_mix_level);
if (s->channel_mode == AC3_CHMODE_STEREO)
put_bits(&s->pb, 2, 0); /* surround not indicated */
put_bits(&s->pb, 2, opt->dolby_surround_mode);
put_bits(&s->pb, 1, s->lfe_on); /* LFE */
put_bits(&s->pb, 5, 31); /* dialog norm: -31 db */
put_bits(&s->pb, 5, -opt->dialogue_level);
put_bits(&s->pb, 1, 0); /* no compression control word */
put_bits(&s->pb, 1, 0); /* no lang code */
put_bits(&s->pb, 1, 0); /* no audio production info */
put_bits(&s->pb, 1, 0); /* no copyright */
put_bits(&s->pb, 1, 1); /* original bitstream */
put_bits(&s->pb, 1, opt->audio_production_info);
if (opt->audio_production_info) {
put_bits(&s->pb, 5, opt->mixing_level - 80);
put_bits(&s->pb, 2, opt->room_type);
}
put_bits(&s->pb, 1, opt->copyright);
put_bits(&s->pb, 1, opt->original);
if (s->bitstream_id == 6) {
/* alternate bit stream syntax */
put_bits(&s->pb, 1, opt->extended_bsi_1);
if (opt->extended_bsi_1) {
put_bits(&s->pb, 2, opt->preferred_stereo_downmix);
put_bits(&s->pb, 3, s->ltrt_center_mix_level);
put_bits(&s->pb, 3, s->ltrt_surround_mix_level);
put_bits(&s->pb, 3, s->loro_center_mix_level);
put_bits(&s->pb, 3, s->loro_surround_mix_level);
}
put_bits(&s->pb, 1, opt->extended_bsi_2);
if (opt->extended_bsi_2) {
put_bits(&s->pb, 2, opt->dolby_surround_ex_mode);
put_bits(&s->pb, 2, opt->dolby_headphone_mode);
put_bits(&s->pb, 1, opt->ad_converter_type);
put_bits(&s->pb, 9, 0); /* xbsi2 and encinfo : reserved */
}
} else {
put_bits(&s->pb, 1, 0); /* no time code 1 */
put_bits(&s->pb, 1, 0); /* no time code 2 */
}
put_bits(&s->pb, 1, 0); /* no additional bit stream info */
}
@ -1479,6 +1628,268 @@ static void output_frame(AC3EncodeContext *s, unsigned char *frame)
}
static void dprint_options(AVCodecContext *avctx)
{
#ifdef DEBUG
AC3EncodeContext *s = avctx->priv_data;
AC3EncOptions *opt = &s->options;
char strbuf[32];
switch (s->bitstream_id) {
case 6: strncpy(strbuf, "AC-3 (alt syntax)", 32); break;
case 8: strncpy(strbuf, "AC-3 (standard)", 32); break;
case 9: strncpy(strbuf, "AC-3 (dnet half-rate)", 32); break;
case 10: strncpy(strbuf, "AC-3 (dnet quater-rate", 32); break;
default: snprintf(strbuf, 32, "ERROR");
}
av_dlog(avctx, "bitstream_id: %s (%d)\n", strbuf, s->bitstream_id);
av_dlog(avctx, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx->sample_fmt));
av_get_channel_layout_string(strbuf, 32, s->channels, avctx->channel_layout);
av_dlog(avctx, "channel_layout: %s\n", strbuf);
av_dlog(avctx, "sample_rate: %d\n", s->sample_rate);
av_dlog(avctx, "bit_rate: %d\n", s->bit_rate);
if (s->cutoff)
av_dlog(avctx, "cutoff: %d\n", s->cutoff);
av_dlog(avctx, "per_frame_metadata: %s\n",
opt->allow_per_frame_metadata?"on":"off");
if (s->has_center)
av_dlog(avctx, "center_mixlev: %0.3f (%d)\n", opt->center_mix_level,
s->center_mix_level);
else
av_dlog(avctx, "center_mixlev: {not written}\n");
if (s->has_surround)
av_dlog(avctx, "surround_mixlev: %0.3f (%d)\n", opt->surround_mix_level,
s->surround_mix_level);
else
av_dlog(avctx, "surround_mixlev: {not written}\n");
if (opt->audio_production_info) {
av_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level);
switch (opt->room_type) {
case 0: strncpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "large", 32); break;
case 2: strncpy(strbuf, "small", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->room_type);
}
av_dlog(avctx, "room_type: %s\n", strbuf);
} else {
av_dlog(avctx, "mixing_level: {not written}\n");
av_dlog(avctx, "room_type: {not written}\n");
}
av_dlog(avctx, "copyright: %s\n", opt->copyright?"on":"off");
av_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level);
if (s->channel_mode == AC3_CHMODE_STEREO) {
switch (opt->dolby_surround_mode) {
case 0: strncpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "on", 32); break;
case 2: strncpy(strbuf, "off", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_mode);
}
av_dlog(avctx, "dsur_mode: %s\n", strbuf);
} else {
av_dlog(avctx, "dsur_mode: {not written}\n");
}
av_dlog(avctx, "original: %s\n", opt->original?"on":"off");
if (s->bitstream_id == 6) {
if (opt->extended_bsi_1) {
switch (opt->preferred_stereo_downmix) {
case 0: strncpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "ltrt", 32); break;
case 2: strncpy(strbuf, "loro", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->preferred_stereo_downmix);
}
av_dlog(avctx, "dmix_mode: %s\n", strbuf);
av_dlog(avctx, "ltrt_cmixlev: %0.3f (%d)\n",
opt->ltrt_center_mix_level, s->ltrt_center_mix_level);
av_dlog(avctx, "ltrt_surmixlev: %0.3f (%d)\n",
opt->ltrt_surround_mix_level, s->ltrt_surround_mix_level);
av_dlog(avctx, "loro_cmixlev: %0.3f (%d)\n",
opt->loro_center_mix_level, s->loro_center_mix_level);
av_dlog(avctx, "loro_surmixlev: %0.3f (%d)\n",
opt->loro_surround_mix_level, s->loro_surround_mix_level);
} else {
av_dlog(avctx, "extended bitstream info 1: {not written}\n");
}
if (opt->extended_bsi_2) {
switch (opt->dolby_surround_ex_mode) {
case 0: strncpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "on", 32); break;
case 2: strncpy(strbuf, "off", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_ex_mode);
}
av_dlog(avctx, "dsurex_mode: %s\n", strbuf);
switch (opt->dolby_headphone_mode) {
case 0: strncpy(strbuf, "notindicated", 32); break;
case 1: strncpy(strbuf, "on", 32); break;
case 2: strncpy(strbuf, "off", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_headphone_mode);
}
av_dlog(avctx, "dheadphone_mode: %s\n", strbuf);
switch (opt->ad_converter_type) {
case 0: strncpy(strbuf, "standard", 32); break;
case 1: strncpy(strbuf, "hdcd", 32); break;
default: snprintf(strbuf, 32, "ERROR (%d)", opt->ad_converter_type);
}
av_dlog(avctx, "ad_conv_type: %s\n", strbuf);
} else {
av_dlog(avctx, "extended bitstream info 2: {not written}\n");
}
}
#endif
}
#define FLT_OPTION_THRESHOLD 0.01
static int validate_float_option(float v, const float *v_list, int v_list_size)
{
int i;
for (i = 0; i < v_list_size; i++) {
if (v < (v_list[i] + FLT_OPTION_THRESHOLD) &&
v > (v_list[i] - FLT_OPTION_THRESHOLD))
break;
}
if (i == v_list_size)
return -1;
return i;
}
static void validate_mix_level(void *log_ctx, const char *opt_name,
float *opt_param, const float *list,
int list_size, int default_value, int min_value,
int *ctx_param)
{
int mixlev = validate_float_option(*opt_param, list, list_size);
if (mixlev < min_value) {
mixlev = default_value;
if (*opt_param >= 0.0) {
av_log(log_ctx, AV_LOG_WARNING, "requested %s is not valid. using "
"default value: %0.3f\n", opt_name, list[mixlev]);
}
}
*opt_param = list[mixlev];
*ctx_param = mixlev;
}
/**
* Validate metadata options as set by AVOption system.
* These values can optionally be changed per-frame.
*/
static int validate_metadata(AVCodecContext *avctx)
{
AC3EncodeContext *s = avctx->priv_data;
AC3EncOptions *opt = &s->options;
/* validate mixing levels */
if (s->has_center) {
validate_mix_level(avctx, "center_mix_level", &opt->center_mix_level,
cmixlev_options, CMIXLEV_NUM_OPTIONS, 1, 0,
&s->center_mix_level);
}
if (s->has_surround) {
validate_mix_level(avctx, "surround_mix_level", &opt->surround_mix_level,
surmixlev_options, SURMIXLEV_NUM_OPTIONS, 1, 0,
&s->surround_mix_level);
}
/* set audio production info flag */
if (opt->mixing_level >= 0 || opt->room_type >= 0) {
if (opt->mixing_level < 0) {
av_log(avctx, AV_LOG_ERROR, "mixing_level must be set if "
"room_type is set\n");
return AVERROR(EINVAL);
}
if (opt->mixing_level < 80) {
av_log(avctx, AV_LOG_ERROR, "invalid mixing level. must be between "
"80dB and 111dB\n");
return AVERROR(EINVAL);
}
/* default room type */
if (opt->room_type < 0)
opt->room_type = 0;
opt->audio_production_info = 1;
} else {
opt->audio_production_info = 0;
}
/* set extended bsi 1 flag */
if ((s->has_center || s->has_surround) &&
(opt->preferred_stereo_downmix >= 0 ||
opt->ltrt_center_mix_level >= 0 ||
opt->ltrt_surround_mix_level >= 0 ||
opt->loro_center_mix_level >= 0 ||
opt->loro_surround_mix_level >= 0)) {
/* default preferred stereo downmix */
if (opt->preferred_stereo_downmix < 0)
opt->preferred_stereo_downmix = 0;
/* validate Lt/Rt center mix level */
validate_mix_level(avctx, "ltrt_center_mix_level",
&opt->ltrt_center_mix_level, extmixlev_options,
EXTMIXLEV_NUM_OPTIONS, 5, 0,
&s->ltrt_center_mix_level);
/* validate Lt/Rt surround mix level */
validate_mix_level(avctx, "ltrt_surround_mix_level",
&opt->ltrt_surround_mix_level, extmixlev_options,
EXTMIXLEV_NUM_OPTIONS, 6, 3,
&s->ltrt_surround_mix_level);
/* validate Lo/Ro center mix level */
validate_mix_level(avctx, "loro_center_mix_level",
&opt->loro_center_mix_level, extmixlev_options,
EXTMIXLEV_NUM_OPTIONS, 5, 0,
&s->loro_center_mix_level);
/* validate Lo/Ro surround mix level */
validate_mix_level(avctx, "loro_surround_mix_level",
&opt->loro_surround_mix_level, extmixlev_options,
EXTMIXLEV_NUM_OPTIONS, 6, 3,
&s->loro_surround_mix_level);
opt->extended_bsi_1 = 1;
} else {
opt->extended_bsi_1 = 0;
}
/* set extended bsi 2 flag */
if (opt->dolby_surround_ex_mode >= 0 ||
opt->dolby_headphone_mode >= 0 ||
opt->ad_converter_type >= 0) {
/* default dolby surround ex mode */
if (opt->dolby_surround_ex_mode < 0)
opt->dolby_surround_ex_mode = 0;
/* default dolby headphone mode */
if (opt->dolby_headphone_mode < 0)
opt->dolby_headphone_mode = 0;
/* default A/D converter type */
if (opt->ad_converter_type < 0)
opt->ad_converter_type = 0;
opt->extended_bsi_2 = 1;
} else {
opt->extended_bsi_2 = 0;
}
/* set bitstream id for alternate bitstream syntax */
if (opt->extended_bsi_1 || opt->extended_bsi_2) {
if (s->bitstream_id > 8 && s->bitstream_id < 11) {
static int warn_once = 1;
if (warn_once) {
av_log(avctx, AV_LOG_WARNING, "alternate bitstream syntax is "
"not compatible with reduced samplerates. writing of "
"extended bitstream information will be disabled.\n");
warn_once = 0;
}
} else {
s->bitstream_id = 6;
}
}
return 0;
}
/**
* Encode a single AC-3 frame.
*/
@ -1489,6 +1900,12 @@ static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame,
const SampleType *samples = data;
int ret;
if (s->options.allow_per_frame_metadata) {
ret = validate_metadata(avctx);
if (ret)
return ret;
}
if (s->bit_alloc.sr_code == 1)
adjust_frame_size(s);
@ -1597,6 +2014,8 @@ static av_cold int set_channel_info(AC3EncodeContext *s, int channels,
default:
return AVERROR(EINVAL);
}
s->has_center = (s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO;
s->has_surround = s->channel_mode & 0x04;
s->channel_map = ff_ac3_enc_channel_map[s->channel_mode][s->lfe_on];
*channel_layout = ch_layout;
@ -1635,6 +2054,7 @@ static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s)
s->sample_rate = avctx->sample_rate;
s->bit_alloc.sr_shift = i % 3;
s->bit_alloc.sr_code = i / 3;
s->bitstream_id = 8 + s->bit_alloc.sr_shift;
/* validate bit rate */
for (i = 0; i < 19; i++) {
@ -1669,6 +2089,10 @@ static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s)
return AVERROR(EINVAL);
}
ret = validate_metadata(avctx);
if (ret)
return ret;
return 0;
}
@ -1810,7 +2234,6 @@ static av_cold int ac3_encode_init(AVCodecContext *avctx)
if (ret)
return ret;
s->bitstream_id = 8 + s->bit_alloc.sr_shift;
s->bitstream_mode = avctx->audio_service_type;
if (s->bitstream_mode == AV_AUDIO_SERVICE_TYPE_KARAOKE)
s->bitstream_mode = 0x7;
@ -1849,6 +2272,8 @@ static av_cold int ac3_encode_init(AVCodecContext *avctx)
dsputil_init(&s->dsp, avctx);
ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
dprint_options(avctx);
return 0;
init_fail:
ac3_encode_close(avctx);

1
libavcodec/ac3enc_fixed.c
View File

@ -410,5 +410,6 @@ AVCodec ff_ac3_fixed_encoder = {
NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
.priv_class = &ac3enc_class,
.channel_layouts = ac3_channel_layouts,
};

1
libavcodec/ac3enc_float.c
View File

@ -120,5 +120,6 @@ AVCodec ff_ac3_encoder = {
NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
.priv_class = &ac3enc_class,
.channel_layouts = ac3_channel_layouts,
};

3
libavdevice/Makefile
View File

@ -18,6 +18,8 @@ OBJS-$(CONFIG_FBDEV_INDEV) += fbdev.o
OBJS-$(CONFIG_JACK_INDEV) += jack_audio.o
OBJS-$(CONFIG_OSS_INDEV) += oss_audio.o
OBJS-$(CONFIG_OSS_OUTDEV) += oss_audio.o
OBJS-$(CONFIG_SNDIO_INDEV) += sndio_common.o sndio_dec.o
OBJS-$(CONFIG_SNDIO_OUTDEV) += sndio_common.o sndio_enc.o
OBJS-$(CONFIG_V4L2_INDEV) += v4l2.o
OBJS-$(CONFIG_V4L_INDEV) += v4l.o
OBJS-$(CONFIG_VFWCAP_INDEV) += vfwcap.o
@ -27,5 +29,6 @@ OBJS-$(CONFIG_X11_GRAB_DEVICE_INDEV) += x11grab.o
OBJS-$(CONFIG_LIBDC1394_INDEV) += libdc1394.o
SKIPHEADERS-$(HAVE_ALSA_ASOUNDLIB_H) += alsa-audio.h
SKIPHEADERS-$(HAVE_SNDIO_H) += sndio_common.h
include $(SUBDIR)../subdir.mak

1
libavdevice/alldevices.c
View File

@ -45,6 +45,7 @@ void avdevice_register_all(void)
REGISTER_INDEV (FBDEV, fbdev);
REGISTER_INDEV (JACK, jack);
REGISTER_INOUTDEV (OSS, oss);
REGISTER_INOUTDEV (SNDIO, sndio);
REGISTER_INDEV (V4L2, v4l2);
REGISTER_INDEV (V4L, v4l);
REGISTER_INDEV (VFWCAP, vfwcap);

120
libavdevice/sndio_common.c Normal file
View File

@ -0,0 +1,120 @@
/*
* sndio play and grab interface
* Copyright (c) 2010 Jacob Meuser
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdint.h>
#include <sndio.h>
#include "libavformat/avformat.h"
#include "sndio_common.h"
static inline void movecb(void *addr, int delta)
{
SndioData *s = addr;
s->hwpos += delta * s->channels * s->bps;
}
av_cold int ff_sndio_open(AVFormatContext *s1, int is_output,
const char *audio_device)
{
SndioData *s = s1->priv_data;
struct sio_hdl *hdl;
struct sio_par par;
hdl = sio_open(audio_device, is_output ? SIO_PLAY : SIO_REC, 0);
if (!hdl) {
av_log(s1, AV_LOG_ERROR, "Could not open sndio device\n");
return AVERROR(EIO);
}
sio_initpar(&par);
par.bits = 16;
par.sig = 1;
par.le = SIO_LE_NATIVE;
if (is_output)
par.pchan = s->channels;
else
par.rchan = s->channels;
par.rate = s->sample_rate;
if (!sio_setpar(hdl, &par) || !sio_getpar(hdl, &par)) {
av_log(s1, AV_LOG_ERROR, "Impossible to set sndio parameters, "
"channels: %d sample rate: %d\n", s->channels, s->sample_rate);
goto fail;
}
if (par.bits != 16 || par.sig != 1 || par.le != SIO_LE_NATIVE ||
(is_output && (par.pchan != s->channels)) ||
(!is_output && (par.rchan != s->channels)) ||
(par.rate != s->sample_rate)) {
av_log(s1, AV_LOG_ERROR, "Could not set appropriate sndio parameters, "
"channels: %d sample rate: %d\n", s->channels, s->sample_rate);
goto fail;
}
s->buffer_size = par.round * par.bps *
(is_output ? par.pchan : par.rchan);
if (is_output) {
s->buffer = av_malloc(s->buffer_size);
if (!s->buffer) {
av_log(s1, AV_LOG_ERROR, "Could not allocate buffer\n");
goto fail;
}
}
s->codec_id = par.le ? CODEC_ID_PCM_S16LE : CODEC_ID_PCM_S16BE;
s->channels = is_output ? par.pchan : par.rchan;
s->sample_rate = par.rate;
s->bps = par.bps;
sio_onmove(hdl, movecb, s);
if (!sio_start(hdl)) {
av_log(s1, AV_LOG_ERROR, "Could not start sndio\n");
goto fail;
}
s->hdl = hdl;
return 0;
fail:
av_freep(&s->buffer);
if (hdl)
sio_close(hdl);
return AVERROR(EIO);
}
int ff_sndio_close(SndioData *s)
{
av_freep(&s->buffer);
if (s->hdl)
sio_close(s->hdl);
return 0;
}

46
libavdevice/sndio_common.h Normal file
View File

@ -0,0 +1,46 @@
/*
* sndio play and grab interface
* Copyright (c) 2010 Jacob Meuser
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVDEVICE_SNDIO_COMMON_H
#define AVDEVICE_SNDIO_COMMON_H
#include <stdint.h>
#include <sndio.h>
#include "libavformat/avformat.h"
typedef struct {
struct sio_hdl *hdl;
enum CodecID codec_id;
int64_t hwpos;
int64_t softpos;
uint8_t *buffer;
int bps;
int buffer_size;
int buffer_offset;
int channels;
int sample_rate;
} SndioData;
int ff_sndio_open(AVFormatContext *s1, int is_output, const char *audio_device);
int ff_sndio_close(SndioData *s);
#endif /* AVDEVICE_SNDIO_COMMON_H */

108
libavdevice/sndio_dec.c Normal file
View File

@ -0,0 +1,108 @@
/*
* sndio play and grab interface
* Copyright (c) 2010 Jacob Meuser
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdint.h>
#include <sndio.h>
#include "libavformat/avformat.h"
#include "sndio_common.h"
static av_cold int audio_read_header(AVFormatContext *s1,
AVFormatParameters *ap)
{
SndioData *s = s1->priv_data;
AVStream *st;
int ret;
if (ap->sample_rate <= 0 || ap->channels <= 0)
return AVERROR(EINVAL);
st = av_new_stream(s1, 0);
if (!st)
return AVERROR(ENOMEM);
s->sample_rate = ap->sample_rate;
s->channels = ap->channels;
ret = ff_sndio_open(s1, 0, s1->filename);
if (ret < 0)
return ret;
/* take real parameters */
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->codec_id = s->codec_id;
st->codec->sample_rate = s->sample_rate;
st->codec->channels = s->channels;
av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
return 0;
}
static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt)
{
SndioData *s = s1->priv_data;
int64_t bdelay, cur_time;
int ret;
if ((ret = av_new_packet(pkt, s->buffer_size)) < 0)
return ret;
ret = sio_read(s->hdl, pkt->data, pkt->size);
if (ret == 0 || sio_eof(s->hdl)) {
av_free_packet(pkt);
return AVERROR_EOF;
}
pkt->size = ret;
s->softpos += ret;
/* compute pts of the start of the packet */
cur_time = av_gettime();
bdelay = ret + s->hwpos - s->softpos;
/* convert to pts */
pkt->pts = cur_time - ((bdelay * 1000000) /
(s->bps * s->channels * s->sample_rate));
return 0;
}
static av_cold int audio_read_close(AVFormatContext *s1)
{
SndioData *s = s1->priv_data;
ff_sndio_close(s);
return 0;
}
AVInputFormat ff_sndio_demuxer = {
.name = "sndio",
.long_name = NULL_IF_CONFIG_SMALL("sndio audio capture"),
.priv_data_size = sizeof(SndioData),
.read_header = audio_read_header,
.read_packet = audio_read_packet,
.read_close = audio_read_close,
.flags = AVFMT_NOFILE,
};

95
libavdevice/sndio_enc.c Normal file
View File

@ -0,0 +1,95 @@
/*
* sndio play and grab interface
* Copyright (c) 2010 Jacob Meuser
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdint.h>
#include <sndio.h>
#include "libavformat/avformat.h"
#include "sndio_common.h"
static av_cold int audio_write_header(AVFormatContext *s1)
{
SndioData *s = s1->priv_data;
AVStream *st;
int ret;
st = s1->streams[0];
s->sample_rate = st->codec->sample_rate;
s->channels = st->codec->channels;
ret = ff_sndio_open(s1, 1, s1->filename);
return ret;
}
static int audio_write_packet(AVFormatContext *s1, AVPacket *pkt)
{
SndioData *s = s1->priv_data;
uint8_t *buf= pkt->data;
int size = pkt->size;
int len, ret;
while (size > 0) {
len = s->buffer_size - s->buffer_offset;
if (len > size)
len = size;
memcpy(s->buffer + s->buffer_offset, buf, len);
buf += len;
size -= len;
s->buffer_offset += len;
if (s->buffer_offset >= s->buffer_size) {
ret = sio_write(s->hdl, s->buffer, s->buffer_size);
if (ret == 0 || sio_eof(s->hdl))
return AVERROR(EIO);
s->softpos += ret;
s->buffer_offset = 0;
}
}
return 0;
}
static int audio_write_trailer(AVFormatContext *s1)
{
SndioData *s = s1->priv_data;
sio_write(s->hdl, s->buffer, s->buffer_offset);
ff_sndio_close(s);
return 0;
}
AVOutputFormat ff_sndio_muxer = {
.name = "sndio",
.long_name = NULL_IF_CONFIG_SMALL("sndio audio playback"),
.priv_data_size = sizeof(SndioData),
/* XXX: we make the assumption that the soundcard accepts this format */
/* XXX: find better solution with "preinit" method, needed also in
other formats */
.audio_codec = AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
.video_codec = CODEC_ID_NONE,
.write_header = audio_write_header,
.write_packet = audio_write_packet,
.write_trailer = audio_write_trailer,
.flags = AVFMT_NOFILE,
};