← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavformat/segafilm.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:23:28 UTC
  • mfrom: (0.4.7 sid)
  • mto: This revision was merged to the branch mainline in revision 76.
  • Revision ID: package-import@ubuntu.com-20120112222328-8jqdyodym3p84ygu
Tags: 2:1.0~rc4.dfsg1+svn34540-1
* New upstream snapshot
* upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavformat/segafilm.c
29
29
 
30
30
#include "libavutil/intreadwrite.h"
31
31
#include "avformat.h"
 
32
#include "internal.h"
32
33
 
33
34
#define FILM_TAG MKBETAG('F', 'I', 'L', 'M')
34
35
#define FDSC_TAG MKBETAG('F', 'D', 'S', 'C')
35
36
#define STAB_TAG MKBETAG('S', 'T', 'A', 'B')
36
37
#define CVID_TAG MKBETAG('c', 'v', 'i', 'd')
 
38
#define RAW_TAG  MKBETAG('r', 'a', 'w', ' ')
37
39
 
38
40
typedef struct {
39
41
  int stream;
111
113
        film->audio_samplerate = AV_RB16(&scratch[24]);
112
114
        film->audio_channels = scratch[21];
113
115
        film->audio_bits = scratch[22];
114
 
        if (film->audio_bits == 8)
115
 
            film->audio_type = CODEC_ID_PCM_S8;
116
 
        else if (film->audio_bits == 16)
117
 
            film->audio_type = CODEC_ID_PCM_S16BE;
118
 
        else
 
116
        if (scratch[23] == 2)
 
117
            film->audio_type = CODEC_ID_ADPCM_ADX;
 
118
        else if (film->audio_channels > 0) {
 
119
            if (film->audio_bits == 8)
 
120
                film->audio_type = CODEC_ID_PCM_S8;
 
121
            else if (film->audio_bits == 16)
 
122
                film->audio_type = CODEC_ID_PCM_S16BE;
 
123
            else
 
124
                film->audio_type = CODEC_ID_NONE;
 
125
        } else
119
126
            film->audio_type = CODEC_ID_NONE;
120
127
    }
121
128
 
124
131
 
125
132
    if (AV_RB32(&scratch[8]) == CVID_TAG) {
126
133
        film->video_type = CODEC_ID_CINEPAK;
127
 
    } else
 
134
    } else if (AV_RB32(&scratch[8]) == RAW_TAG) {
 
135
        film->video_type = CODEC_ID_RAWVIDEO;
 
136
    } else {
128
137
        film->video_type = CODEC_ID_NONE;
 
138
    }
129
139
 
130
140
    /* initialize the decoder streams */
131
141
    if (film->video_type) {
132
 
        st = av_new_stream(s, 0);
 
142
        st = avformat_new_stream(s, NULL);
133
143
        if (!st)
134
144
            return AVERROR(ENOMEM);
135
145
        film->video_stream_index = st->index;
138
148
        st->codec->codec_tag = 0;  /* no fourcc */
139
149
        st->codec->width = AV_RB32(&scratch[16]);
140
150
        st->codec->height = AV_RB32(&scratch[12]);
 
151
 
 
152
        if (film->video_type == CODEC_ID_RAWVIDEO) {
 
153
            if (scratch[20] == 24) {
 
154
                st->codec->pix_fmt = PIX_FMT_RGB24;
 
155
            } else {
 
156
                av_log(s, AV_LOG_ERROR, "raw video is using unhandled %dbpp\n", scratch[20]);
 
157
                return -1;
 
158
            }
 
159
        }
141
160
    }
142
161
 
