Statistics
| Branch: | Revision:

ffmpeg / libavcodec / utils.c @ 18f77016

History | View | Annotate | Download (12.8 KB)

1
/*
2
 * utils for libavcodec
3
 * Copyright (c) 2001 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
#include "avcodec.h"
20
#include "dsputil.h"
21
#include "mpegvideo.h"
22

    
23
void *av_mallocz(unsigned int size)
24
{
25
    void *ptr;
26
    ptr = av_malloc(size);
27
    if (!ptr)
28
        return NULL;
29
    memset(ptr, 0, size);
30
    return ptr;
31
}
32

    
33
/* cannot call it directly because of 'void **' casting is not automatic */
34
void __av_freep(void **ptr)
35
{
36
    av_free(*ptr);
37
    *ptr = NULL;
38
}
39

    
40
/* encoder management */
41
AVCodec *first_avcodec;
42

    
43
void register_avcodec(AVCodec *format)
44
{
45
    AVCodec **p;
46
    p = &first_avcodec;
47
    while (*p != NULL) p = &(*p)->next;
48
    *p = format;
49
    format->next = NULL;
50
}
51

    
52
void avcodec_get_context_defaults(AVCodecContext *s){
53
    s->bit_rate= 800*1000;
54
    s->bit_rate_tolerance= s->bit_rate*10;
55
    s->qmin= 2;
56
    s->qmax= 31;
57
    s->rc_eq= "tex^qComp";
58
    s->qcompress= 0.5;
59
    s->max_qdiff= 3;
60
    s->b_quant_factor=1.25;
61
    s->b_quant_offset=1.25;
62
    s->i_quant_factor=-0.8;
63
    s->i_quant_offset=0.0;
64
    s->error_concealment= 3;
65
    s->error_resilience= 1;
66
    s->workaround_bugs= FF_BUG_AUTODETECT;
67
    s->frame_rate = 25 * FRAME_RATE_BASE;
68
    s->gop_size= 50;
69
    s->me_method= ME_EPZS;
70
}
71

    
72
/**
73
 * allocates a AVCodecContext and set it to defaults.
74
 * this can be deallocated by simply calling free() 
75
 */
76
AVCodecContext *avcodec_alloc_context(void){
77
    AVCodecContext *avctx= av_mallocz(sizeof(AVCodecContext));
78
    
79
    if(avctx==NULL) return NULL;
80
    
81
    avcodec_get_context_defaults(avctx);
82
    
83
    return avctx;
84
}
85

    
86
int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
87
{
88
    int ret;
89

    
90
    avctx->codec = codec;
91
    avctx->frame_number = 0;
92
    if (codec->priv_data_size > 0) {
93
        avctx->priv_data = av_mallocz(codec->priv_data_size);
94
        if (!avctx->priv_data) 
95
            return -ENOMEM;
96
    } else {
97
        avctx->priv_data = NULL;
98
    }
99
    ret = avctx->codec->init(avctx);
100
    if (ret < 0) {
101
        av_freep(&avctx->priv_data);
102
        return ret;
103
    }
104
    return 0;
105
}
106

    
107
int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
108
                         const short *samples)
109
{
110
    int ret;
111

    
112
    ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
113
    avctx->frame_number++;
114
    return ret;
115
}
116

    
117
int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
118
                         const AVPicture *pict)
119
{
120
    int ret;
121

    
122
    ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
123
    
124
    emms_c(); //needed to avoid a emms_c() call before every return;
125

    
126
    avctx->frame_number++;
127
    return ret;
128
}
129

    
130
/* decode a frame. return -1 if error, otherwise return the number of
131
   bytes used. If no frame could be decompressed, *got_picture_ptr is
132
   zero. Otherwise, it is non zero */
133
int avcodec_decode_video(AVCodecContext *avctx, AVPicture *picture, 
134
                         int *got_picture_ptr,
135
                         UINT8 *buf, int buf_size)
