← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vlc/maverick

« back to all changes in this revision

Viewing changes to src/misc/es_format.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2008-09-17 21:56:14 UTC
  • mfrom: (1.1.17 upstream)
  • Revision ID: james.westby@ubuntu.com-20080917215614-tj0vx8xzd57e52t8
Tags: 0.9.2-1ubuntu1
https://launchpad.net/bugs/270404
https://launchpad.net/bugs/210354
https://launchpad.net/bugs/199870
https://launchpad.net/bugs/261567
* New Upstream Release, exception granted by
    - dktrkranz, norsetto, Hobbsee (via irc). LP: #270404

Changes done in ubuntu:

* add libxul-dev to build-depends
* make sure that vlc is build against libxul in configure. This doesn't
  change anything in the package, but makes it more robust if building
  in an 'unclean' chroot or when modifying the package.
* debian/control: make Vcs-* fields point to the motumedia branch
* add libx264-dev and libass-dev to build-depends
  LP: #210354, #199870
* actually enable libass support by passing --enable-libass to configure
* enable libdca: add libdca-dev to build depends and --enable-libdca
* install the x264 plugin.

Changes already in the pkg-multimedia branch in debian:

* don't install usr/share/vlc/mozilla in debian/mozilla-plugin-vlc.install  
* new upstream .desktop file now registers flash video mimetype LP: #261567
* add Xb-Npp-Applications to mozilla-plugin-vlc
* remove duplicate entries in debian/vlc-nox.install

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/misc/es_format.c
 
1
/*****************************************************************************
 
2
 * es_format.c : es_format_t helpers.
 
3
 *****************************************************************************
 
4
 * Copyright (C) 2008 the VideoLAN team
 
5
 * $Id$
 
6
 *
 
7
 * Author: Laurent Aimar <fenrir@videolan.org>
 
8
 *
 
9
 * This program is free software; you can redistribute it and/or modify
 
10
 * it under the terms of the GNU General Public License as published by
 
11
 * the Free Software Foundation; either version 2 of the License, or
 
12
 * (at your option) any later version.
 
13
 *
 
14
 * This program is distributed in the hope that it will be useful,
 
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
 * GNU General Public License for more details.
 
18
 *
 
19
 * You should have received a copy of the GNU General Public License
 
20
 * along with this program; if not, write to the Free Software
 
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 
22
 *****************************************************************************/
 
23
 
 
24
/*****************************************************************************
 
25
 * Preamble
 
26
 *****************************************************************************/
 
27
 
 
28
#ifdef HAVE_CONFIG_H
 
29
# include "config.h"
 
30
#endif
 
31
 
 
32
#include <vlc_common.h>
 
33
#include <vlc_es.h>
 
34
 
 
35
 
 
36
/*****************************************************************************
 
37
 * BinaryLog: computes the base 2 log of a binary value
 
38
 *****************************************************************************
 
39
 * This functions is used by MaskToShift, to get a bit index from a binary
 
40
 * value.
 
41
 *****************************************************************************/
 
42
static int BinaryLog( uint32_t i )
 
43
{
 
44
    int i_log = 0;
 
45
 
 
46
    if( i == 0 ) return -31337;
 
47
 
 
48
    if( i & 0xffff0000 ) i_log += 16;
 
49
    if( i & 0xff00ff00 ) i_log += 8;
 
50
    if( i & 0xf0f0f0f0 ) i_log += 4;
 
51
    if( i & 0xcccccccc ) i_log += 2;
 
52
    if( i & 0xaaaaaaaa ) i_log += 1;
 
53
 
 
54
    return i_log;
 
55
}
 
56
 
 
57
/**
 
58
 * It transforms a color mask into right and left shifts
 
59
 * FIXME copied from video_output.c
 
60
 */
 
61
static void MaskToShift( int *pi_left, int *pi_right, uint32_t i_mask )
 
62
{
 
63
    uint32_t i_low, i_high;            /* lower hand higher bits of the mask */
 
64
 
 
65
    if( !i_mask )
 
66
    {
 
67
        *pi_left = *pi_right = 0;
 
68
        return;
 
69
    }
 
70
 
 
71
    /* Get bits */
 
72
    i_low = i_high = i_mask;
 
73
 
 
74
    i_low &= - (int32_t)i_low;          /* lower bit of the mask */
 
75
    i_high += i_low;                    /* higher bit of the mask */
 
76
 
 
77
    /* Transform bits into an index. Also deal with i_high overflow, which
 
78
     * is faster than changing the BinaryLog code to handle 64 bit integers. */
 
79
    i_low =  BinaryLog (i_low);
 
80
    i_high = i_high ? BinaryLog (i_high) : 32;
 
81
 
 
82
    /* Update pointers and return */
 
83
    *pi_left =   i_low;
 
84
    *pi_right = (8 - i_high + i_low);
 
85
}
 
86
 
 
87
/* */
 
88
void video_format_FixRgb( video_format_t *p_fmt )
 
