← Back to branch summary

~ubuntu-branches/ubuntu/hardy/avidemux/hardy

« back to all changes in this revision

Viewing changes to avidemux/ADM_libraries/ADM_mplex/inputstrm.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Matvey Kozhev
  • Date: 2007-12-18 13:53:04 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20071218135304-cdqec2lg2bglyz15
Tags: 1:2.4~preview3-0.0ubuntu1
https://launchpad.net/bugs/163287
https://launchpad.net/bugs/126572
https://launchpad.net/bugs/138854
* Upload to Ubuntu. (LP: #163287, LP: #126572)
* debian/changelog: re-added Ubuntu releases.
* debian/control:
  - Require debhelper >= 5.0.51 (for dh_icons) and imagemagick.
  - Build-depend on libsdl1.2-dev instead of libsdl-dev.
  - Build against newer libx264-dev. (LP: #138854)
  - Removed libamrnb-dev, not in Ubuntu yet.
* debian/rules:
  - Install all icon sizes, using convert (upstream installs none).
  - Added missing calls to dh_installmenu, dh_installman, dh_icons and
    dh_desktop.
* debian/menu, debian/avidemux-qt.menu:
  - Corrected package and executable names.
* debian/avidemux-common.install: Install icons.
* debian/avidemux.common.manpages: Install man/avidemux.1.
* debian/links, debian/avidemux-cli.links, debian/avidemux-gtk.links:
  - Link manpages to avidemux.1.gz.
* debian/install, debian/avidemux-qt.install, debian/avidemux-gtk.desktop,
  debian/avidemux-qt.desktop: Install desktop files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_libraries/ADM_mplex/inputstrm.hpp
 
1
 
 
2
/*
 
3
 *  inptstrm.hpp:  Input stream classes for MPEG multiplexing
 
4
 *
 
5
 *  Copyright (C) 2001 Andrew Stevens <andrew.stevens@philips.com>
 
6
 *
 
7
 *
 
8
 *  This program is free software; you can redistribute it and/or
 
9
 *  modify it under the terms of version 2 of the GNU General Public License
 
10
 *  as published by the Free Software Foundation.
 
11
 *
 
12
 *  This program is distributed in the hope that it will be useful,
 
13
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 *  GNU General Public License for more details.
 
16
 *
 
17
 *  You should have received a copy of the GNU General Public License
 
18
 *  along with this program; if not, write to the Free Software
 
19
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
20
 */
 
21
 
 
22
#ifndef __INPUTSTRM_H__
 
23
#define __INPUTSTRM_H__
 
24
 
 
25
#include <stdio.h>
 
26
#include <vector>
 
27
#include <sys/stat.h>
 
28
 
 
29
#include "mjpeg_types.h"
 
30
#include "mpegconsts.h"
 
31
#include "format_codes.h"
 
32
#include "mjpeg_logging.h"
 
33
 
 
34
#include "mplexconsts.hpp"
 
35
#include "bits.hpp"
 
36
#include "aunitbuffer.hpp"
 
37
#include "decodebufmodel.hpp"
 
38
 
 
39
using std::vector;
 
40
 
 
41
class InputStream
 
42
{
 
43
public:
 
44
        InputStream( IBitStream &istream ) :
 
45
                stream_length(0),
 
46
        bs( istream ),
 
47
                eoscan(false),
 
48
                last_buffered_AU(0),
 
49
                decoding_order(0),
 
50
                old_frames(0)
 
51
                {}
 
52
 
 
53
        void SetBufSize( unsigned int buf_size )
 
54
                {
 
55
                        bs.SetBufSize( buf_size );
 
56
                }
 
57
 
 
58
    bitcount_t stream_length;
 
59
 
 
60
protected:
 
61
        off_t      file_length;
 
62
    IBitStream &bs;
 
63
        bool eoscan;
 
64
        
 
65
        unsigned int last_buffered_AU;          // decode seq num of last buffered frame + 1
 
66
        bitcount_t AU_start;
 
67
    uint32_t  syncword;
 
68
    bitcount_t prev_offset;
 
69
    unsigned int decoding_order;
 
70
    unsigned int old_frames;
 
71
 
 
72
};
 
73
 
 
74
class Multiplexor;
 
75
 
 
76
 
 
77
class MuxStream 
 
78
{
 
79
public:
 
80
        MuxStream();
 
81
 
 
82
    void Init( const int strm_id,
 
83
               const unsigned int _buf_scale,
 
84
                           const unsigned int buf_size,
 
85
                           const unsigned int _zero_stuffing,
 
86
                           const bool bufs_in_first, 
 
87
                           const bool always_bufs
 
88
                  );
 
89
 
 
90
        unsigned int BufferSizeCode();
 
91
        inline unsigned int BufferSize() { return buffer_size; }
 
92
        inline unsigned int BufferScale() { return buffer_scale; }
 
93
 
 
94
        
 
95
        inline void SetMaxPacketData( unsigned int max )
 
96
                {
 
97
                        max_packet_data = max;
 
98
                }
 
99
        inline void SetMinPacketData( unsigned int min )
 
100
                {
 
101
                        min_packet_data = min;
 
102
                }
 
103
        inline unsigned int MaxPacketData() { return max_packet_data; }
 
104
        inline unsigned int MinPacketData() { return min_packet_data; }
 
105
    inline bool NewAUNextSector() { return new_au_next_sec; }
 
106
 
 
107
        //
 
108
        //  Read the next packet payload (sub-stream headers plus
 
109
        //  parsed and spliced stream data) for a packet with the
 
110
        //  specified payload capacity.  Update the AU info.
 
111
        //
 
112
 
 
113
        virtual unsigned int ReadPacketPayload(uint8_t *dst, unsigned int to_read) = 0;
 
114
 
 
115
    //
 
116
    // Return the size of the substream headers...
 
117
    //
 
118
    virtual unsigned int StreamHeaderSize() { return 0; }
 
119
 
 
120
public:  // TODO should go protected once encapsulation complete
 
121
        int        stream_id;
 
122
        unsigned int    buffer_scale;
 
123
        unsigned int    buffer_size;
 
124
        DecodeBufModel  bufmodel;
 
125
        unsigned int    max_packet_data;
 
126
        unsigned int    min_packet_data;
 
127
        unsigned int    zero_stuffing;
 
128
        unsigned int    nsec;
 
129
    unsigned int    min_pes_header_len;
 
130
        bool buffers_in_header;
 
131
        bool always_buffers_in_header;
 
132
        bool new_au_next_sec;
 
133
        bool init;
 
134
};
 
135
 
 
136
class DummyMuxStream : public MuxStream
 
137
{
 
138
public:
 
139
    DummyMuxStream( const int strm_id,
 
140
                    const unsigned int buf_scale, 
 
141
                    unsigned int buf_size )
 
142
        {
 
143
            stream_id = strm_id;
 
144
            buffer_scale = buf_scale;
 
145
            buffer_size = buf_size;
 
146
        }
 
147
 
 
148
    unsigned int ReadPacketPayload(uint8_t *dst, unsigned int to_read)
 
149
        {
 
150
            abort();
 
151
            return 0;
 
152
        }
 
153
};
 
154
 
 
155
 
 
156
class ElementaryStream : public InputStream,
 
157
                                                 public MuxStream
 
158
{
 
159
public:
 
160
        enum stream_kind { audio, video, dummy };
 
161
        ElementaryStream( IBitStream &ibs,
 
162
                      Multiplexor &into, 
 
163
                                          stream_kind kind
 
164
                                          );
 
165
    virtual ~ElementaryStream () { }
 
166
        virtual void Close() = 0;
 
167
 
 
168
        bool NextAU();
 
169
        AUnit *Lookahead( unsigned int n = 0);
 
170
        unsigned int BytesToMuxAUEnd(unsigned int sector_transport_size);
 
171
        bool MuxCompleted();
 
172
        virtual bool MuxPossible(clockticks currentSCR );
 
173
        void DemuxedTo( clockticks SCR );
 
174
        void SetTSOffset( clockticks baseTS );
 
175
        void AllDemuxed();
 
176
        inline stream_kind Kind() { return kind; }
 
177
    inline unsigned int BufferMin() { return buffer_min; }
 
178
    inline unsigned int BufferMax() { return buffer_max; }
 
179
    inline clockticks BaseDTS() { return au->DTS; };
 
180
    inline clockticks BasePTS() { return au->PTS; };
 
181
 
 
182
    inline int        DecodeOrder() { return au->dorder; }
 
183
 
 
184
    inline clockticks RequiredDTS( const AUnit *unit )  
 
185
        { return unit->DTS + timestamp_delay; };
 
186
    inline clockticks RequiredPTS( const AUnit *unit ) 
 
187
        { return unit->PTS + timestamp_delay; };
 
188
    inline clockticks RequiredDTS()  
 
189
        { return RequiredDTS(au); };
 
190
    inline clockticks RequiredPTS() 
 
191
        { return  RequiredPTS(au); };
 
192
    inline clockticks NextRequiredDTS()
 
193
        { 
 
194
            AUnit *next = Lookahead();
 
195
            if( next != 0 )
 
196
                return RequiredDTS(next); 
 
197
            else
 
198
                return 0;
 
199
        };
 
200
    inline clockticks NextRequiredPTS()
 
201
        { 
 
202
            AUnit *next = Lookahead();
 
203
            if( next != 0 )
 
204
                return RequiredPTS(next); 
 
205
            else
 
206
                return 0;
 
207
        };
 
208
 
 
209
    void UpdateBufferMinMax();
 
210
 
 
211
        void SetSyncOffset( clockticks timestamp_delay );
 
212
 
 
213
        void BufferAndOutputSector();
 
214
 
 
215
        inline bool BuffersInHeader() { return buffers_in_header; }
 
216
        virtual unsigned int NominalBitRate() = 0;
 
217
        virtual bool RunOutComplete() = 0;
 
218
 
 
219
 
 
220
    /******************************************************************
 
221
     *  Reads the stream data from actual input stream, updates decode
 
222
     *  buffer model and current access unit information from the
 
223
     *  look-ahead scanning buffer to account for bytes_muxed bytes being
 
224
     *  muxed out.  
 
225
     * TODO: No longer needs to be virtual
 
226
     *
 
227
     ******************************************************************/
 
228
        virtual unsigned int ReadPacketPayload(uint8_t *dst, unsigned int to_read);
 
229
 
 
230
    /********************************************************************
 
231
     * Update stream-specific mux state information to reflect muxing of
 
232
     * current AU.  first_in_sector is set true if AU is first muxed into
 
233
     * the current sector.
 
234
     *
 
235
     *******************************************************************/
 
236
 
 
237
    virtual void AUMuxed( bool first_in_sector ) {}
 
238
 
 
239
    /**************************************************************
 
240
     * The size of the stream-specific  sub-header (if any)
 
241
     *************************************************************/
 
242
    virtual unsigned int StreamHeaderSize() { return 0; }
 
243
    
 
244
    /*****************************************************************
 
245
     * Reads/generates the stream-specific sub-header for AUs muxed
 
246
     * since last call AUMuxed( true );
 
247
     ****************************************************************/
 
248
 
 
249
    virtual void ReadStreamHeader( uint8_t *dst, unsigned int len ) {}
 
250
 
 
251
    bitcount_t bytes_read;
 
252
private:
 
253
    void AUBufferLookaheadFill( unsigned int look_ahead);
 
254
 
 
255
//protected:
 
256
public:
 
257
        virtual void FillAUbuffer(unsigned int frames_to_buffer) = 0;
 
258
    virtual void OutputSector() = 0;
 
259
        AUStream aunits;
 
260
        void Muxed( unsigned int bytes_muxed );
 
261
        AUnit *au;
 
262
        clockticks timestamp_delay;
 
263
 
 
264
        unsigned int au_unsent;
 
265
        AUnit *OLDnext();
 
266
        Multiplexor &muxinto;
 
267
        stream_kind kind;
 
268
    unsigned int buffer_min;
 
269
    unsigned int buffer_max;
 
270
    int FRAME_CHUNK;
 
271
                                                                        
 
272
};
 
273
 
 
274
 
 
275
 
 
276
#endif // __INPUTSTRM_H__
 
277
 
 
278
 
 
279
/* 
 
280
 * Local variables:
 
281
 *  c-file-style: "stroustrup"
 
282
 *  tab-width: 4
 
283
 *  indent-tabs-mode: nil
 
284
 * End:
 
285
 */