136
{
137
    int ret;
138

    
139
    ret = avctx->codec->decode(avctx, picture, got_picture_ptr, 
140
                               buf, buf_size);
141

    
142
    emms_c(); //needed to avoid a emms_c() call before every return;
143

    
144
    if (*got_picture_ptr)                           
145
        avctx->frame_number++;
146
    return ret;
147
}
148

    
149
/* decode an audio frame. return -1 if error, otherwise return the
150
   *number of bytes used. If no frame could be decompressed,
151
   *frame_size_ptr is zero. Otherwise, it is the decompressed frame
152
   *size in BYTES. */
153
int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, 
154
                         int *frame_size_ptr,
155
                         UINT8 *buf, int buf_size)
156
{
157
    int ret;
158

    
159
    ret = avctx->codec->decode(avctx, samples, frame_size_ptr, 
160
                               buf, buf_size);
161
    avctx->frame_number++;
162
    return ret;
163
}
164

    
165
int avcodec_close(AVCodecContext *avctx)
166
{
167
    if (avctx->codec->close)
168
        avctx->codec->close(avctx);
169
    av_freep(&avctx->priv_data);
170
    avctx->codec = NULL;
171
    return 0;
172
}
173

    
174
AVCodec *avcodec_find_encoder(enum CodecID id)
175
{
176
    AVCodec *p;
177
    p = first_avcodec;
178
    while (p) {
179
        if (p->encode != NULL && p->id == id)
180
            return p;
181
        p = p->next;
182
    }
183
    return NULL;
184
}
185

    
186
AVCodec *avcodec_find_encoder_by_name(const char *name)
187
{
188
    AVCodec *p;
189
    p = first_avcodec;
190
    while (p) {
191
        if (p->encode != NULL && strcmp(name,p->name) == 0)
192
            return p;
193
        p = p->next;
194
    }
195
    return NULL;
196
}
197

    
198
AVCodec *avcodec_find_decoder(enum CodecID id)
199
{
200
    AVCodec *p;
201
    p = first_avcodec;
202
    while (p) {
203
        if (p->decode != NULL && p->id == id)
204
            return p;
205
        p = p->next;
206
    }
207
    return NULL;
208
}
209

    
210
AVCodec *avcodec_find_decoder_by_name(const char *name)
211
{
212
    AVCodec *p;
213
    p = first_avcodec;
214
    while (p) {
215
        if (p->decode != NULL && strcmp(name,p->name) == 0)
216
            return p;
217
        p = p->next;
218
    }
219
    return NULL;
220
}
221

    
222
AVCodec *avcodec_find(enum CodecID id)
223
{
224
    AVCodec *p;
225
    p = first_avcodec;
226
    while (p) {
227
        if (p->id == id)
228
            return p;
229
        p = p->next;
230
    }
231
    return NULL;
232
}
233

    
234
const char *pix_fmt_str[] = {
235
    "yuv420p",
236
    "yuv422",
237
    "rgb24",
238
    "bgr24",
239
    "yuv422p",
240
    "yuv444p",
241
    "rgba32",
242
    "bgra32",
243
    "yuv410p",
244
    "yuv411p",
245
};
246

    
247
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
248
{
249
    const char *codec_name;
250
    AVCodec *p;
251
    char buf1[32];
252
    char channels_str[100];
253
    int bitrate;
254

    
255
    if (encode)
256
        p = avcodec_find_encoder(enc->codec_id);
257
    else
258
        p = avcodec_find_decoder(enc->codec_id);
259

    
260
    if (p) {
261
        codec_name = p->name;
262
    } else if (enc->codec_name[0] != '\0') {
263
        codec_name = enc->codec_name;
264
    } else {
265
        /* output avi tags */
266
        if (enc->codec_type == CODEC_TYPE_VIDEO) {
267
            snprintf(buf1, sizeof(buf1), "%c%c%c%c", 
268
                     enc->codec_tag & 0xff,
269
                     (enc->codec_tag >> 8) & 0xff,
270
                     (enc->codec_tag >> 16) & 0xff,
271
                     (enc->codec_tag >> 24) & 0xff);
272
        } else {
273
            snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
274
        }
275
        codec_name = buf1;
276
    }
277

    
278
    switch(enc->codec_type) {
279
    case CODEC_TYPE_VIDEO:
280
        snprintf(buf, buf_size,
281
                 "Video: %s%s",
282
                 codec_name, enc->flags & CODEC_FLAG_HQ ? " (hq)" : "");
283
        if (enc->codec_id == CODEC_ID_RAWVIDEO) {
284
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
285
                     ", %s",
286
                     pix_fmt_str[enc->pix_fmt]);
287
        }
288
        if (enc->width) {
289
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
290
                     ", %dx%d, %0.2f fps",
291
                     enc->width, enc->height, 
292
                     (float)enc->frame_rate / FRAME_RATE_BASE);
293
        }