89
{
 
90
    /* FIXME find right default mask */
 
91
    if( !p_fmt->i_rmask || !p_fmt->i_gmask || !p_fmt->i_bmask )
 
92
    {
 
93
        switch( p_fmt->i_chroma )
 
94
        {
 
95
        case VLC_FOURCC('R','V','1','5'):
 
96
            p_fmt->i_rmask = 0x7c00;
 
97
            p_fmt->i_gmask = 0x03e0;
 
98
            p_fmt->i_bmask = 0x001f;
 
99
            break;
 
100
 
 
101
        case VLC_FOURCC('R','V','1','6'):
 
102
            p_fmt->i_rmask = 0xf800;
 
103
            p_fmt->i_gmask = 0x07e0;
 
104
            p_fmt->i_bmask = 0x001f;
 
105
            break;
 
106
 
 
107
        case VLC_FOURCC('R','V','2','4'):
 
108
            p_fmt->i_rmask = 0xff0000;
 
109
            p_fmt->i_gmask = 0x00ff00;
 
110
            p_fmt->i_bmask = 0x0000ff;
 
111
            break;
 
112
        case VLC_FOURCC('R','V','3','2'):
 
113
            p_fmt->i_rmask = 0x00ff0000;
 
114
            p_fmt->i_gmask = 0x0000ff00;
 
115
            p_fmt->i_bmask = 0x000000ff;
 
116
            break;
 
117
 
 
118
        default:
 
119
            return;
 
120
        }
 
121
    }
 
122
 
 
123
    MaskToShift( &p_fmt->i_lrshift, &p_fmt->i_rrshift,
 
124
                 p_fmt->i_rmask );
 
125
    MaskToShift( &p_fmt->i_lgshift, &p_fmt->i_rgshift,
 
126
                 p_fmt->i_gmask );
 
127
    MaskToShift( &p_fmt->i_lbshift, &p_fmt->i_rbshift,
 
128
                 p_fmt->i_bmask );
 
129
}
 
130
 
 
131
void es_format_Init( es_format_t *fmt,
 
132
                     int i_cat, vlc_fourcc_t i_codec )
 
133
{
 
134
    fmt->i_cat                  = i_cat;
 
135
    fmt->i_codec                = i_codec;
 
136
    fmt->i_id                   = -1;
 
137
    fmt->i_group                = 0;
 
138
    fmt->i_priority             = 0;
 
139
    fmt->psz_language           = NULL;
 
140
    fmt->psz_description        = NULL;
 
141
 
 
142
    fmt->i_extra_languages      = 0;
 
143
    fmt->p_extra_languages      = NULL;
 
144
 
 
145
    memset( &fmt->audio, 0, sizeof(audio_format_t) );
 
146
    memset( &fmt->audio_replay_gain, 0, sizeof(audio_replay_gain_t) );
 
147
    memset( &fmt->video, 0, sizeof(video_format_t) );
 
148
    memset( &fmt->subs, 0, sizeof(subs_format_t) );
 
149
 
 
150
    fmt->b_packetized           = true;
 
151
    fmt->i_bitrate              = 0;
 
152
    fmt->i_extra                = 0;
 
153
    fmt->p_extra                = NULL;
 
154
}
 
155
 
 
156
int es_format_Copy( es_format_t *dst, const es_format_t *src )
 
157
{
 
158
    int i;
 
159
    memcpy( dst, src, sizeof( es_format_t ) );
 
160
    if( src->psz_language )
 
161
         dst->psz_language = strdup( src->psz_language );
 
162
    if( src->psz_description )
 
163
        dst->psz_description = strdup( src->psz_description );
 
164
    if( src->i_extra > 0 )
 
165
    {
 
166
        dst->i_extra = src->i_extra;
 
167
        dst->p_extra = malloc( src->i_extra );
 
168
        memcpy( dst->p_extra, src->p_extra, src->i_extra );
 
169
    }
 
170
    else
 
171
    {
 
172
        dst->i_extra = 0;
 
173
        dst->p_extra = NULL;
 
174
    }
 
175
 
 
176
    if( src->subs.psz_encoding )
 
177
        dst->subs.psz_encoding = strdup( src->subs.psz_encoding );
 
178
 
 
179
    if( src->video.p_palette )
 
180
    {
 
181
        dst->video.p_palette =
 
182
            (video_palette_t*)malloc( sizeof( video_palette_t ) );
 
183
        memcpy( dst->video.p_palette, src->video.p_palette,
 
184
                sizeof( video_palette_t ) );
 
185
    }
 
186
 
 
187
    dst->i_extra_languages = src->i_extra_languages;
 
188
    if( dst->i_extra_languages )
 
189
        dst->p_extra_languages = (extra_languages_t*)
 
190
            malloc(dst->i_extra_languages * sizeof(*dst->p_extra_languages ));
 
191
    for( i = 0; i < dst->i_extra_languages; i++ ) {
 
192
        if( src->p_extra_languages[i].psz_language )
 
193
            dst->p_extra_languages[i].psz_language = strdup( src->p_extra_languages[i].psz_language );
 
194
        else
 
195
            dst->p_extra_languages[i].psz_language = NULL;
 
196
        if( src->p_extra_languages[i].psz_description )
 
197
            dst->p_extra_languages[i].psz_description = strdup( src->p_extra_languages[i].psz_description );
 
198
        else
 
199
            dst->p_extra_languages[i].psz_description = NULL;
 
200
    }
 
201
    return VLC_SUCCESS;
 
202
}
 
203
 
 
204
void es_format_Clean( es_format_t *fmt )
 
205
{
 
206
    free( fmt->psz_language );
 
207
    free( fmt->psz_description );
 
208
 
 
209
    if( fmt->i_extra > 0 ) free( fmt->p_extra );
 
210
 
 
211
    free( fmt->video.p_palette );
 
212
    free( fmt->subs.psz_encoding );
 
213
 
 
214
    if( fmt->i_extra_languages > 0 && fmt->p_extra_languages )
 
215
    {
 
216
        int i;
 
217
        for( i = 0; i < fmt->i_extra_languages; i++ )
 
218
        {
 
219
            free( fmt->p_extra_languages[i].psz_language );
 
220
            free( fmt->p_extra_languages[i].psz_description );
 
221
        }
 
222
        free( fmt->p_extra_languages );
 
223
    }
 
224
 
 
225
    /* es_format_Clean can be called multiple times */
 
226
    memset( fmt, 0, sizeof(*fmt) );
 
227
}
 
228