143
162
    if (film->audio_type) {
144
 
        st = av_new_stream(s, 0);
 
163
        st = avformat_new_stream(s, NULL);
145
164
        if (!st)
146
165
            return AVERROR(ENOMEM);
147
166
        film->audio_stream_index = st->index;
149
168
        st->codec->codec_id = film->audio_type;
150
169
        st->codec->codec_tag = 1;
151
170
        st->codec->channels = film->audio_channels;
152
 
        st->codec->bits_per_coded_sample = film->audio_bits;
153
171
        st->codec->sample_rate = film->audio_samplerate;
 
172
 
 
173
        if (film->audio_type == CODEC_ID_ADPCM_ADX) {
 
174
            st->codec->bits_per_coded_sample = 18 * 8 / 32;
 
175
            st->codec->block_align = st->codec->channels * 18;
 
176
            st->need_parsing = AVSTREAM_PARSE_FULL;
 
177
        } else {
 
178
            st->codec->bits_per_coded_sample = film->audio_bits;
 
179
            st->codec->block_align = st->codec->channels *
 
180
                st->codec->bits_per_coded_sample / 8;
 
181
        }
 
182
 
154
183
        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
155
184
            st->codec->bits_per_coded_sample;
156
 
        st->codec->block_align = st->codec->channels *
157
 
            st->codec->bits_per_coded_sample / 8;
158
185
    }
159
186
 
160
187
    /* load the sample table */
167
194
    if(film->sample_count >= UINT_MAX / sizeof(film_sample))
168
195
        return -1;
169
196
    film->sample_table = av_malloc(film->sample_count * sizeof(film_sample));
 
197
    if (!film->sample_table)
 
198
        return AVERROR(ENOMEM);
170
199
 
171
200
    for(i=0; i<s->nb_streams; i++)
172
 
        av_set_pts_info(s->streams[i], 33, 1, film->base_clock);
 
201
        avpriv_set_pts_info(s->streams[i], 33, 1, film->base_clock);
173
202
 
174
203
    audio_frame_counter = 0;
175
204
    for (i = 0; i < film->sample_count; i++) {
187
216
            film->sample_table[i].pts *= film->base_clock;
188
217
            film->sample_table[i].pts /= film->audio_samplerate;
189
218
 
190
 
            audio_frame_counter += (film->sample_table[i].sample_size /
191
 
                (film->audio_channels * film->audio_bits / 8));
 
219
            if (film->audio_type == CODEC_ID_ADPCM_ADX)
 
220
                audio_frame_counter += (film->sample_table[i].sample_size * 32 /
 
221
                    (18 * film->audio_channels));
 
222
            else if (film->audio_type != CODEC_ID_NONE)
 
223
                audio_frame_counter += (film->sample_table[i].sample_size /
 
224
                    (film->audio_channels * film->audio_bits / 8));
192
225
        } else {
193
226
            film->sample_table[i].stream = film->video_stream_index;
194
227
            film->sample_table[i].pts = AV_RB32(&scratch[8]) & 0x7FFFFFFF;
227
260
            return AVERROR(ENOMEM);
228
261
        avio_read(pb, pkt->data, sample->sample_size);
229
262
    } else if ((sample->stream == film->audio_stream_index) &&
230
 
        (film->audio_channels == 2)) {
 
263
        (film->audio_channels == 2) &&
 
264
        (film->audio_type != CODEC_ID_ADPCM_ADX)) {
231
265
        /* stereo PCM needs to be interleaved */
232
266
 
233
267
        if (av_new_packet(pkt, sample->sample_size))
238
272
            av_free(film->stereo_buffer);
239
273
            film->stereo_buffer_size = sample->sample_size;
240
274
            film->stereo_buffer = av_malloc(film->stereo_buffer_size);
 
275
            if (!film->stereo_buffer) {
 
276
                film->stereo_buffer_size = 0;
 
277
                return AVERROR(ENOMEM);
 
278
            }
241
279
        }
242
280
 
243
281
        pkt->pos= avio_tell(pb);
283
321
}
284
322
 
285
323
AVInputFormat ff_segafilm_demuxer = {
286
 
    "film_cpk",
287
 
    NULL_IF_CONFIG_SMALL("Sega FILM/CPK format"),
288
 
    sizeof(FilmDemuxContext),
289
 
    film_probe,
290
 
    film_read_header,
291
 
    film_read_packet,
292
 
    film_read_close,
 
324
    .name           = "film_cpk",
 
325
    .long_name      = NULL_IF_CONFIG_SMALL("Sega FILM/CPK format"),
 
326
    .priv_data_size = sizeof(FilmDemuxContext),
 
327
    .read_probe     = film_probe,
 
328
    .read_header    = film_read_header,
 
329
    .read_packet    = film_read_packet,
 
330
    .read_close     = film_read_close,
293
331
};