blob: 920d3cf8c1e7ec0893e33da675a187ec40675c12 (
plain)
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
130
131
132
133
|
/* Copyright (c) MediaArea.net SARL. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license that can
* be found in the License.html file in the root of the source tree.
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Some containers use mono stream for AES3 (Stereo) grouping
// We need to group the 2-mono streams in one before sending
// data to AES parser
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------
#ifndef MediaInfo_File_ChannelGroupingH
#define MediaInfo_File_ChannelGroupingH
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#include "MediaInfo/File__Analyze.h"
#include <cstring>
//---------------------------------------------------------------------------
namespace MediaInfoLib
{
//***************************************************************************
// Class File_ChannelGrouping
//***************************************************************************
class File_ChannelGrouping : public File__Analyze
{
public :
//In
int8u BitDepth;
int16u SamplingRate;
int8u Endianness;
bool Aligned;
bool CanBePcm;
struct common
{
struct channel
{
int8u* Buffer;
size_t Buffer_Offset;
size_t Buffer_Size;
size_t Buffer_Size_Max;
std::vector<int64u> Offsets_Stream;
std::vector<int64u> Offsets_Buffer;
channel()
{
Buffer=new int8u[32768];
Buffer_Offset=0;
Buffer_Size=0;
Buffer_Size_Max=32768;
}
~channel()
{
delete[] Buffer; //Buffer=NULL;
}
void resize(size_t NewSize)
{
if (NewSize<Buffer_Size_Max)
return;
int8u* Old=Buffer;
if (NewSize<2*Buffer_Size_Max)
Buffer_Size_Max*=2;
else
Buffer_Size_Max=NewSize;
Buffer=new int8u[Buffer_Size_Max];
std::memcpy(Buffer, Old, Buffer_Size);
delete[] Old; //Old=NULL;
}
void optimize()
{
if (Buffer_Offset<Buffer_Size_Max/2)
return;
std::memcpy(Buffer, Buffer+Buffer_Offset, Buffer_Size-Buffer_Offset);
Buffer_Size-=Buffer_Offset;
Buffer_Offset=0;
}
};
vector<channel*> Channels;
channel MergedChannel;
size_t Channel_Current;
std::vector<File__Analyze*> Parsers;
size_t Instances;
size_t Instances_Max;
common()
{
Channel_Current=0;
Instances=0;
Instances_Max=0;
}
~common()
{
for (size_t Pos=0; Pos<Parsers.size(); Pos++)
delete Parsers[Pos];
}
};
int64u StreamID;
common* Common;
int8u Channel_Pos;
int8u Channel_Total;
//Constructor/Destructor
File_ChannelGrouping();
~File_ChannelGrouping();
private :
//Streams management
void Streams_Fill();
void Streams_Finish();
//Buffer - Global
void Read_Buffer_Init ();
void Read_Buffer_Continue ();
void Read_Buffer_Unsynched ();
};
} //NameSpace
#endif
|