294
        if (encode) {
295
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
296
                     ", q=%d-%d", enc->qmin, enc->qmax);
297
        }
298
        bitrate = enc->bit_rate;
299
        break;
300
    case CODEC_TYPE_AUDIO:
301
        snprintf(buf, buf_size,
302
                 "Audio: %s",
303
                 codec_name);
304
        switch (enc->channels) {
305
            case 1:
306
                strcpy(channels_str, "mono");
307
                break;
308
            case 2:
309
                strcpy(channels_str, "stereo");
310
                break;
311
            case 6:
312
                strcpy(channels_str, "5:1");
313
                break;
314
            default:
315
                sprintf(channels_str, "%d channels", enc->channels);
316
                break;
317
        }
318
        if (enc->sample_rate) {
319
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
320
                     ", %d Hz, %s",
321
                     enc->sample_rate,
322
                     channels_str);
323
        }
324
        
325
        /* for PCM codecs, compute bitrate directly */
326
        switch(enc->codec_id) {
327
        case CODEC_ID_PCM_S16LE:
328
        case CODEC_ID_PCM_S16BE:
329
        case CODEC_ID_PCM_U16LE:
330
        case CODEC_ID_PCM_U16BE:
331
            bitrate = enc->sample_rate * enc->channels * 16;
332
            break;
333
        case CODEC_ID_PCM_S8:
334
        case CODEC_ID_PCM_U8:
335
        case CODEC_ID_PCM_ALAW:
336
        case CODEC_ID_PCM_MULAW:
337
            bitrate = enc->sample_rate * enc->channels * 8;
338
            break;
339
        default:
340
            bitrate = enc->bit_rate;
341
            break;
342
        }
343
        break;
344
    default:
345
        av_abort();
346
    }
347
    if (encode) {
348
        if (enc->flags & CODEC_FLAG_PASS1)
349
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
350
                     ", pass 1");
351
        if (enc->flags & CODEC_FLAG_PASS2)
352
            snprintf(buf + strlen(buf), buf_size - strlen(buf),
353
                     ", pass 2");
354
    }
355
    if (bitrate != 0) {
356
        snprintf(buf + strlen(buf), buf_size - strlen(buf), 
357
                 ", %d kb/s", bitrate / 1000);
358
    }
359
}
360

    
361
/* Picture field are filled with 'ptr' addresses */
362
void avpicture_fill(AVPicture *picture, UINT8 *ptr,
363
                    int pix_fmt, int width, int height)
