File: media_object.h

package info (click to toggle)
bino 1.6.6-3
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 4,636 kB
  • sloc: cpp: 21,288; sh: 4,849; makefile: 314; sed: 16
file content (152 lines) | stat: -rw-r--r-- 6,398 bytes parent folder | download | duplicates (4)
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
/*
 * This file is part of bino, a 3D video player.
 *
 * Copyright (C) 2010, 2011, 2012
 * Martin Lambers <marlam@marlam.de>
 * Joe <cuchac@email.cz>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef MEDIA_OBJECT_H
#define MEDIA_OBJECT_H

#include <string>
#include <vector>

#include "media_data.h"


class media_object
{
private:
    bool _always_convert_to_bgra32;             // Always convert video to BGRA32 format
    std::string _url;                           // The URL of the media object (may be a file)
    bool _is_device;                            // Whether the URL represents a device (e.g. a camera)
    struct ffmpeg_stuff *_ffmpeg;               // FFmpeg related data
    std::vector<std::string> _tag_names;        // Meta data: tag names
    std::vector<std::string> _tag_values;       // Meta data: tag values

    // Set video frame and audio blob templates by extracting the information
    // from the given streams
    void set_video_frame_template(int video_stream, int width_before_avcodec_open, int height_before_avcodec_open);
    void set_audio_blob_template(int audio_stream);
    void set_subtitle_box_template(int subtitle_stream);

    // The threaded implementation can access private members
    friend class read_thread;
    friend class video_decode_thread;
    friend class audio_decode_thread;
    friend class subtitle_decode_thread;

public:

    /* Constructor, Destructor */
    media_object(bool always_convert_to_bgra32 = false);
    ~media_object();

    /*
     * Initialization
     */

    /* Open a media object. The URL may simply be a file name. */
    void open(const std::string &url, const device_request &dev_request);

    /* Get metadata */
    const std::string &url() const;
    size_t tags() const;
    const std::string &tag_name(size_t i) const;
    const std::string &tag_value(size_t i) const;
    const std::string &tag_value(const std::string &tag_name) const;

    /* Get the number of media streams in the file. */
    int video_streams() const;
    int audio_streams() const;
    int subtitle_streams() const;

    /* Activate a media stream for usage. Inactive streams will not be accessible. */
    void video_stream_set_active(int video_stream, bool active);
    void audio_stream_set_active(int audio_stream, bool active);
    void subtitle_stream_set_active(int subtitle_stream, bool active);

    /* Get information about video streams. */
    // Return a video frame with all properties filled in (but without any data).
    // Note that this is only a hint; the properties of actual video frames may differ!
    const video_frame &video_frame_template(int video_stream) const;
    // Return frame rate. This is just informal; usually, the presentation time of each frame
    // should be used (videos do not need to have constant frame rate).
    int video_frame_rate_numerator(int video_stream) const;
    int video_frame_rate_denominator(int video_stream) const;
    // Video stream duration in microseconds.
    int64_t video_duration(int video_stream) const;

    /* Get information about audio streams. */
    // Return an audio blob with all properties filled in (but without any data).
    // Note that this is only a hint; the properties of actual audio blobs may differ!
    const audio_blob &audio_blob_template(int audio_stream) const;
    // Audio stream duration in microseconds.
    int64_t audio_duration(int audio_stream) const;

    /* Get information about subtitle streams. */
    // Return a subtitle box with all properties filled in (but without any data).
    // Note that this is only a hint; the properties of actual subtitle boxes may differ!
    const subtitle_box &subtitle_box_template(int subtitle_stream) const;
    // Subtitle stream duration in microseconds.
    int64_t subtitle_duration(int subtitle_stream) const;

    /*
     * Access media data
     */

    /* Start to read a video frame asynchronously (in a separate thread).
     * The value of 'raw_frames' must be 1 or 2. If it is 2, the two views of the frame
     * are read from two consecutive raw video frames. */
    void start_video_frame_read(int video_stream, int raw_frames);
    /* Wait for the video frame reading to finish, and return the frame.
     * An invalid frame means that EOF was reached. */
    video_frame finish_video_frame_read(int video_stream);

    /* Start to read the given amount of audio data asynchronously (in a separate thread). */
    void start_audio_blob_read(int audio_stream, size_t size);
    /* Wait for the audio data reading to finish, and return the blob.
     * An invalid blob means that EOF was reached. */
    audio_blob finish_audio_blob_read(int audio_stream);

    /* Start to read a subtitle box asynchronously (in a separate thread). */
    void start_subtitle_box_read(int subtitle_stream);
    /* Wait for the subtitle box reading to finish, and return the box.
     * An invalid box means that EOF was reached. */
    subtitle_box finish_subtitle_box_read(int subtitle_stream);

    /* Return the last position in microseconds, of the last packet that was read in any
     * stream. If the position is unkown, the minimum possible value is returned. */
    int64_t tell();

    /* Seek to the given position in microseconds. This affects all streams.
     * Make sure that the position is not out of range!
     * The real position after seeking is only revealed after reading the next video frame,
     * audio blob, or subtitle box. This position may differ from the requested position
     * for various reasons (seeking is only possible to keyframes, seeking is not supported
     * by the stream, ...) */
    void seek(int64_t pos);

    /*
     * Cleanup
     */

    /* When done, close the object and clean up. */
    void close();
};

#endif