qaac/qtmoviesource.cpp at master · xiangruipuzhao/qaac · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include "qtmoviesource.h"
#include "qtmoviehelper.h"
#include "itunetags.h"
#include "strcnv.h"

static
Track GetSoundTrack(Movie movie)
{
    size_t count = GetMovieTrackCount(movie);
    for (size_t i = 0; i < count; ++i) {
	Media media = GetTrackMedia(GetMovieIndTrack(movie, i + 1));
	OSType type;
	GetMediaHandlerDescription(media, &type, 0, 0);
	if (type == SoundMediaType)
	    return GetMediaTrack(media);
    }
    throw std::runtime_error("Movie contains no sound track");
}

static SampleFormat
ConvertFromBasicDescription(const AudioStreamBasicDescription &asbd)
{
    SampleFormat format;
    if (asbd.mFormatFlags & kAudioFormatFlagIsSignedInteger)
	format.m_type = SampleFormat::kIsSignedInteger;
    else if (asbd.mFormatFlags & kAudioFormatFlagIsFloat)
	format.m_type = SampleFormat::kIsFloat;
    else
	format.m_type = SampleFormat::kIsUnsignedInteger;

    if (asbd.mFormatFlags & kAudioFormatFlagIsBigEndian)
	format.m_endian = SampleFormat::kIsBigEndian;
    else
	format.m_endian = SampleFormat::kIsLittleEndian;

    format.m_nchannels = asbd.mChannelsPerFrame;
    format.m_rate = static_cast<unsigned>(asbd.mSampleRate);
    format.m_bitsPerSample = asbd.mBitsPerChannel;
    return format;
}

QTMovieSource::QTMovieSource(const std::wstring &path, bool alac_only)
    : m_extraction_complete(false)
{
    try {
	M4ATagParser parser(path);
	if (alac_only && !parser.isALAC())
	    throw std::runtime_error("Not an ALAC file");
	m_tags = parser.getTags();
    } catch (const std::exception&) {
	if (alac_only) throw;
    }
    MovieX movie = MovieX::FromFile(path);
    Track track = GetSoundTrack(movie);
    /*
     * By default, Movie's time scale is not accurate enough, and
     * MovieAudioExtraction produces fewer samples than the original,
     * even if it is just a raw PCM source.
     * So, we must reset the time scale to get accurate extraction.
     */
    DeleteTrackSegment(track, 0, GetTrackDuration(track));
    Media media = GetTrackMedia(track);
    SetMovieTimeScale(movie, GetMediaTimeScale(media));
    InsertMediaIntoTrack(track, 0, 0, GetMediaDuration(media), fixed1);

    m_session = MovieAudioExtractionX::Begin(movie, 0);
    m_session.getAudioStreamBasicDescription(&m_description);
    m_session.getAudioChannelLayout(&m_layout);

    /*
     * MovieAudioExtraction produces non-interleaved PCM by default.
     */
    m_description.mFormatFlags &= ~kLinearPCMFormatFlagIsNonInterleaved;
    /*
     * cf. "scaudiocompress" sample by Apple.
     * MovieAudioExtraction produces 32bit float PCM by default.
     */
    UInt32 mss = m_session.getMaxSampleSize();  // "Real" sample size.
    if (mss > 0 && mss <= 32) {
	m_description.mBitsPerChannel = mss;
	m_description.mFormatFlags &= ~kLinearPCMFormatFlagIsFloat;
	m_description.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
	m_description.mBytesPerFrame
	    = m_description.mBytesPerPacket
	    = (mss >> 3) * m_description.mChannelsPerFrame;
    }
    m_session.setAudioStreamBasicDescription(m_description);
    m_format = ConvertFromBasicDescription(m_description);
    for (size_t i = 0; i < m_layout->mNumberChannelDescriptions; ++i)
	m_chanmap.push_back(m_layout->mChannelDescriptions[i].mChannelLabel);

    setRange(0, static_cast<uint64_t>(GetMediaDuration(media))
       	* m_description.mSampleRate / GetMediaTimeScale(media));
}

void QTMovieSource::skipSamples(int64_t count)
{
    TimeRecord tr;
    m_session.getCurrentTime(&tr);
    tr.value.hi += static_cast<SInt32>(count >> 32);
    tr.value.lo += static_cast<SInt32>(count);
    m_session.setCurrentTime(tr);
}

size_t QTMovieSource::readSamples(void *buffer, size_t nsamples)
{
    nsamples = adjustSamplesToRead(nsamples);
    if (!nsamples || m_extraction_complete)
	return 0;

    UInt32 flags = 0;
    /*
     * We've told MovieAudioExtraction to produce Interleaved samples,
     * so number of buffers is 1
     */

    AudioBufferList abl = { 1, 0 };
    AudioBuffer &ab = abl.mBuffers[0];
    ab.mNumberChannels = m_description.mChannelsPerFrame;
    ab.mData = buffer;
    ab.mDataByteSize = nsamples * m_description.mBytesPerFrame;
    UInt32 npackets = nsamples;
    flags = 0;
    TRYE(MovieAudioExtractionFillBuffer(m_session, &npackets, &abl, &flags));
    if (flags & kQTMovieAudioExtractionComplete)
	m_extraction_complete = true;
    addSamplesRead(npackets);
    return npackets;
}