364
{
365
    int size;
366

    
367
    size = width * height;
368
    switch(pix_fmt) {
369
    case PIX_FMT_YUV420P:
370
        picture->data[0] = ptr;
371
        picture->data[1] = picture->data[0] + size;
372
        picture->data[2] = picture->data[1] + size / 4;
373
        picture->linesize[0] = width;
374
        picture->linesize[1] = width / 2;
375
        picture->linesize[2] = width / 2;
376
        break;
377
    case PIX_FMT_YUV422P:
378
        picture->data[0] = ptr;
379
        picture->data[1] = picture->data[0] + size;
380
        picture->data[2] = picture->data[1] + size / 2;
381
        picture->linesize[0] = width;
382
        picture->linesize[1] = width / 2;
383
        picture->linesize[2] = width / 2;
384
        break;
385
    case PIX_FMT_YUV444P:
386
        picture->data[0] = ptr;
387
        picture->data[1] = picture->data[0] + size;
388
        picture->data[2] = picture->data[1] + size;
389
        picture->linesize[0] = width;
390
        picture->linesize[1] = width;
391
        picture->linesize[2] = width;
392
        break;
393
    case PIX_FMT_RGB24:
394
    case PIX_FMT_BGR24:
395
        picture->data[0] = ptr;
396
        picture->data[1] = NULL;
397
        picture->data[2] = NULL;
398
        picture->linesize[0] = width * 3;
399
        break;
400
    case PIX_FMT_RGBA32:
401
    case PIX_FMT_BGRA32:
402
        picture->data[0] = ptr;
403
        picture->data[1] = NULL;
404
        picture->data[2] = NULL;
405
        picture->linesize[0] = width * 4;
406
        break;
407
    case PIX_FMT_YUV422:
408
        picture->data[0] = ptr;
409
        picture->data[1] = NULL;
410
        picture->data[2] = NULL;
411
        picture->linesize[0] = width * 2;
412
        break;
413
    default:
414
        picture->data[0] = NULL;
415
        picture->data[1] = NULL;
416
        picture->data[2] = NULL;
417
        break;
418
    }
419
}
420

    
421
int avpicture_get_size(int pix_fmt, int width, int height)
422
{
423
    int size;
424

    
425
    size = width * height;
426
    switch(pix_fmt) {
427
    case PIX_FMT_YUV420P:
428
        size = (size * 3) / 2;
429
        break;
430
    case PIX_FMT_YUV422P:
431
        size = (size * 2);
432
        break;
433
    case PIX_FMT_YUV444P:
434
        size = (size * 3);
435
        break;
436
    case PIX_FMT_RGB24:
437
    case PIX_FMT_BGR24:
438
        size = (size * 3);
439
        break;
440
    case PIX_FMT_RGBA32:
441
    case PIX_FMT_BGRA32:
442
        size = (size * 4);
443
        break;
444
    case PIX_FMT_YUV422:
445
        size = (size * 2);
446
        break;
447
    default:
448
        size = -1;
449
        break;
450
    }
451
    return size;
452
}
453

    
454
unsigned avcodec_version( void )
455
{
456
  return LIBAVCODEC_VERSION_INT;
457
}
458

    
459
unsigned avcodec_build( void )
460
{
461
  return LIBAVCODEC_BUILD;
462
}
463

    
464
/* must be called before any other functions */
465
void avcodec_init(void)
466
{
467
    static int inited = 0;
468

    
469
    if (inited != 0)
470
        return;
471
    inited = 1;
472

    
473
    //dsputil_init();
474
}
475

    
476
/* this should be called after seeking and before trying to decode the next frame */
477
void avcodec_flush_buffers(AVCodecContext *avctx)
478
{
479
    MpegEncContext *s = avctx->priv_data;
480
    s->num_available_buffers=0;
481
}
482

    
483

    
484
static int raw_encode_init(AVCodecContext *s)
485
{
486
    return 0;
487
}
488

    
489
static int raw_decode_frame(AVCodecContext *avctx,
490
                            void *data, int *data_size,
491
                            UINT8 *buf, int buf_size)
492
{
493
    return -1;
494
}
495

    
496
static int raw_encode_frame(AVCodecContext *avctx,
497
                            unsigned char *frame, int buf_size, void *data)
498
{
499
    return -1;
500
}
501

    
502
AVCodec rawvideo_codec = {
503
    "rawvideo",
504
    CODEC_TYPE_VIDEO,
505
    CODEC_ID_RAWVIDEO,
506
    0,
507
    raw_encode_init,
508
    raw_encode_frame,
509
    NULL,
510
    raw_decode_frame,
511
};